itkRLERegionOfInterestImageFilter.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 itkRLERegionOfInterestImageFilter_h
#define itkRLERegionOfInterestImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkRLEImage.h"
#include "itkRegionOfInterestImageFilter.h"
#include "itkSmartPointer.h"

namespace itk
{
template< typename TPixel, unsigned int VImageDimension, typename CounterType >
class RegionOfInterestImageFilter< RLEImage< TPixel, VImageDimension, CounterType >,
  RLEImage< TPixel, VImageDimension, CounterType > > :
  public ImageToImageFilter< RLEImage< TPixel, VImageDimension, CounterType >,
    RLEImage< TPixel, VImageDimension, CounterType > >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(RegionOfInterestImageFilter);

  using Self = RegionOfInterestImageFilter;
  using RLEImageType = RLEImage< TPixel, VImageDimension, CounterType >;
  using ImageType = RLEImageType;
  using Superclass = ImageToImageFilter< RLEImageType, RLEImageType >;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;
  using InputImageRegionType = typename Superclass::InputImageRegionType;

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  using RegionType = typename RLEImageType::RegionType;
  using IndexType = typename RLEImageType::IndexType;
  using SizeType = typename RLEImageType::SizeType;

  using OutputImagePixelType = typename RLEImageType::PixelType;
  using InputImagePixelType = typename RLEImageType::PixelType;

  itkSetMacro( RegionOfInterest, RegionType );
  itkGetConstMacro( RegionOfInterest, RegionType );

  static constexpr unsigned int ImageDimension = VImageDimension;
  static constexpr unsigned int OutputImageDimension = VImageDimension;

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( SameDimensionCheck, (Concept::SameDimension< ImageDimension, OutputImageDimension > ) );
  itkConceptMacro( InputConvertibleToOutputCheck,
    (Concept::Convertible< InputImagePixelType, OutputImagePixelType > ) );
// End concept checking
#endif

protected:
  RegionOfInterestImageFilter()
    { this->DynamicMultiThreadingOn(); }
  ~RegionOfInterestImageFilter() override {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const override;

  void
  GenerateInputRequestedRegion() override;

  void
  EnlargeOutputRequestedRegion( DataObject* output ) override;

  void
  GenerateOutputInformation() override;

  void
  DynamicThreadedGenerateData( const RegionType& outputRegionForThread ) override;

private:
  RegionType m_RegionOfInterest;
};

template< typename TPixelIn, typename TPixelOut, unsigned int VImageDimension,
  typename CounterTypeIn, typename CounterTypeOut >
class RegionOfInterestImageFilter< RLEImage< TPixelIn, VImageDimension, CounterTypeIn >,
  RLEImage< TPixelOut, VImageDimension, CounterTypeOut > > :
  public ImageToImageFilter< RLEImage< TPixelIn, VImageDimension, CounterTypeIn >,
    RLEImage< TPixelOut, VImageDimension, CounterTypeOut > >
{
public:
  using Self = RegionOfInterestImageFilter;
  using RLEImageTypeIn = RLEImage< TPixelIn, VImageDimension, CounterTypeIn >;
  using RLEImageTypeOut = RLEImage< TPixelOut, VImageDimension, CounterTypeOut >;
  using ImageType = RLEImageTypeOut;
  using Superclass = ImageToImageFilter< RLEImageTypeIn, RLEImageTypeOut >;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;
  using InputImageRegionType = typename Superclass::InputImageRegionType;

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  using RegionType = typename RLEImageTypeIn::RegionType;
  using IndexType = typename RLEImageTypeIn::IndexType;
  using SizeType = typename RLEImageTypeIn::SizeType;

  using OutputImagePixelType = typename RLEImageTypeOut::PixelType;
  using InputImagePixelType = typename RLEImageTypeIn::PixelType;

  itkSetMacro( RegionOfInterest, RegionType );
  itkGetConstMacro( RegionOfInterest, RegionType );

  static constexpr unsigned int ImageDimension = VImageDimension;
  static constexpr unsigned int OutputImageDimension = VImageDimension;

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( SameDimensionCheck, (Concept::SameDimension< ImageDimension, OutputImageDimension > ) );
  itkConceptMacro( InputConvertibleToOutputCheck,
    (Concept::Convertible< InputImagePixelType, OutputImagePixelType > ) );
// End concept checking
#endif

protected:
  RegionOfInterestImageFilter()
    { this->DynamicMultiThreadingOn(); }
  ~RegionOfInterestImageFilter() override {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const override;

  void
  GenerateInputRequestedRegion() override;

  void
  EnlargeOutputRequestedRegion( DataObject* output ) override;

  void
  GenerateOutputInformation() override;

  void
  DynamicThreadedGenerateData( const RegionType& outputRegionForThread ) override;

private:
  RegionOfInterestImageFilter( const Self & ); // purposely not implemented
  void
  operator=( const Self & ); // purposely not implemented

  RegionType m_RegionOfInterest;
};

// not implemented on purpose, so it will produce a meaningful error message
template< unsigned int VImageDimensionIn, unsigned int VImageDimensionOut >
class InputAndOutputImagesMustHaveSameDimension;

// input and output images must have the same dimension (e.g. both 2D or both 3D)
// so disallow this by inheriting from unimplemented base class
template< typename TPixelIn, typename TPixelOut, unsigned int VImageDimensionIn,
  unsigned int VImageDimensionOut, typename CounterTypeIn, typename CounterTypeOut >
class RegionOfInterestImageFilter< RLEImage< TPixelIn, VImageDimensionIn, CounterTypeIn >,
  RLEImage< TPixelOut, VImageDimensionOut, CounterTypeOut > > :
  InputAndOutputImagesMustHaveSameDimension< VImageDimensionIn, VImageDimensionOut >
{
};

template< typename TPixel, unsigned int VImageDimension, typename CounterType >
class RegionOfInterestImageFilter< Image< TPixel, VImageDimension >,
  RLEImage< TPixel, VImageDimension, CounterType > > :
  public ImageToImageFilter< Image< TPixel, VImageDimension >,
    RLEImage< TPixel, VImageDimension, CounterType > >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(RegionOfInterestImageFilter);

  using RLEImageType = RLEImage< TPixel, VImageDimension, CounterType >;

  using Self = RegionOfInterestImageFilter;
  using ImageType = Image< TPixel, VImageDimension >;
  using Superclass = ImageToImageFilter< ImageType, RLEImageType >;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;
  using InputImageRegionType = typename Superclass::InputImageRegionType;

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  using RegionType = typename RLEImageType::RegionType;
  using IndexType = typename RLEImageType::IndexType;
  using SizeType = typename RLEImageType::SizeType;

  using OutputImagePixelType = typename RLEImageType::PixelType;
  using InputImagePixelType = typename RLEImageType::PixelType;

  itkSetMacro( RegionOfInterest, RegionType );
  itkGetConstMacro( RegionOfInterest, RegionType );

  static constexpr unsigned int ImageDimension = VImageDimension;
  static constexpr unsigned int OutputImageDimension = VImageDimension;

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( SameDimensionCheck, (Concept::SameDimension< ImageDimension, OutputImageDimension > ) );
  itkConceptMacro( InputConvertibleToOutputCheck,
    (Concept::Convertible< InputImagePixelType, OutputImagePixelType > ) );
// End concept checking
#endif

protected:
  RegionOfInterestImageFilter()
    { this->DynamicMultiThreadingOn(); }
  ~RegionOfInterestImageFilter() override {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const override;

  void
  GenerateInputRequestedRegion() override;

  void
  EnlargeOutputRequestedRegion( DataObject* output ) override;

  void
  GenerateOutputInformation() override;

  void
  DynamicThreadedGenerateData( const RegionType& outputRegionForThread ) override;

private:
  RegionType m_RegionOfInterest;
};

template< typename TPixel, unsigned int VImageDimension, typename CounterType >
class RegionOfInterestImageFilter< RLEImage< TPixel, VImageDimension, CounterType >,
  Image< TPixel, VImageDimension > > :
  public ImageToImageFilter< RLEImage< TPixel, VImageDimension, CounterType >,
    Image< TPixel, VImageDimension > >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(RegionOfInterestImageFilter);

  using RLEImageType = RLEImage< TPixel, VImageDimension, CounterType >;

  using Self = RegionOfInterestImageFilter;
  using ImageType = Image< TPixel, VImageDimension >;
  using Superclass = ImageToImageFilter< RLEImageType, ImageType >;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;
  using InputImageRegionType = typename Superclass::InputImageRegionType;

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  using RegionType = typename RLEImageType::RegionType;
  using IndexType = typename RLEImageType::IndexType;
  using SizeType = typename RLEImageType::SizeType;

  using OutputImagePixelType = typename RLEImageType::PixelType;
  using InputImagePixelType = typename RLEImageType::PixelType;

  itkSetMacro( RegionOfInterest, RegionType );
  itkGetConstMacro( RegionOfInterest, RegionType );

  static constexpr unsigned int ImageDimension = VImageDimension;
  static constexpr unsigned int OutputImageDimension = VImageDimension;

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( SameDimensionCheck, (Concept::SameDimension< ImageDimension, OutputImageDimension > ) );
  itkConceptMacro( InputConvertibleToOutputCheck,
    (Concept::Convertible< InputImagePixelType, OutputImagePixelType > ) );
// End concept checking
#endif

protected:
  RegionOfInterestImageFilter()
    { this->DynamicMultiThreadingOn(); }
  ~RegionOfInterestImageFilter() override {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const override;

  void
  GenerateInputRequestedRegion() override;

  void
  EnlargeOutputRequestedRegion( DataObject* output ) override;

  void
  GenerateOutputInformation() override;

  void
  DynamicThreadedGenerateData( const RegionType& outputRegionForThread ) override;

private:
  RegionType m_RegionOfInterest;
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRLERegionOfInterestImageFilter.hxx"
#endif

#endif // itkRLERegionOfInterestImageFilter_h