mitkHotspotMaskGenerator.h

Go to the documentation of this file.

#ifndef MITKHOTSPOTCALCULATOR_H
#define MITKHOTSPOTCALCULATOR_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::Pointer GetMask();

        vnl_vector<int> GetHotspotIndex();

        vnl_vector<int> GetConvolutionImageMinIndex();

        void SetTimeStep(unsigned int timeStep);

    protected:
        HotspotMaskGenerator();

        ~HotspotMaskGenerator();

        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,
                               typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
                               unsigned int label);


        template <typename TPixel, unsigned int VImageDimension  >
        ImageExtrema CalculateExtremaWorld( const itk::Image<TPixel, VImageDimension>* inputImage,
                                                        typename itk::Image<unsigned short, VImageDimension>::Pointer maskImage,
                                                        double neccessaryDistanceToImageBorderInMM,
                                                        unsigned int label);

        bool IsUpdateRequired() const;

        HotspotMaskGenerator(const HotspotMaskGenerator &);
        HotspotMaskGenerator & operator=(const HotspotMaskGenerator &);

        MaskGenerator::Pointer m_Mask;
        mitk::Image::Pointer m_internalImage;
        itk::Image<unsigned short, 2>::Pointer m_internalMask2D;
        itk::Image<unsigned short, 3>::Pointer m_internalMask3D;
        double m_HotspotRadiusinMM;
        bool m_HotspotMustBeCompletelyInsideImage;
        bool m_HotspotParamsChanged;
        unsigned short m_Label;
        vnl_vector<int> m_ConvolutionImageMinIndex, m_ConvolutionImageMaxIndex;
        unsigned long m_InternalMaskUpdateTime;
    };
}
#endif // MITKHOTSPOTCALCULATOR