itkBoundaryShiftIntegralCalculator.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). 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 in the top level directory for details.

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

#ifndef itkBoundaryShiftIntegralCalculator_h
#define itkBoundaryShiftIntegralCalculator_h

#include <itkImage.h>
#include <itkObject.h>
#include <itkMacro.h>

namespace itk
{

template <class TInputImage, class TInputMask, class TOutputImage>
class ITK_EXPORT BoundaryShiftIntegralCalculator: public Object
{
public:
  typedef BoundaryShiftIntegralCalculator Self;
  typedef Object Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  typedef typename TInputImage::Pointer TInputImagePointer;
  typedef typename TInputMask::Pointer TInputMaskPointer;
  typedef itk::Image<int, 3> IntImageType;
  itkNewMacro(Self);  
  itkTypeMacro(BoundaryShiftIntegralCalculator, Object);
  itkGetMacro(BoundaryShiftIntegral, double);
  itkSetMacro(BaselineImage, TInputImagePointer);
  itkSetMacro(BaselineMask, TInputMaskPointer);
  itkSetMacro(RepeatImage, TInputImagePointer);
  itkSetMacro(RepeatMask, TInputMaskPointer);
  itkSetMacro(NumberOfErosion, unsigned int);
  itkSetMacro(NumberOfDilation, unsigned int);
  itkSetMacro(NumberOfSubROIDilation, unsigned int);
  itkSetMacro(SubROIMask, TInputMaskPointer);
  itkSetMacro(UpperCutoffValue, double);
  itkSetMacro(LowerCutoffValue, double);
  itkSetMacro(BaselineIntensityNormalisationFactor, double);
  itkSetMacro(RepeatIntensityNormalisationFactor, double);
  itkSetMacro(PaddingValue, typename TInputMask::PixelType);
  itkGetMacro(BSIMask, TInputMaskPointer);
  itkSetMacro(BSIMask, TInputMaskPointer);
  itkGetMacro(BSIMap,typename TOutputImage::Pointer); 
  itkGetMacro(BSIMapSIENAStyle,TInputImagePointer); 
  itkGetMacro(XORMap, TInputImagePointer);
  itkSetMacro(ProbabilisticBSI, unsigned int);  

  virtual void Compute(void);
  void PrintSelf(std::ostream& os, Indent indent) const override;
  static void PerformLinearRegression(const std::vector<double>& x, const std::vector<double>& y, double* slope, double* intercept)
  {
    assert(x.size() == y.size());
    
    double correlation = 0.0;
    double meanX = 0.0;
    double meanY = 0.0;
    double varianceX = 0.0;
    int sizeOfArray = x.size();
    
    for (int arrayIndex = 0; arrayIndex < sizeOfArray; arrayIndex++)
    {
      meanX += x[arrayIndex]; 
      meanY += y[arrayIndex]; 
    }
    meanX /= sizeOfArray;
    meanY /= sizeOfArray;
    
    for (int arrayIndex = 0; arrayIndex < sizeOfArray; arrayIndex++)
    {
      correlation += (x[arrayIndex]-meanX)*(y[arrayIndex]-meanY);
      varianceX += (x[arrayIndex]-meanX)*(x[arrayIndex]-meanX);
    }
    *slope = correlation/varianceX;
    *intercept = meanY-(*slope)*meanX;
  }

protected:
  BoundaryShiftIntegralCalculator();
  virtual ~BoundaryShiftIntegralCalculator();
  virtual void ComputeBSIMask(void);
  virtual void ComputeGBSIMask(void);
  virtual void ComputeLedigMask(void);
  virtual void IntegrateOverBSIMask(void) throw (ExceptionObject);
  
protected:
  void ComputeErodedIntersectMask(void);
  void ComputeDilatedUnionMask(void);
  double m_BoundaryShiftIntegral;
  TInputImagePointer m_BaselineImage;
  TInputMaskPointer m_BaselineMask;
  TInputImagePointer m_RepeatImage;
  TInputMaskPointer m_RepeatMask;
  unsigned int m_NumberOfSubROIDilation;
  TInputMaskPointer m_SubROIMask;
  unsigned int m_NumberOfErosion;
  typename IntImageType::Pointer m_ErodedIntersectMask;
  unsigned int m_NumberOfDilation;
  typename IntImageType::Pointer m_DilatedUnionMask;
  typename TInputMask::PixelType m_PaddingValue;
  TInputMaskPointer m_BSIMask;
  double m_UpperCutoffValue;
  double m_LowerCutoffValue;
  double m_BaselineIntensityNormalisationFactor;
  double m_RepeatIntensityNormalisationFactor;
  typename TOutputImage::Pointer m_BSIMap;  
  TInputImagePointer m_BSIMapSIENAStyle; 
  TInputImagePointer m_XORMap; 
  unsigned int m_ProbabilisticBSI;

  typename IntImageType::Pointer m_BaselineMaskInt;
  typename IntImageType::Pointer m_RepeatMaskInt;
  typename IntImageType::Pointer m_PORMaskInt;
  typename IntImageType::Pointer m_PANDMaskInt;
  
  TInputMaskPointer m_POR;
  TInputMaskPointer m_PAND;
  
  void ComputePORandPANDMask(void);
  void ComputePORandPANDMaskLedig(void);

  
private:  
  BoundaryShiftIntegralCalculator(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

};

}

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBoundaryShiftIntegralCalculator.txx"
#endif

#endif