itkJoinImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkJoinImageFilter_h
#define __itkJoinImageFilter_h

#include "itkBinaryFunctorImageFilter.h"
#include "itkPixelTraits.h"

namespace itk
{
namespace Functor
{
template< class TPixel1, class TPixel2 >
class JoinFunctor
{
public:
  JoinFunctor() {}
  ~JoinFunctor() {}

  typedef JoinFunctor Self;

  typedef typename PixelTraits< TPixel1 >::ValueType               ValueType1;
  typedef typename PixelTraits< TPixel2 >::ValueType               ValueType2;
  typedef typename JoinTraits< ValueType1, ValueType2 >::ValueType JoinValueType;

  itkStaticConstMacro(Dimension1, unsigned int,
                      PixelTraits< TPixel1 >::Dimension);
  itkStaticConstMacro(Dimension2, unsigned int,
                      PixelTraits< TPixel2 >::Dimension);
  itkStaticConstMacro(JoinDimension, unsigned int,
                      Dimension1 + Dimension2);

  typedef Vector< JoinValueType, itkGetStaticConstMacro(JoinDimension) > JoinType;

  bool operator!=(const JoinFunctor &) const
  {
    return false;
  }

  bool operator==(const JoinFunctor & other) const
  {
    return !( *this != other );
  }

  inline JoinType operator()(const TPixel1 & A, const TPixel2 & B) const
  {
    JoinType out;

    // Copy A into the output, casting as necessary
    this->FirstCopier(out, 0, A);

    // Copy B into the output, starting where A left off,casting as necessary
    this->SecondCopier(out, Dimension1, B);

    return out;
  }

private:
  struct CopierDispatchBase {};
  template< unsigned int VDimension >
  struct CopierDispatch:public CopierDispatchBase {};

  void FirstCopier(JoinType & out, unsigned int idx, const TPixel1 & A) const
  {
    FirstCopier(CopierDispatch< Dimension1 >(), out, idx, A);
  }

  void FirstCopier(CopierDispatchBase,
                   JoinType & out, unsigned int idx, const TPixel1 & A) const
  {
    for ( unsigned int i = 0; i < Dimension1; i++, idx++ )
      {
      out[idx] = static_cast< JoinValueType >( A[i] );
      }
  }

  void FirstCopier(CopierDispatch< 1 >,
                   JoinType & out, unsigned int idx, const TPixel1 & A) const
  { out[idx] = static_cast< JoinValueType >( A ); }

  void SecondCopier(JoinType & out, unsigned int idx, const TPixel2 & B) const
  {
    SecondCopier(CopierDispatch< Dimension2 >(), out, idx, B);
  }

  void SecondCopier(CopierDispatchBase,
                    JoinType & out, unsigned int idx, const TPixel2 & B) const
  {
    for ( unsigned int i = 0; i < Dimension2; i++, idx++ )
      {
      out[idx] = static_cast< JoinValueType >( B[i] );
      }
  }

  void SecondCopier(CopierDispatch< 1 >,
                    JoinType & out, unsigned int idx, const TPixel2 & B) const
  {
    out[idx] = static_cast< JoinValueType >( B );
  }
};  //class JoinFunction

template< typename TImage1, typename TImage2 >
struct MakeJoin {
  typedef JoinFunctor< typename TImage1::PixelType,
                       typename TImage2::PixelType > FunctorType;
  typedef Image< typename FunctorType::JoinType,
                  TImage1 ::ImageDimension > ImageType;
};
} //namespace functor

template< class TInputImage1, class TInputImage2 >
class ITK_EXPORT JoinImageFilter:
  public BinaryFunctorImageFilter< TInputImage1,
                                   TInputImage2,
                                   typename
                                   Functor::MakeJoin< TInputImage1,
                                                      TInputImage2 >::ImageType,
                                   typename
                                   Functor::MakeJoin< TInputImage1,
                                                      TInputImage2 >::FunctorType >
{
public:
  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TInputImage1::ImageDimension);

  typedef JoinImageFilter Self;

  typedef typename Functor::MakeJoin< TInputImage1,
                                      TInputImage2 >::FunctorType FunctorType;
  typedef typename Functor::MakeJoin< TInputImage1,
                                      TInputImage2 >::ImageType OutputImageType;
  typedef typename FunctorType::JoinType OutputImagePixelType;

  typedef BinaryFunctorImageFilter< TInputImage1, TInputImage2, OutputImageType,
                                    FunctorType > Superclass;

  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(JoinImageFilter, BinaryFunctorImageFilter);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro( Input1HasPixelTraitsCheck,
                   ( Concept::HasPixelTraits< typename TInputImage1::PixelType > ) );
  itkConceptMacro( Input2HasPixelTraitsCheck,
                   ( Concept::HasPixelTraits< typename TInputImage2::PixelType > ) );
  itkConceptMacro( Input1Input2HasJoinTraitsCheck,
                   ( Concept::HasJoinTraits< typename PixelTraits< typename TInputImage1::PixelType >::ValueType,
                                             typename PixelTraits< typename TInputImage2::PixelType >::ValueType > ) );

#endif

protected:
  JoinImageFilter() {}
  virtual ~JoinImageFilter() {}

private:
  JoinImageFilter(const Self &); //purposely not implemented
  void operator=(const Self &);  //purposely not implemented
};
} // end namespace itk

#endif