itkStitchImageFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef itkStitchImageFilter_h
#define itkStitchImageFilter_h
 
#include "itkFixedArray.h"
#include "itkTransform.h"
#include "itkImageRegionIterator.h"
#include "itkImageToImageFilter.h"
#include "itkLinearInterpolateImageFunction.h"
#include "itkSize.h"
#include "itkDefaultConvertPixelTraits.h"
#include "itkDataObjectDecorator.h"
 
 
namespace itk
{
  enum class StitchStrategy
  {
    Mean = 0, //use the mean value of all inputs that can provide a pixel vaule
    BorderDistance = 1 //use the value that is largest minimal distance to its image borders (use e.g. if values tend to be not reliable at borders)
  };
 
  std::ostream& operator<< (std::ostream& os, const itk::StitchStrategy& strategy)
  {
    if (itk::StitchStrategy::Mean == strategy)
      os << "Mean";
    else if (itk::StitchStrategy::BorderDistance == strategy)
      os << "BorderDistance";
    else
      os << "unknown";
 
    return os;
  };
 
template< typename TInputImage,
          typename TOutputImage,
          typename TInterpolatorPrecisionType = double,
          typename TTransformPrecisionType = TInterpolatorPrecisionType>
class StitchImageFilter :
  public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
  typedef StitchImageFilter                             Self;
  typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass;
  typedef SmartPointer< Self >                            Pointer;
  typedef SmartPointer< const Self >                      ConstPointer;
 
  typedef TInputImage                           InputImageType;
  typedef TOutputImage                          OutputImageType;
  typedef typename InputImageType::Pointer      InputImagePointer;
  typedef typename InputImageType::ConstPointer InputImageConstPointer;
  typedef typename OutputImageType::Pointer     OutputImagePointer;
  typedef typename InputImageType::RegionType   InputImageRegionType;
 
  itkNewMacro(Self);
 
  itkTypeMacro(StitchImageFilter, ImageToImageFilter);
 
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TOutputImage::ImageDimension);
  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);
 
  typedef ImageBase< itkGetStaticConstMacro(ImageDimension) > ImageBaseType;
 
  typedef Transform< TTransformPrecisionType,
                     itkGetStaticConstMacro(ImageDimension),
                     itkGetStaticConstMacro(ImageDimension) >   TransformType;
  typedef typename TransformType::ConstPointer                  TransformPointerType;
  typedef DataObjectDecorator<TransformType>                    DecoratedTransformType;
  typedef typename DecoratedTransformType::Pointer              DecoratedTransformPointer;
 
 
  typedef InterpolateImageFunction< InputImageType,
                                    TInterpolatorPrecisionType >     InterpolatorType;
  typedef typename InterpolatorType::Pointer InterpolatorPointerType;
 
  typedef typename InterpolatorType::OutputType InterpolatorOutputType;
 
  typedef DefaultConvertPixelTraits< InterpolatorOutputType > InterpolatorConvertType;
 
  typedef typename InterpolatorConvertType::ComponentType ComponentType;
 
  typedef LinearInterpolateImageFunction< InputImageType,
                                          TInterpolatorPrecisionType >   LinearInterpolatorType;
  typedef typename LinearInterpolatorType::Pointer
  LinearInterpolatorPointerType;
 
  typedef Size< itkGetStaticConstMacro(ImageDimension) > SizeType;
 
  typedef typename TOutputImage::IndexType IndexType;
 
  typedef typename InterpolatorType::PointType PointType;
  //typedef typename TOutputImage::PointType            PointType;
 
  typedef typename TOutputImage::PixelType PixelType;
  typedef typename TInputImage::PixelType  InputPixelType;
 
  typedef DefaultConvertPixelTraits<PixelType> PixelConvertType;
 
  typedef typename PixelConvertType::ComponentType PixelComponentType;
 
  typedef ContinuousIndex< TTransformPrecisionType, ImageDimension >
  ContinuousInputIndexType;
 
  typedef typename TOutputImage::RegionType OutputImageRegionType;
 
  typedef typename TOutputImage::SpacingType   SpacingType;
  typedef typename TOutputImage::PointType     OriginPointType;
  typedef typename TOutputImage::DirectionType DirectionType;
 
  using Superclass::GetInput;
 
  typedef ImageBase<ImageDimension> ReferenceImageBaseType;
 
  using Superclass::SetInput;
  void SetInput(const InputImageType* image) override;
  void SetInput(unsigned int index, const InputImageType* image) override;
  virtual void SetInput(unsigned int index, const InputImageType* image, const TransformType* transform);
  virtual void SetInput(unsigned int index, const InputImageType* image, const TransformType* transform, InterpolatorType* interpolator);
 
  const TransformType* GetTransform(unsigned int index) const;
 
  const InterpolatorType* GetInterpolator(unsigned int index) const;
 
  itkSetMacro(Size, SizeType);
  itkGetConstReferenceMacro(Size, SizeType);
 
  itkSetMacro(DefaultPixelValue, PixelType);
  itkGetConstReferenceMacro(DefaultPixelValue, PixelType);
 
  itkSetMacro(OutputSpacing, SpacingType);
  virtual void SetOutputSpacing(const double *values);
 
  itkGetConstReferenceMacro(OutputSpacing, SpacingType);
 
  itkSetMacro(OutputOrigin, OriginPointType);
  virtual void SetOutputOrigin(const double *values);
 
  itkGetConstReferenceMacro(OutputOrigin, OriginPointType);
 
  itkSetMacro(OutputDirection, DirectionType);
  itkGetConstReferenceMacro(OutputDirection, DirectionType);
 
  void SetOutputParametersFromImage(const ImageBaseType *image);
 
  itkSetMacro(OutputStartIndex, IndexType);
 
  itkGetConstReferenceMacro(OutputStartIndex, IndexType);
 
  itkSetInputMacro(ReferenceImage, ReferenceImageBaseType);
 
  itkGetInputMacro(ReferenceImage, ReferenceImageBaseType);
 
  itkSetMacro(UseReferenceImage, bool);
  itkBooleanMacro(UseReferenceImage);
  itkGetConstMacro(UseReferenceImage, bool);
 
  itkSetMacro(StitchStrategy, StitchStrategy);
  itkGetConstMacro(StitchStrategy, StitchStrategy);
 
  virtual void GenerateOutputInformation() ITK_OVERRIDE;
 
  virtual void GenerateInputRequestedRegion() ITK_OVERRIDE;
 
  virtual void BeforeThreadedGenerateData() ITK_OVERRIDE;
 
  virtual void AfterThreadedGenerateData() ITK_OVERRIDE;
 
  ModifiedTimeType GetMTime(void) const ITK_OVERRIDE;
 
#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( OutputHasNumericTraitsCheck,
                   ( Concept::HasNumericTraits< PixelComponentType > ) );
  // End concept checking
#endif
 
protected:
  StitchImageFilter();
  ~StitchImageFilter() ITK_OVERRIDE {}
  void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
 
  virtual void VerifyInputInformation() const ITK_OVERRIDE { }
 
  virtual void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread,
                                    ThreadIdType threadId) ITK_OVERRIDE;
 
  virtual PixelType CastPixelWithBoundsChecking( const InterpolatorOutputType value,
                                                 const ComponentType minComponent,
                                                 const ComponentType maxComponent) const;
 
  void SetTransform(unsigned int index, const TransformType* transform);
 
  void EnsureTransforms();
 
  void EnsureInterpolators();
 
  static std::string GetTransformInputName(unsigned int index);
 
private:
  ITK_DISALLOW_COPY_AND_ASSIGN(StitchImageFilter);
 
  typedef std::vector<const InputImageType*> InputImageVectorType;
  typedef std::map<const InputImageType*, typename TransformType::ConstPointer> TransformMapType;
  typedef std::map<const InputImageType*, InterpolatorPointerType> InterpolatorMapType;
 
  InputImageVectorType GetInputs();
  TransformMapType GetTransforms();
 
  InterpolatorMapType m_Interpolators;   // Image function for
                                          // interpolation
  PixelType m_DefaultPixelValue;          // default pixel value
                                          // if the point is
                                          // outside the image
  SizeType        m_Size;                 // Size of the output image
  SpacingType     m_OutputSpacing;        // output image spacing
  OriginPointType m_OutputOrigin;         // output image origin
  DirectionType   m_OutputDirection;      // output image direction cosines
  IndexType       m_OutputStartIndex;     // output image start index
  bool            m_UseReferenceImage;
  StitchStrategy  m_StitchStrategy;
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkStitchImageFilter.tpp"
#endif
 
#endif