itkAdvancedImageMomentsCalculator.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 itkAdvancedImageMomentsCalculator_h
#define itkAdvancedImageMomentsCalculator_h
 
#include "itkInPlaceImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkAffineTransform.h"
#include "itkImage.h"
#include "itkSpatialObject.h"
#include "itkImageGridSampler.h"
#include "itkImageFullSampler.h"
 
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix_fixed.h"
#include "vnl/vnl_diag_matrix.h"
 
#include "itkPlatformMultiThreader.h"
 
namespace itk
{
template< typename TImage >
class AdvancedImageMomentsCalculator : public Object
{
public:
  typedef AdvancedImageMomentsCalculator< TImage > Self;
  typedef Object                           Superclass;
  typedef SmartPointer< Self >             Pointer;
  typedef SmartPointer< const Self >       ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(AdvancedImageMomentsCalculator, Object);
 
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TImage::ImageDimension);
 
  typedef double ScalarType;
 
  typedef Vector< ScalarType, itkGetStaticConstMacro(ImageDimension) > VectorType;
 
  typedef SpatialObject< itkGetStaticConstMacro(ImageDimension) > SpatialObjectType;
 
  typedef typename SpatialObjectType::Pointer      SpatialObjectPointer;
  typedef typename SpatialObjectType::ConstPointer SpatialObjectConstPointer;
 
  typedef Matrix< ScalarType,
                  itkGetStaticConstMacro(ImageDimension),
                  itkGetStaticConstMacro(ImageDimension) >   MatrixType;
 
  typedef TImage ImageType;
 
  typedef typename ImageType::Pointer      ImagePointer;
  typedef typename ImageType::ConstPointer ImageConstPointer;
 
  typedef AffineTransform< double, itkGetStaticConstMacro(ImageDimension) > AffineTransformType;
  typedef typename AffineTransformType::Pointer                             AffineTransformPointer;
 
  virtual void SetImage(const ImageType *image)
  {
    if ( m_Image != image )
      {
      m_Image = image;
      this->Modified();
      m_Valid = false;
      }
  }
 
  virtual void SetSpatialObjectMask(const SpatialObject< itkGetStaticConstMacro(ImageDimension) > *so)
  {
    if ( m_SpatialObjectMask != so )
      {
      m_SpatialObjectMask = so;
      this->Modified();
      m_Valid = false;
      }
  }
 
  void Compute();
 
  void ComputeSingleThreaded();
  ScalarType GetTotalMass() const;
 
  VectorType GetFirstMoments() const;
 
  MatrixType GetSecondMoments() const;
 
  VectorType GetCenterOfGravity() const;
 
  MatrixType GetCentralMoments() const;
 
  VectorType GetPrincipalMoments() const;
 
  MatrixType GetPrincipalAxes() const;
 
  AffineTransformPointer GetPrincipalAxesToPhysicalAxesTransform() const;
 
  AffineTransformPointer GetPhysicalAxesToPrincipalAxesTransform() const;
 
  void SetNumberOfWorkUnits(ThreadIdType numberOfThreads)
  {
    this->m_Threader->SetNumberOfWorkUnits(numberOfThreads);
  }
 
  virtual void BeforeThreadedCompute( void );
 
  virtual void AfterThreadedCompute( void );
 
  typedef itk::ImageGridSampler< ImageType >     ImageGridSamplerType;
//  typedef itk::ImageFullSampler< ImageType >     ImageGridSamplerType;
  typedef typename ImageGridSamplerType::Pointer ImageGridSamplerPointer;
  typedef typename ImageGridSamplerType
    ::ImageSampleContainerType                   ImageSampleContainerType;
  typedef typename ImageSampleContainerType::Pointer ImageSampleContainerPointer;
 
  virtual void SampleImage(ImageSampleContainerPointer & sampleContainer);
 
  typedef itk::BinaryThresholdImageFilter < TImage, TImage >             BinaryThresholdImageFilterType;
  typedef typename TImage::PixelType  InputPixelType;
 
  itkSetMacro( NumberOfSamplesForCenteredTransformInitialization, SizeValueType );
  itkSetMacro( LowerThresholdForCenterGravity, InputPixelType );
  itkSetMacro( CenterOfGravityUsesLowerThreshold, bool );
 
protected:
  AdvancedImageMomentsCalculator();
  ~AdvancedImageMomentsCalculator() override;
  void PrintSelf(std::ostream & os, Indent indent) const override;
 
  typedef itk::PlatformMultiThreader             ThreaderType;
  typedef ThreaderType::WorkUnitInfo ThreadInfoType;
  ThreaderType::Pointer                   m_Threader;
 
  void LaunchComputeThreaderCallback(void) const;
 
  static ITK_THREAD_RETURN_FUNCTION_CALL_CONVENTION ComputeThreaderCallback(void * arg);
 
  virtual inline void ThreadedCompute(ThreadIdType threadID);
 
  virtual void InitializeThreadingParameters(void);
 
  struct MultiThreaderParameterType
  {
    Self * st_Self;
  };
  mutable MultiThreaderParameterType m_ThreaderParameters;
 
  struct ComputePerThreadStruct
  {
    ScalarType st_M0;                   // Zeroth moment for threading
    VectorType st_M1;                   // First moments about origin for threading
    MatrixType st_M2;                   // Second moments about origin for threading
    VectorType st_Cg;                   // Center of gravity (physical units) for threading
    MatrixType st_Cm;                   // Second central moments (physical) for threading
    SizeValueType st_NumberOfPixelsCounted;
  };
  itkPadStruct(ITK_CACHE_LINE_ALIGNMENT, ComputePerThreadStruct,
    PaddedComputePerThreadStruct);
  itkAlignedTypedef(ITK_CACHE_LINE_ALIGNMENT, PaddedComputePerThreadStruct,
    AlignedComputePerThreadStruct);
  mutable AlignedComputePerThreadStruct * m_ComputePerThreadVariables;
  mutable ThreadIdType                    m_ComputePerThreadVariablesSize;
  bool                        m_UseMultiThread;
  SizeValueType               m_NumberOfPixelsCounted;
 
  typedef typename ImageType::RegionType ThreadRegionType;
 
  SizeValueType  m_NumberOfSamplesForCenteredTransformInitialization;
  InputPixelType m_LowerThresholdForCenterGravity;
  bool           m_CenterOfGravityUsesLowerThreshold;
  ImageSampleContainerPointer m_SampleContainer;
 
private:
  void DoPostProcessing();
 
  AdvancedImageMomentsCalculator( const Self & );
  void operator = ( const Self & );
 
  bool       m_Valid;                // Have moments been computed yet?
  ScalarType m_M0;                   // Zeroth moment
  VectorType m_M1;                   // First moments about origin
  MatrixType m_M2;                   // Second moments about origin
  VectorType m_Cg;                   // Center of gravity (physical units)
  MatrixType m_Cm;                   // Second central moments (physical)
  VectorType m_Pm;                   // Principal moments (physical)
  MatrixType m_Pa;                   // Principal axes (physical)
 
  ImageConstPointer         m_Image;
  SpatialObjectConstPointer m_SpatialObjectMask;
 
};  // class AdvancedImageMomentsCalculator
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkAdvancedImageMomentsCalculator.hxx"
#endif
 
#endif /* itkAdvancedImageMomentsCalculator_h */