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:
  typedef RegionOfInterestImageFilter                      Self;
  typedef RLEImage< TPixel, VImageDimension, CounterType > RLEImageType;
  typedef RLEImageType                                     ImageType;
  typedef ImageToImageFilter< RLEImageType, RLEImageType > Superclass;
  typedef SmartPointer< Self >                             Pointer;
  typedef SmartPointer< const Self >                       ConstPointer;
  typedef typename Superclass::InputImageRegionType        InputImageRegionType;

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  typedef typename RLEImageType::RegionType RegionType;
  typedef typename RLEImageType::IndexType  IndexType;
  typedef typename RLEImageType::SizeType   SizeType;

  typedef typename RLEImageType::PixelType OutputImagePixelType;
  typedef typename RLEImageType::PixelType InputImagePixelType;

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

  itkStaticConstMacro( ImageDimension, unsigned int, VImageDimension );
  itkStaticConstMacro( OutputImageDimension, unsigned int, 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() {}
  ~RegionOfInterestImageFilter() {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const;

  virtual void
  GenerateInputRequestedRegion();

  virtual void
  EnlargeOutputRequestedRegion( DataObject* output );

  virtual void
  GenerateOutputInformation();

  void
  ThreadedGenerateData( const RegionType& outputRegionForThread, ThreadIdType threadId );

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

  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:
  typedef RegionOfInterestImageFilter                            Self;
  typedef RLEImage< TPixelIn, VImageDimension, CounterTypeIn >   RLEImageTypeIn;
  typedef RLEImage< TPixelOut, VImageDimension, CounterTypeOut > RLEImageTypeOut;
  typedef RLEImageTypeOut                                        ImageType;
  typedef ImageToImageFilter< RLEImageTypeIn, RLEImageTypeOut >  Superclass;
  typedef SmartPointer< Self >                                   Pointer;
  typedef SmartPointer< const Self >                             ConstPointer;
  typedef typename Superclass::InputImageRegionType              InputImageRegionType;

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  typedef typename RLEImageTypeIn::RegionType RegionType;
  typedef typename RLEImageTypeIn::IndexType  IndexType;
  typedef typename RLEImageTypeIn::SizeType   SizeType;

  typedef typename RLEImageTypeOut::PixelType OutputImagePixelType;
  typedef typename RLEImageTypeIn::PixelType  InputImagePixelType;

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

  itkStaticConstMacro( ImageDimension, unsigned int, VImageDimension );
  itkStaticConstMacro( OutputImageDimension, unsigned int, 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() {}
  ~RegionOfInterestImageFilter() {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const;

  virtual void
  GenerateInputRequestedRegion();

  virtual void
  EnlargeOutputRequestedRegion( DataObject* output );

  virtual void
  GenerateOutputInformation();

  void
  ThreadedGenerateData( const RegionType& outputRegionForThread, ThreadIdType threadId );

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:
  typedef RLEImage< TPixel, VImageDimension, CounterType > RLEImageType;

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

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  typedef typename RLEImageType::RegionType RegionType;
  typedef typename RLEImageType::IndexType  IndexType;
  typedef typename RLEImageType::SizeType   SizeType;

  typedef typename RLEImageType::PixelType OutputImagePixelType;
  typedef typename RLEImageType::PixelType InputImagePixelType;

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

  itkStaticConstMacro( ImageDimension, unsigned int, VImageDimension );
  itkStaticConstMacro( OutputImageDimension, unsigned int, 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() {}
  ~RegionOfInterestImageFilter() {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const;

  virtual void
  GenerateInputRequestedRegion();

  virtual void
  EnlargeOutputRequestedRegion( DataObject* output );

  virtual void
  GenerateOutputInformation();

  void
  ThreadedGenerateData( const RegionType& outputRegionForThread, ThreadIdType threadId );

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

  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:
  typedef RLEImage< TPixel, VImageDimension, CounterType > RLEImageType;

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

  itkNewMacro( Self );

  itkTypeMacro( RegionOfInterestImageFilter, ImageToImageFilter );

  typedef typename RLEImageType::RegionType RegionType;
  typedef typename RLEImageType::IndexType  IndexType;
  typedef typename RLEImageType::SizeType   SizeType;

  typedef typename RLEImageType::PixelType OutputImagePixelType;
  typedef typename RLEImageType::PixelType InputImagePixelType;

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

  itkStaticConstMacro( ImageDimension, unsigned int, VImageDimension );
  itkStaticConstMacro( OutputImageDimension, unsigned int, 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() {}
  ~RegionOfInterestImageFilter() {}
  void
  PrintSelf( std::ostream& os, Indent indent ) const;

  virtual void
  GenerateInputRequestedRegion();

  virtual void
  EnlargeOutputRequestedRegion( DataObject* output );

  virtual void
  GenerateOutputInformation();

  void
  ThreadedGenerateData( const RegionType& outputRegionForThread, ThreadIdType threadId );

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

  RegionType m_RegionOfInterest;
};
} // end namespace itk

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

#endif // itkRLERegionOfInterestImageFilter_h