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
*
*         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 __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.hxx"
#endif

#endif