mitkHotspotMaskGenerator.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.
 
============================================================================*/
 
#ifndef mitkHotspotMaskGenerator_h
#define mitkHotspotMaskGenerator_h
 
#include <itkObject.h>
#include <mitkImage.h>
#include <itkImage.h>
#include <itkTimeStamp.h>
#include <stdexcept>
#include <MitkImageStatisticsExports.h>
#include <mitkImageTimeSelector.h>
#include <mitkMaskGenerator.h>
 
 
namespace mitk
{
    class MITKIMAGESTATISTICS_EXPORT HotspotMaskGenerator: public MaskGenerator
    {
    public:
        typedef HotspotMaskGenerator                Self;
        typedef MaskGenerator                       Superclass;
        typedef itk::SmartPointer< Self >           Pointer;
        typedef itk::SmartPointer< const Self >     ConstPointer;
 
        itkNewMacro(Self); 
        itkTypeMacro(HotspotMaskGenerator, MaskGenerator);
 
        void SetInputImage(mitk::Image::Pointer inputImage);
 
        void SetMask(MaskGenerator::Pointer mask);
 
        void SetHotspotRadiusInMM(double radiusInMillimeter);
 
        const double& GetHotspotRadiusinMM() const;
 
        void SetHotspotMustBeCompletelyInsideImage(bool hotspotCompletelyInsideImage);
 
        bool GetHotspotMustBeCompletelyInsideImage() const;
 
        void SetLabel(unsigned short label);
 
        mitk::Image::ConstPointer GetMask() override;
 
        vnl_vector<int> GetHotspotIndex();
 
        vnl_vector<int> GetConvolutionImageMinIndex();
 
        void SetTimeStep(unsigned int timeStep) override;
 
    protected:
        HotspotMaskGenerator();
 
        ~HotspotMaskGenerator() override;
 
        class ImageExtrema
        {
        public:
          bool Defined;
          double Max;
          double Min;
          vnl_vector<int> MaxIndex;
          vnl_vector<int> MinIndex;
 
          ImageExtrema()
            :Defined(false)
            ,Max(itk::NumericTraits<double>::min())
            ,Min(itk::NumericTraits<double>::max())
          {
          }
        };
 
    private:
        template <unsigned int VImageDimension>
        itk::Size<VImageDimension>
          CalculateConvolutionKernelSize(double spacing[VImageDimension], double radiusInMM);
 
        template <unsigned int VImageDimension>
        itk::SmartPointer< itk::Image<float, VImageDimension> >
          GenerateHotspotSearchConvolutionKernel(double spacing[VImageDimension], double radiusInMM);
 
        template <typename TPixel, unsigned int VImageDimension>
        itk::SmartPointer< itk::Image<TPixel, VImageDimension> >
          GenerateConvolutionImage( const itk::Image<TPixel, VImageDimension>* inputImage );
 
 
        template < typename TPixel, unsigned int VImageDimension>
        void
          FillHotspotMaskPixels( itk::Image<TPixel, VImageDimension>* maskImage,
          itk::Point<double, VImageDimension> sphereCenter,
          double sphereRadiusInMM);
 
 
        template <typename TPixel, unsigned int VImageDimension>
        void
          CalculateHotspotMask(itk::Image<TPixel, VImageDimension>* inputImage,
                               const itk::Image<unsigned short, VImageDimension>* maskImage,
                               unsigned int label);
 
 
        template <typename TPixel, unsigned int VImageDimension  >
        ImageExtrema CalculateExtremaWorld( const itk::Image<TPixel, VImageDimension>* inputImage,
                                                        const itk::Image<unsigned short, VImageDimension>* maskImage,
                                                        double neccessaryDistanceToImageBorderInMM,
                                                        unsigned int label);
 
        bool IsUpdateRequired() const;
 
        HotspotMaskGenerator(const HotspotMaskGenerator &);
        HotspotMaskGenerator & operator=(const HotspotMaskGenerator &);
 
        MaskGenerator::Pointer m_Mask;
        mitk::Image::Pointer m_InternalMask;
        mitk::Image::Pointer m_internalImage;
        itk::Image<unsigned short, 2>::ConstPointer m_internalMask2D;
        itk::Image<unsigned short, 3>::ConstPointer m_internalMask3D;
        double m_HotspotRadiusinMM;
        bool m_HotspotMustBeCompletelyInsideImage;
        unsigned short m_Label;
        vnl_vector<int> m_ConvolutionImageMinIndex, m_ConvolutionImageMaxIndex;
        unsigned long m_InternalMaskUpdateTime;
    };
}
#endif