animaHierarchicalInitializer.h

Go to the documentation of this file.

#pragma once

#include "animaImageClassifierFilter.h"
#include "animaGaussianREMEstimator.h"
#include "animaRandomInitializer.h"
#include "animaClassificationStrategy.h"

#include <itkHistogram.h>
#include <itkListSample.h>
#include <itkDenseFrequencyContainer2.h>
#include <itkSampleToHistogramFilter.h>
#include <itkMinimumMaximumImageCalculator.h>
#include <itkImageRegionIterator.h>
#include <itkMaskImageFilter.h>


namespace anima
{
template <typename TInputImage, typename TMaskImage>
class HierarchicalInitializer: public ModelInitializer
{
public:

    typedef HierarchicalInitializer  Self;
    typedef itk::ProcessObject Superclass;
    typedef itk::SmartPointer <Self> Pointer;
    typedef itk::SmartPointer <const Self> ConstPointer;

    itkNewMacro(Self)

    
    itkTypeMacro(HierarchicalInitializer, itk::ProcessObject)

    typedef double  PixelTypeD;
    typedef itk::Image <PixelTypeD,3> ImageTypeD;
    typedef itk::ImageRegionIterator <ImageTypeD> ImageIteratorTypeD;
    typedef itk::ImageRegionIterator< ImageTypeD > InputIteratorTypeD;

    typedef TInputImage InputImageType;
    typedef typename InputImageType::ConstPointer InputImageConstPointer;
    typedef typename InputImageType::Pointer InputImagePointer;
    typedef typename InputImageType::PixelType InputImagePixelType;
    typedef typename itk::ImageRegionIterator< InputImageType > InputIteratorType;
    typedef typename itk::ImageRegionConstIterator< InputImageType > InputConstIteratorType;

    typedef TMaskImage MaskImageType;
    typedef typename MaskImageType::ConstPointer MaskImageConstPointer;
    typedef typename itk::ImageRegionConstIterator< MaskImageType > MaskConstIteratorType;

    typedef anima::ImageClassifierFilter<InputImageType,InputImageType> ImageClassifierType;
    typedef anima::GaussianREMEstimator<InputImageType,MaskImageType> GaussianREMEstimatorType;
    typedef anima::ClassificationStrategy<InputImageType,MaskImageType> ClassificationStrategyType;
    typedef itk::MaskImageFilter< InputImageType, InputImageType > MaskFilterType;
    typedef itk::MinimumMaximumImageCalculator<InputImageType>   MinMaxCalculatorType;

    typedef std::map<double, std::vector<GaussianFunctionType::Pointer> > ModelMap;
    typedef std::map<double, std::vector<double> > ModelMap2;

    void SetInputImage1(const TInputImage* image);
    void SetInputImage2(const TInputImage* image);
    void SetInputImage3(const TInputImage* image);
    void SetInputImage4(const TInputImage* image);
    void SetInputImage5(const TInputImage* image);

    typename TInputImage::ConstPointer GetInputImage1();
    typename TInputImage::ConstPointer GetInputImage2();
    typename TInputImage::ConstPointer GetInputImage3();
    typename TInputImage::ConstPointer GetInputImage4();
    typename TInputImage::ConstPointer GetInputImage5();

    void SetMask(const TMaskImage* mask);
    typename TMaskImage::ConstPointer GetMask();

    double regionMedianValue(itk::Image< double, 3 >::Pointer image, typename TInputImage::Pointer mask );

    void Update() ITK_OVERRIDE;

    void ComputeSolution1D();

    void ComputeInitialT1Classification();

    void ComputeHistogram();

    void ComputeVariances();

    void FillInitialGaussianModel();

    //Update progression of the process
    static void eventCallback (itk::Object* caller, const itk::EventObject& event, void* clientData)
    {
        itk::ProcessObject * processObject = (itk::ProcessObject*) caller;
        std::cout<<"\033[K\rProgression: "<<(int)(processObject->GetProgress() * 100)<<"%"<<std::flush;
    }

    itkSetMacro(Tol, double)
    itkGetMacro(Tol, double)

    itkSetMacro(ThirdIsFLAIR, bool)
    itkGetMacro(ThirdIsFLAIR, bool)

    itkSetMacro(Robust, double)
    itkGetMacro(Robust, double)

protected:
    HierarchicalInitializer()
    {
        m_ThirdIsFLAIR = true;
        m_Robust = 0.01;
        m_NbInputs = 1;
        m_NbMaxImages = 6;
        m_NbClasses = 3;
        m_NumberOfModalities = 3;
        m_IndexImage1 = m_NbMaxImages, m_IndexImage2 = m_NbMaxImages, m_IndexImage3 = m_NbMaxImages, m_IndexImage4 = m_NbMaxImages, m_IndexImage5 = m_NbMaxImages, m_IndexImagem_NbMaxImages = m_NbMaxImages;
    }
    virtual ~HierarchicalInitializer(){}

private:
    ITK_DISALLOW_COPY_AND_ASSIGN(HierarchicalInitializer);

    std::vector<InputImageConstPointer> m_ImagesVector; //Order must be "T1","T2","FLAIR or PD"
    bool m_ThirdIsFLAIR;
    double m_Robust;

    unsigned int m_NbInputs, m_NbMaxImages;
    unsigned int m_IndexImage1, m_IndexImage2, m_IndexImage3, m_IndexImage4,m_IndexImage5, m_IndexImagem_NbMaxImages;
    unsigned int m_NbClasses, m_NumberOfModalities;

    std::vector<GaussianFunctionType::Pointer> m_Solution1D;
    std::vector<double> m_Solution1DAlphas;

    std::vector<InputImagePointer> m_ImagesClasses;
    std::vector< std::vector<double> > m_Stds;
    std::vector< std::vector<double> > m_SelectedMax;

    double m_Tol;
};

}

#include "animaHierarchicalInitializer.hxx"