mitkImageStatisticsCalculator.h

Go to the documentation of this file.

#ifndef MITKIMAGESTATISTICSCALCULATOR
#define MITKIMAGESTATISTICSCALCULATOR

#include <MitkImageStatisticsExports.h>
#include <mitkImage.h>
#include <mitkMaskGenerator.h>
#include <itkImage.h>
#include <limits>
#include <itkObject.h>
#include <itkSmartPointer.h>

namespace mitk
{
    class MITKIMAGESTATISTICS_EXPORT ImageStatisticsCalculator: public itk::Object
    {
    public:
        typedef ImageStatisticsCalculator        Self;
        typedef itk::Object                         Superclass;
        typedef itk::SmartPointer< Self >           Pointer;
        typedef itk::SmartPointer< const Self >     ConstPointer;

        itkNewMacro(Self)

        
        itkTypeMacro(ImageStatisticsCalculator_v2, itk::Object)

        typedef double statisticsValueType;
        typedef std::map<std::string, statisticsValueType> statisticsMapType;
        typedef itk::Statistics::Histogram<double> HistogramType;
        typedef unsigned short MaskPixelType;

        class MITKIMAGESTATISTICS_EXPORT StatisticsContainer : public itk::Object
        {
        public:
            typedef StatisticsContainer                 Self;
            typedef itk::Object                         Superclass;
            typedef itk::SmartPointer< Self >           Pointer;
            typedef itk::SmartPointer< const Self >     ConstPointer;

            itkNewMacro(Self)

            
            itkTypeMacro(StatisticsContainer, itk::Object)

            typedef double RealType;

            statisticsMapType GetStatisticsAsMap();

            void Reset();

            void SetN(long n)
            {
                m_N = n;
            }

            const long& GetN() const
            {
                return m_N;
            }

            void SetMean(RealType mean)
            {
                m_Mean = mean;
            }

            const RealType& GetMean() const
            {
                return m_Mean;
            }

            void SetVariance(RealType variance)
            {
                m_Variance = variance;
            }

            const RealType& GetVariance() const
            {
                return m_Variance;
            }

            void SetStd(RealType std)
            {
                m_Std = std;
            }

            const RealType& GetStd() const
            {
                return m_Std;
            }

            void SetMin(RealType minVal)
            {
                m_Min = minVal;
            }

            const RealType& GetMin() const
            {
                return m_Min;
            }

            void SetMax(RealType maxVal)
            {
                m_Max = maxVal;
            }

            const RealType& GetMax() const
            {
                return m_Max;
            }

            void SetRMS(RealType rms)
            {
                m_RMS = rms;
            }

            const RealType& GetRMS() const
            {
                return m_RMS;
            }

            void SetSkewness(RealType skewness)
            {
                m_Skewness = skewness;
            }

            const RealType& GetSkewness() const
            {
                return m_Skewness;
            }

            void SetKurtosis(RealType kurtosis)
            {
                m_Kurtosis = kurtosis;
            }

            const RealType& GetKurtosis() const
            {
                return m_Kurtosis;
            }

            void SetMPP(RealType mpp)
            {
                m_MPP = mpp;
            }

            const RealType& GetMPP() const
            {
                return m_MPP;
            }

            void SetLabel(unsigned int label)
            {
                m_Label = label;
            }

            const unsigned int& GetLabel() const
            {
                return m_Label;
            }

            void SetMinIndex(vnl_vector<int> minIndex)
            {
                m_minIndex = minIndex;
            }

            vnl_vector<int> GetMinIndex() const
            {
                return m_minIndex;
            }

            void SetMaxIndex(vnl_vector<int> maxIndex)
            {
                m_maxIndex = maxIndex;
            }

            vnl_vector<int> GetMaxIndex() const
            {
                return m_maxIndex;
            }

            void SetHistogram(HistogramType::Pointer hist)
            {
                if (m_Histogram != hist)
                {
                    m_Histogram = hist;
                }
            }

            const HistogramType::Pointer GetHistogram() const
            {
                return m_Histogram;
            }

            void SetEntropy(RealType entropy)
            {
                m_Entropy = entropy;
            }

            const RealType & GetEntropy() const
            {
                return m_Entropy;
            }

            void SetMedian(RealType median)
            {
                m_Median = median;
            }

            const RealType & GetMedian() const
            {
                return m_Median;
            }

            void SetUniformity(RealType uniformity)
            {
                m_Uniformity = uniformity;
            }

            const RealType & GetUniformity() const
            {
                return m_Uniformity;
            }

            void SetUPP(RealType upp)
            {
                m_UPP = upp;
            }

            const RealType & GetUPP() const
            {
                return m_UPP;
            }

            void Print();

            std::string GetAsString();


        protected:
            StatisticsContainer();

        private:
            itk::LightObject::Pointer InternalClone() const
            {
                itk::LightObject::Pointer ioPtr = Superclass::InternalClone();
                Self::Pointer rval = dynamic_cast<Self*>(ioPtr.GetPointer());
                if (rval.IsNull())
                {
                    itkExceptionMacro(<< "downcast to type "
                                      << "StatisticsContainer"
                                      << " failed.");
                }

                rval->SetEntropy(this->GetEntropy());
                rval->SetKurtosis(this->GetKurtosis());
                rval->SetLabel(this->GetLabel());
                rval->SetMax(this->GetMax());
                rval->SetMin(this->GetMin());
                rval->SetMean(this->GetMean());
                rval->SetMedian(this->GetMedian());
                rval->SetMPP(this->GetMPP());
                rval->SetN(this->GetN());
                rval->SetRMS(this->GetRMS());
                rval->SetSkewness(this->GetSkewness());
                rval->SetStd(this->GetStd());
                rval->SetUniformity(this->GetUniformity());
                rval->SetUPP(this->GetUPP());
                rval->SetVariance(this->GetVariance());
                rval->SetHistogram(this->GetHistogram());
                rval->SetMinIndex(this->GetMinIndex());
                rval->SetMaxIndex(this->GetMaxIndex());
                return ioPtr;
            }

            // not pretty, is temporary
            long m_N;
            RealType m_Mean, m_Min, m_Max, m_Std, m_Variance;
            RealType m_Skewness;
            RealType m_Kurtosis;
            RealType m_RMS;
            RealType m_MPP;
            vnl_vector<int> m_minIndex, m_maxIndex;
            RealType m_Median;
            RealType m_Uniformity;
            RealType m_UPP;
            RealType m_Entropy;
            unsigned int m_Label;
            HistogramType::Pointer m_Histogram;

        };

        void SetInputImage(mitk::Image::Pointer image);

        void SetMask(mitk::MaskGenerator::Pointer mask);

        void SetSecondaryMask(mitk::MaskGenerator::Pointer mask);

        void SetNBinsForHistogramStatistics(unsigned int nBins);

        unsigned int GetNBinsForHistogramStatistics() const;

        void SetBinSizeForHistogramStatistics(double binSize);

        double GetBinSizeForHistogramStatistics() const;

        StatisticsContainer::Pointer GetStatistics(unsigned int timeStep=0, unsigned int label=1);

    protected:
        ImageStatisticsCalculator(){
            m_nBinsForHistogramStatistics = 100;
            m_binSizeForHistogramStatistics = 10;
            m_UseBinSizeOverNBins = false;
        };


    private:
        template < typename TPixel, unsigned int VImageDimension > void InternalCalculateStatisticsUnmasked(
                typename itk::Image< TPixel, VImageDimension >* image,
                unsigned int timeStep);

        template < typename TPixel, unsigned int VImageDimension > typename HistogramType::Pointer InternalCalculateHistogramUnmasked(
                typename itk::Image< TPixel, VImageDimension >* image,
                double minVal,
                double maxVal);

        template < typename TPixel, unsigned int VImageDimension > void InternalCalculateStatisticsMasked(
                typename itk::Image< TPixel, VImageDimension >* image,
                unsigned int timeStep);

        bool IsUpdateRequired(unsigned int timeStep) const;

        std::string GetNameOfClass()
        {
            return std::string("ImageStatisticsCalculator_v2");
        }

        mitk::Image::Pointer m_Image;
        mitk::Image::Pointer m_ImageTimeSlice;
        mitk::Image::Pointer m_InternalImageForStatistics;

        mitk::MaskGenerator::Pointer m_MaskGenerator;
        mitk::Image::Pointer m_InternalMask;

        mitk::MaskGenerator::Pointer m_SecondaryMaskGenerator;
        mitk::Image::Pointer m_SecondaryMask;

        unsigned int m_nBinsForHistogramStatistics;
        double m_binSizeForHistogramStatistics;
        bool m_UseBinSizeOverNBins;

        std::vector<std::vector<StatisticsContainer::Pointer>> m_StatisticsByTimeStep;
        std::vector<unsigned long> m_StatisticsUpdateTimePerTimeStep;
    };

}
#endif // MITKIMAGESTATISTICSCALCULATOR