mitkFiberfoxParameters.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef _MITK_FiberfoxParameters_H
#define _MITK_FiberfoxParameters_H

#include <itkImageRegion.h>
#include <itkMatrix.h>
#include <mitkDiffusionNoiseModel.h>
#include <mitkDiffusionSignalModel.h>
#include <mitkDataNode.h>
#include <mitkRicianNoiseModel.h>
#include <mitkChiSquareNoiseModel.h>
#include <mitkImage.h>
#include <mitkDiffusionPropertyHelper.h>
#include <mitkPlanarEllipse.h>
#include <mitkStickModel.h>
#include <mitkTensorModel.h>
#include <mitkAstroStickModel.h>
#include <mitkBallModel.h>
#include <mitkDotModel.h>
#include <mitkRawShModel.h>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <limits>

using namespace std;

namespace mitk
{

  class SignalGenerationParameters
  {
  public:
    typedef itk::Image<double, 3>                   ItkDoubleImgType;
    typedef itk::Image<unsigned char, 3>            ItkUcharImgType;
    typedef itk::Vector<double,3>                   GradientType;
    typedef std::vector<GradientType>               GradientListType;

    enum CoilSensitivityProfile : int {
      COIL_CONSTANT,
      COIL_LINEAR,
      COIL_EXPONENTIAL
    };

    enum AcquisitionType : int
    {
      SingleShotEpi,
      SpinEcho
    };

    SignalGenerationParameters()
      : m_AcquisitionType(SignalGenerationParameters::SingleShotEpi)
      , m_SignalScale(100)
      , m_tEcho(100)
      , m_tRep(4000)
      , m_tLine(1)
      , m_tInhom(50)
      , m_ReversePhase(false)
      , m_PartialFourier(1.0)
      , m_NoiseVariance(0.001)
      , m_NumberOfCoils(1)
      , m_CoilSensitivityProfile(SignalGenerationParameters::COIL_CONSTANT)
      , m_Bvalue(1000)
      , m_SimulateKspaceAcquisition(false)
      , m_AxonRadius(0)
      , m_DoDisablePartialVolume(false)
      , m_Spikes(0)
      , m_SpikeAmplitude(1)
      , m_KspaceLineOffset(0)
      , m_EddyStrength(300)
      , m_Tau(70)
      , m_CroppingFactor(1)
      , m_DoAddGibbsRinging(false)
      , m_DoSimulateRelaxation(true)
      , m_DoAddMotion(false)
      , m_DoRandomizeMotion(true)
      , m_FrequencyMap(NULL)
      , m_MaskImage(NULL)
    {
      m_ImageRegion.SetSize(0, 12);
      m_ImageRegion.SetSize(1, 12);
      m_ImageRegion.SetSize(2, 3);
      m_ImageSpacing.Fill(2.0);
      m_ImageOrigin.Fill(0.0);
      m_ImageDirection.SetIdentity();
      m_Translation.Fill(0.0);
      m_Rotation.Fill(0.0);
      SetNumWeightedVolumes(6);
    }

    itk::ImageRegion<3>                 m_CroppedRegion;            
    itk::ImageRegion<3>                 m_ImageRegion;              
    itk::Vector<double,3>               m_ImageSpacing;             
    itk::Point<double,3>                m_ImageOrigin;              
    itk::Matrix<double, 3, 3>           m_ImageDirection;           

    AcquisitionType                     m_AcquisitionType;          
    double                              m_SignalScale;              
    double                              m_tEcho;                    
    double                              m_tRep;                     
    double                              m_tLine;                    
    double                              m_tInhom;                   
    bool                                m_ReversePhase;             
    double                              m_PartialFourier;           
    double                              m_NoiseVariance;            
    int                                 m_NumberOfCoils;            
    CoilSensitivityProfile              m_CoilSensitivityProfile;   
    double                              m_Bvalue;                   
    bool                                m_SimulateKspaceAcquisition;
    double                              m_AxonRadius;               
    bool                                m_DoDisablePartialVolume;   

    unsigned int                        m_Spikes;                   
    double                              m_SpikeAmplitude;           
    double                              m_KspaceLineOffset;         
    double                              m_EddyStrength;             
    double                              m_Tau;                      
    double                              m_CroppingFactor;           
    bool                                m_DoAddGibbsRinging;        
    bool                                m_DoSimulateRelaxation;     
    bool                                m_DoAddMotion;              
    bool                                m_DoRandomizeMotion;        
    std::vector< bool >                 m_MotionVolumes;            
    itk::Vector<double,3>               m_Translation;              
    itk::Vector<double,3>               m_Rotation;                 
    ItkDoubleImgType::Pointer           m_FrequencyMap;             
    ItkUcharImgType::Pointer            m_MaskImage;                

    inline void GenerateGradientHalfShell();                        
    inline std::vector< int > GetBaselineIndices();                 
    inline unsigned int GetFirstBaselineIndex();                    
    inline bool IsBaselineIndex(unsigned int idx);                  
    inline unsigned int GetNumWeightedVolumes();                    
    inline unsigned int GetNumBaselineVolumes();                    
    inline unsigned int GetNumVolumes();                            
    inline GradientListType GetGradientDirections();                
    inline GradientType GetGradientDirection(unsigned int i);

    inline void SetNumWeightedVolumes(int numGradients);            
    inline void SetGradienDirections(GradientListType gradientList);
    inline void SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList);

  protected:

    unsigned int                        m_NumGradients;             
    unsigned int                        m_NumBaseline;              
    GradientListType                    m_GradientDirections;       
  };

  class FiberGenerationParameters
  {
  public:

    enum FiberDistribution
    {
      DISTRIBUTE_UNIFORM, // distribute fibers uniformly in the ROIs
      DISTRIBUTE_GAUSSIAN // distribute fibers using a 2D gaussian
    };

    typedef vector< vector< mitk::PlanarEllipse::Pointer > >    FiducialListType;
    typedef vector< vector< unsigned int > >                    FlipListType;

    FiberGenerationParameters()
      : m_Distribution(DISTRIBUTE_UNIFORM)
      , m_Density(100)
      , m_Variance(100)
      , m_Sampling(1)
      , m_Tension(0)
      , m_Continuity(0)
      , m_Bias(0)
    {
      m_Rotation.Fill(0.0);
      m_Translation.Fill(0.0);
      m_Scale.Fill(1.0);
    }

    FiberDistribution   m_Distribution;
    unsigned int        m_Density;
    double              m_Variance;
    double              m_Sampling;
    double              m_Tension;
    double              m_Continuity;
    double              m_Bias;
    mitk::Vector3D      m_Rotation;
    mitk::Vector3D      m_Translation;
    mitk::Vector3D      m_Scale;
    FlipListType        m_FlipList;        
    FiducialListType    m_Fiducials;       
  };

  class MiscFiberfoxParameters
  {
  public:
    MiscFiberfoxParameters()
      : m_ResultNode(DataNode::New())
      , m_ParentNode(NULL)
      , m_SignalModelString("")
      , m_ArtifactModelString("")
      , m_OutputPath("/tmp/")
      , m_OutputPrefix("fiberfox")
      , m_CheckOutputVolumeFractionsBox(false)
      , m_CheckAdvancedSignalOptionsBox(false)
      , m_CheckAddNoiseBox(false)
      , m_CheckAddGhostsBox(false)
      , m_CheckAddAliasingBox(false)
      , m_CheckAddSpikesBox(false)
      , m_CheckAddEddyCurrentsBox(false)
      , m_CheckAddDistortionsBox(false)
      , m_MotionVolumesBox("random")
      , m_CheckRealTimeFibersBox(true)
      , m_CheckAdvancedFiberOptionsBox(false)
      , m_CheckConstantRadiusBox(false)
      , m_CheckIncludeFiducialsBox(true)
    {}

    DataNode::Pointer   m_ResultNode;                       
    DataNode::Pointer   m_ParentNode;                       
    string              m_SignalModelString;                
    string              m_ArtifactModelString;              
    string              m_OutputPath;                       
    string              m_OutputPrefix;  
    string              m_AfterSimulationMessage;           

    // image generation
    bool                m_CheckOutputVolumeFractionsBox;
    bool                m_CheckAdvancedSignalOptionsBox;
    bool                m_CheckAddNoiseBox;
    bool                m_CheckAddGhostsBox;
    bool                m_CheckAddAliasingBox;
    bool                m_CheckAddSpikesBox;
    bool                m_CheckAddEddyCurrentsBox;
    bool                m_CheckAddDistortionsBox;
    string              m_MotionVolumesBox;
    // fiber generation
    bool                m_CheckRealTimeFibersBox;
    bool                m_CheckAdvancedFiberOptionsBox;
    bool                m_CheckConstantRadiusBox;
    bool                m_CheckIncludeFiducialsBox;
  };

  template< class ScalarType = double >
  class FiberfoxParameters
  {
  public:

    typedef itk::Image<double, 3>                           ItkDoubleImgType;
    typedef itk::Image<unsigned char, 3>                    ItkUcharImgType;
    typedef DiffusionSignalModel<ScalarType>                DiffusionModelType;
    typedef std::vector< DiffusionModelType* >              DiffusionModelListType;
    typedef DiffusionNoiseModel<ScalarType>                 NoiseModelType;

    FiberfoxParameters();
    ~FiberfoxParameters();

    template< class OutType >
    FiberfoxParameters< OutType > CopyParameters()
    {
      FiberfoxParameters< OutType > out;

      out.m_FiberGen = m_FiberGen;
      out.m_SignalGen = m_SignalGen;
      out.m_Misc = m_Misc;

      if (m_NoiseModel!=NULL)
      {
        if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel.get()))
          out.m_NoiseModel = std::make_shared< mitk::RicianNoiseModel<OutType> >();
        else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel.get()))
          out.m_NoiseModel = std::make_shared< mitk::ChiSquareNoiseModel<OutType> >();
        out.m_NoiseModel->SetNoiseVariance(m_NoiseModel->GetNoiseVariance());
      }

      for (unsigned int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
      {
        mitk::DiffusionSignalModel<OutType>* outModel = NULL;
        mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
        if (i<m_FiberModelList.size())
          signalModel = m_FiberModelList.at(i);
        else
          signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());

        if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
          outModel = new mitk::StickModel<OutType>(dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel));
        else  if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
          outModel = new mitk::TensorModel<OutType>(dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel));
        else  if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
          outModel = new mitk::RawShModel<OutType>(dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel));
        else  if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
          outModel = new mitk::BallModel<OutType>(dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel));
        else if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
          outModel = new mitk::AstroStickModel<OutType>(dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel));
        else  if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
          outModel = new mitk::DotModel<OutType>(dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel));

        if (i<m_FiberModelList.size())
          out.m_FiberModelList.push_back(outModel);
        else
          out.m_NonFiberModelList.push_back(outModel);
      }

      return out;
    }

    FiberGenerationParameters           m_FiberGen;             
    SignalGenerationParameters          m_SignalGen;            
    MiscFiberfoxParameters              m_Misc;                 

    DiffusionModelListType              m_FiberModelList;       
    DiffusionModelListType              m_NonFiberModelList;    
    std::shared_ptr< NoiseModelType >   m_NoiseModel;           

    void PrintSelf();                           
    void SaveParameters(string filename);       
    void LoadParameters(string filename);       
    template< class ParameterType >
    ParameterType ReadVal(boost::property_tree::ptree::value_type const& v, std::string tag, ParameterType defaultValue, bool essential=false);
    std::string                         m_MissingTags;
  };
}

#include "mitkFiberfoxParameters.cpp"

#endif