itkGenericMultiResolutionPyramidImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  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 __itkGenericMultiResolutionPyramidImageFilter_h
#define __itkGenericMultiResolutionPyramidImageFilter_h
 
#include "itkMultiResolutionPyramidImageFilter.h"
#include "itkSmoothingRecursiveGaussianImageFilter.h"
 
namespace itk
{
template< class TInputImage, class TOutputImage, class TPrecisionType = double >
class GenericMultiResolutionPyramidImageFilter :
  public MultiResolutionPyramidImageFilter< TInputImage, TOutputImage >
{
public:
 
  typedef GenericMultiResolutionPyramidImageFilter Self;
  typedef MultiResolutionPyramidImageFilter<
    TInputImage, TOutputImage >           Superclass;
  typedef typename Superclass::Superclass SuperSuperclass;
  typedef SmartPointer< Self >            Pointer;
  typedef SmartPointer< const Self >      ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( GenericMultiResolutionPyramidImageFilter,
    MultiResolutionPyramidImageFilter );
 
  itkStaticConstMacro( ImageDimension, unsigned int,
    TInputImage::ImageDimension );
  itkStaticConstMacro( OutputImageDimension, unsigned int,
    TOutputImage::ImageDimension );
 
  typedef typename Superclass::ScheduleType                   ScheduleType;
  typedef typename Superclass::InputImageType                 InputImageType;
  typedef typename Superclass::OutputImageType                OutputImageType;
  typedef typename Superclass::InputImagePointer              InputImagePointer;
  typedef typename Superclass::OutputImagePointer             OutputImagePointer;
  typedef typename Superclass::InputImageConstPointer         InputImageConstPointer;
  typedef typename Superclass::InputImageType::SpacingType    SpacingType;
  typedef typename InputImageType::PixelType                  PixelType;
  typedef typename NumericTraits< PixelType >::ScalarRealType ScalarRealType;
 
  typedef Array2D< ScalarRealType > SmoothingScheduleType;
  typedef ScheduleType              RescaleScheduleType;
 
  typedef FixedArray< ScalarRealType,
    itkGetStaticConstMacro( ImageDimension ) > SigmaArrayType;
  typedef SigmaArrayType RescaleFactorArrayType;
 
  void SetSchedule( const ScheduleType & schedule ) override;
 
  virtual void SetRescaleSchedule( const RescaleScheduleType & schedule );
 
  virtual void SetRescaleScheduleToUnity( void );
 
  const RescaleScheduleType & GetRescaleSchedule( void ) const
  {
    return this->m_Schedule;
  }
 
 
  virtual void SetSmoothingSchedule( const SmoothingScheduleType & schedule );
 
  virtual void SetSmoothingScheduleToZero( void );
 
  itkGetConstReferenceMacro( SmoothingSchedule, SmoothingScheduleType );
 
  void SetNumberOfLevels( unsigned int num ) override;
 
  virtual void SetCurrentLevel( unsigned int level );
 
  itkGetConstReferenceMacro( CurrentLevel, unsigned int );
 
  virtual void SetComputeOnlyForCurrentLevel( const bool _arg );
 
  itkGetConstMacro( ComputeOnlyForCurrentLevel, bool );
  itkBooleanMacro( ComputeOnlyForCurrentLevel );
 
#ifdef ITK_USE_CONCEPT_CHECKING
  itkConceptMacro( SameDimensionCheck,
    ( Concept::SameDimension< ImageDimension, OutputImageDimension > ) );
  itkConceptMacro( OutputHasNumericTraitsCheck,
    ( Concept::HasNumericTraits< typename TOutputImage::PixelType > ) );
#endif
 
protected:
 
  GenericMultiResolutionPyramidImageFilter();
  ~GenericMultiResolutionPyramidImageFilter() override {}
 
  void PrintSelf( std::ostream & os, Indent indent ) const override;
 
  void GenerateOutputInformation( void ) override;
 
  void GenerateOutputRequestedRegion( DataObject * output ) override;
 
  void GenerateInputRequestedRegion( void ) override;
 
  void GenerateData( void ) override;
 
  void ReleaseOutputs( void );
 
  SmoothingScheduleType m_SmoothingSchedule;
  unsigned int          m_CurrentLevel;
  bool                  m_ComputeOnlyForCurrentLevel;
  bool                  m_SmoothingScheduleDefined;
 
private:
 
  typedef SmoothingRecursiveGaussianImageFilter<
    InputImageType, OutputImageType > SmootherType;
 
  typedef ImageToImageFilter< OutputImageType, OutputImageType >
    ImageToImageFilterSameTypes;
  typedef ImageToImageFilter< InputImageType, OutputImageType >
    ImageToImageFilterDifferentTypes;
 
  bool SetupSmoother( const unsigned int level,
    typename SmootherType::Pointer & smoother,
    const InputImageConstPointer & input );
 
  int SetupShrinkerOrResampler( const unsigned int level,
    typename SmootherType::Pointer & smoother,
    const bool sameType,
    const InputImageConstPointer & input,
    const OutputImagePointer & outputPtr,
    typename ImageToImageFilterSameTypes::Pointer & rescaleSameTypes,
    typename ImageToImageFilterDifferentTypes::Pointer & rescaleDifferentTypes );
 
  void DefineShrinkerOrResampler(
    const bool sameType,
    const RescaleFactorArrayType & shrinkFactors,
    const OutputImagePointer & outputPtr,
    typename ImageToImageFilterSameTypes::Pointer & rescaleSameTypes,
    typename ImageToImageFilterDifferentTypes::Pointer & rescaleDifferentTypes );
 
  void SetSmoothingScheduleToDefault( void );
 
  bool ComputeForCurrentLevel( const unsigned int level ) const;
 
  double GetDefaultSigma( const unsigned int level,
    const unsigned int dim,
    const unsigned int * factors,
    const SpacingType & spacing ) const;
 
  void GetSigma( const unsigned int level,
    SigmaArrayType & sigmaArray ) const;
 
  void GetShrinkFactors( const unsigned int level,
    RescaleFactorArrayType & shrinkFactors ) const;
 
  bool AreSigmasAllZeros( const SigmaArrayType & sigmaArray ) const;
 
  bool AreRescaleFactorsAllOnes( const RescaleFactorArrayType & rescaleFactorArray ) const;
 
  bool IsSmoothingUsed( void ) const;
 
  bool IsRescaleUsed( void ) const;
 
private:
 
  GenericMultiResolutionPyramidImageFilter( const Self & ); // purposely not implemented
  void operator=( const Self & );                           // purposely not implemented
 
};
 
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkGenericMultiResolutionPyramidImageFilter.hxx"
#endif
 
#endif