itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE 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
*
*         https://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 itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_h
#define itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_h
 
#include <itkImage.h>
#include <itkHistogram.h>
#include <itkNumericTraits.h>
#include <itkVectorContainer.h>
 
namespace itk
{
  namespace Statistics
  {
    template<typename TImageType, typename THistogramFrequencyContainer =
      DenseFrequencyContainer2>
    class EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter : public ProcessObject
    {
    public:
      typedef EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter  Self;
      typedef ProcessObject                       Superclass;
      typedef SmartPointer<Self>                  Pointer;
      typedef SmartPointer<const Self>            ConstPointer;
 
      itkTypeMacro( EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter, ProcessObject );
 
      itkNewMacro( Self );
 
      typedef TImageType                                      ImageType;
      typedef typename ImageType::Pointer                     ImagePointer;
      typedef typename ImageType::ConstPointer                ImageConstPointer;
      typedef typename ImageType::PixelType                   PixelType;
      typedef typename ImageType::IndexType                   IndexType;
      typedef typename ImageType::RegionType                  RegionType;
      typedef typename ImageType::SizeType                    RadiusType;
      typedef typename ImageType::OffsetType                  OffsetType;
      typedef VectorContainer<unsigned char, OffsetType>      OffsetVector;
      typedef typename OffsetVector::Pointer                  OffsetVectorPointer;
      typedef typename ImageType::PointType                   PointType;
 
      typedef typename NumericTraits<PixelType>::RealType     MeasurementType;
      typedef typename NumericTraits<PixelType>::RealType     RealType;
 
      typedef Histogram<MeasurementType, THistogramFrequencyContainer>
        HistogramType;
      typedef typename HistogramType::Pointer                 HistogramPointer;
      typedef typename HistogramType::ConstPointer            HistogramConstPointer;
      typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;
 
      itkStaticConstMacro( ImageDimension, unsigned int,
        TImageType::ImageDimension );
 
      itkStaticConstMacro( DefaultBinsPerAxis, unsigned int, 256 );
 
      itkSetObjectMacro( Offsets, OffsetVector );
 
      void SetOffset( const OffsetType offset );
 
      void AddOffsets( const std::vector<OffsetType> offset );
 
      itkGetModifiableObjectMacro(Offsets, OffsetVector );
 
      itkSetMacro( NumberOfBinsPerAxis, unsigned int );
 
      itkGetConstMacro( NumberOfBinsPerAxis, unsigned int );
 
      void SetPixelValueMinMax( PixelType min, PixelType max );
 
      itkGetConstMacro( Min, PixelType );
 
      itkGetConstMacro( Max, PixelType );
 
      void SetDistanceValueMinMax( RealType min, RealType max );
 
      itkGetConstMacro( MinDistance, RealType );
 
      itkGetConstMacro( MaxDistance, RealType );
 
      using Superclass::SetInput;
      void SetInput( const ImageType *image );
 
      const ImageType * GetInput() const;
 
      void SetMaskImage( const ImageType *image );
 
      const ImageType * GetMaskImage() const;
 
      const HistogramType * GetOutput() const;
 
      double* GetSiMatrix() const;
 
      itkSetMacro( InsidePixelValue, PixelType );
      itkGetConstMacro( InsidePixelValue, PixelType );
 
    protected:
      EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter();
      ~EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter() override {};
      void PrintSelf( std::ostream& os, Indent indent ) const ITK_OVERRIDE;
 
      typedef DataObject::Pointer DataObjectPointer;
 
      typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
      using Superclass::MakeOutput;
      DataObjectPointer MakeOutput( DataObjectPointerArraySizeType idx ) ITK_OVERRIDE;
 
      void GenerateData() ITK_OVERRIDE;
 
      void NormalizeOffsetDirection(OffsetType &offset);
 
    private:
 
      unsigned int             m_NumberOfBinsPerAxis;
      PixelType                m_Min;
      PixelType                m_Max;
      RealType                 m_MinDistance;
      RealType                 m_MaxDistance;
      PixelType                m_InsidePixelValue;
 
      MeasurementVectorType    m_LowerBound;
      MeasurementVectorType    m_UpperBound;
      OffsetVectorPointer      m_Offsets;
 
      double * m_siMatrix;
    };
  } // end of namespace Statistics
} // end of namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include <itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.tpp>
#endif
 
#endif