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 "itkBinaryGeneratorImageFilter.h"
#include "itkPixelTraits.h"

namespace itk
{
namespace Functor
{
template< typename TPixel1, typename TPixel2 >
class JoinFunctor
{
public:
  JoinFunctor() = default;
  ~JoinFunctor() = default;

  using Self = JoinFunctor;

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

  static constexpr unsigned int Dimension1 = PixelTraits< TPixel1 >::Dimension;
  static constexpr unsigned int Dimension2 = PixelTraits< TPixel2 >::Dimension;
  static constexpr unsigned int JoinDimension = Dimension1 + Dimension2;

  using JoinType = Vector< JoinValueType, Self::JoinDimension >;

  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 {
  using FunctorType = JoinFunctor< typename TImage1::PixelType,
                       typename TImage2::PixelType >;
  using ImageType = Image< typename FunctorType::JoinType,
                  TImage1 ::ImageDimension >;
};
} //namespace functor

template< typename TInputImage1, typename TInputImage2 >
class JoinImageFilter:
  public BinaryGeneratorImageFilter< TInputImage1,
                                   TInputImage2,
                                   typename
                                   Functor::MakeJoin< TInputImage1,
                                                      TInputImage2 >::ImageType >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(JoinImageFilter);

  static constexpr unsigned int OutputImageDimension = TInputImage1::ImageDimension;

  using Self = JoinImageFilter;

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

  using Superclass = BinaryGeneratorImageFilter< TInputImage1, TInputImage2, OutputImageType >;

  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  itkNewMacro(Self);

  itkTypeMacro(JoinImageFilter, BinaryGeneratorImageFilter);

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin 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 > ) );
  // End concept checking
#endif

protected:
  JoinImageFilter() {Superclass::SetFunctor(FunctorType());}
  ~JoinImageFilter() override = default;
};
} // end namespace itk

#endif