1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkShrinkImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-22 16:26:45 $
Version: $Revision: 1.42 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
Portions of this code are covered under the VTK copyright.
See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef __itkShrinkImageFilter_h
#define __itkShrinkImageFilter_h
#include "itkImageToImageFilter.h"
namespace itk
{
/** \class ShrinkImageFilter
* \brief Reduce the size of an image by an integer factor in each
* dimension.
*
* ShrinkImageFilter reduces the size of an image by an integer factor
* in each dimension. The algorithm implemented is a simple subsample.
* The output image size in each dimension is given by:
*
* outputSize[j] = max( vcl_floor(inputSize[j]/shrinkFactor[j]), 1 );
*
* Since this filter produces an image which is a different resolution
* and with different pixel spacing than its input image,
* it needs to override several of the methods defined
* in ProcessObject in order to properly manage the pipeline execution model.
* In particular, this filter overrides
* ProcessObject::GenerateInputRequestedRegion() and
* ProcessObject::GenerateOutputInformation().
*
* This filter is implemented as a multithreaded filter. It provides a
* ThreadedGenerateData() method for its implementation.
*
* \ingroup GeometricTransforms
*/
template <class TInputImage, class TOutputImage>
class ITK_EXPORT ShrinkImageFilter:
public ImageToImageFilter<TInputImage,TOutputImage>
{
public:
/** Standard class typedefs. */
typedef ShrinkImageFilter Self;
typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(ShrinkImageFilter, ImageToImageFilter);
/** Typedef to images */
typedef TOutputImage OutputImageType;
typedef TInputImage InputImageType;
typedef typename OutputImageType::Pointer OutputImagePointer;
typedef typename InputImageType::Pointer InputImagePointer;
typedef typename InputImageType::ConstPointer InputImageConstPointer;
/** Typedef to describe the output image region type. */
typedef typename TOutputImage::RegionType OutputImageRegionType;
/** ImageDimension enumeration. */
itkStaticConstMacro(ImageDimension, unsigned int,
TInputImage::ImageDimension );
itkStaticConstMacro(OutputImageDimension, unsigned int,
TOutputImage::ImageDimension );
/** Set the shrink factors. Values are clamped to
* a minimum value of 1. Default is 1 for all dimensions. */
void SetShrinkFactors( unsigned int factors[] );
void SetShrinkFactors( unsigned int factor );
void SetShrinkFactor( unsigned int i, unsigned int factor )
{
m_ShrinkFactors[i] = factor;
}
/** Get the shrink factors. */
const unsigned int * GetShrinkFactors() const
{ return m_ShrinkFactors; }
/** ShrinkImageFilter produces an image which is a different
* resolution and with a different pixel spacing than its input
* image. As such, ShrinkImageFilter needs to provide an
* implementation for GenerateOutputInformation() in order to inform
* the pipeline execution model. The original documentation of this
* method is below.
* \sa ProcessObject::GenerateOutputInformaton() */
virtual void GenerateOutputInformation();
/** ShrinkImageFilter needs a larger input requested region than the output
* requested region. As such, ShrinkImageFilter needs to provide an
* implementation for GenerateInputRequestedRegion() in order to inform the
* pipeline execution model.
* \sa ProcessObject::GenerateInputRequestedRegion() */
virtual void GenerateInputRequestedRegion();
virtual void EnlargeOutputRequestedRegion(DataObject *output);
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(InputConvertibleToOutputCheck,
(Concept::Convertible<typename TInputImage::PixelType, typename TOutputImage::PixelType>));
itkConceptMacro(SameDimensionCheck,
(Concept::SameDimension<ImageDimension, OutputImageDimension>));
/** End concept checking */
#endif
protected:
ShrinkImageFilter();
~ShrinkImageFilter() {};
void PrintSelf(std::ostream& os, Indent indent) const;
/** ShrinkImageFilter can be implemented as a multithreaded filter.
* Therefore, this implementation provides a ThreadedGenerateData() routine
* which is called for each processing thread. The output image data is
* allocated automatically by the superclass prior to calling
* ThreadedGenerateData(). ThreadedGenerateData can only write to the
* portion of the output image specified by the parameter
* "outputRegionForThread"
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
int threadId );
private:
ShrinkImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
unsigned int m_ShrinkFactors[ImageDimension];
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkShrinkImageFilter.txx"
#endif
#endif
|