itkJoinImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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:
  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 true;
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(JoinFunctor);

  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_MOVE(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);

  itkOverrideGetNameOfClassMacro(JoinImageFilter);
 
  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>));
 
protected:
  JoinImageFilter() { Superclass::SetFunctor(FunctorType()); }
  ~JoinImageFilter() override = default;
};
} // end namespace itk
 
#endif