itkJoinImageFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkJoinImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2008-10-09 16:20:18 $
  Version:   $Revision: 1.17 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#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)
    {
    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)
    {
    FirstCopier(CopierDispatch<Dimension1>(), out, idx, A);
    }

  void FirstCopier(CopierDispatchBase,
                   JoinType& out, unsigned int idx, const TPixel1& A)
    {
    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)
    { out[idx] = static_cast<JoinValueType>(A); }

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

  void SecondCopier(CopierDispatchBase,
                    JoinType& out, unsigned int idx, const TPixel2& B)
    {
    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)
    {
    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,
                ::itk::GetImageDimension<TImage1>::ImageDimension> ImageType;
};

} //namespace functor
  
template <class TInputImage1, class TInputImage2>
class ITK_EXPORT JoinImageFilter:
  public BinaryFunctorImageFilter<TInputImage1,
                                  TInputImage2,
                                  ITK_TYPENAME
                                  Functor::MakeJoin<TInputImage1,
                                                    TInputImage2>::ImageType,
                                  ITK_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