itkMammogramRegistrationFilter.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 itkMammogramRegistrationFilter_h
#define itkMammogramRegistrationFilter_h

#include <itkImageToImageFilter.h>

#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>

#include <itkImageMomentsCalculator.h>
#include <itkImageRegistrationFactory.h>
#include <itkMammogramMaskSegmentationImageFilter.h>

namespace itk
{


template< class TInputImage, class TOutputImage >
class MammogramRegistrationFilter :
  public ImageToImageFilter< TInputImage, TOutputImage >
{
public:

  typedef MammogramRegistrationFilter Self;
  typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass;
  typedef SmartPointer< Self > Pointer;

  itkNewMacro(Self);

  itkTypeMacro(MammogramRegistrationFilter, ImageToImageFilter);

  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef TInputImage                           InputImageType;
  typedef typename InputImageType::Pointer      InputImagePointer;
  typedef typename InputImageType::ConstPointer InputImageConstPointer;
  typedef typename InputImageType::RegionType   InputImageRegionType;
  typedef typename InputImageType::PixelType    InputImagePixelType;
  typedef typename InputImageType::SpacingType  InputImageSpacingType;
  typedef typename InputImageType::PointType    InputImagePointType;

  typedef typename NumericTraits<InputImagePixelType>::RealType    RealType;

  typedef TOutputImage                          OutputImageType;
  typedef typename OutputImageType::Pointer     OutputImagePointer;
  typedef typename OutputImageType::RegionType  OutputImageRegionType;
  typedef typename OutputImageType::PixelType   OutputImagePixelType;
  typedef typename OutputImageType::IndexType   OutputImageIndexType;
  typedef typename OutputImageType::PointType   OutputImagePointType;


  typedef typename itk::Vector< float, ImageDimension > VectorPixelType;
  typedef typename itk::Image< VectorPixelType, ImageDimension > DeformationFieldType;

  typedef typename itk::ImageFileReader< InputImageType > FileReaderType;
  typedef typename itk::ImageFileWriter< InputImageType > FileWriterType;



  typedef double ScalarType;

  typedef typename itk::ImageRegistrationFactory< InputImageType, ImageDimension, ScalarType > FactoryType;

  typedef typename FactoryType::EulerAffineTransformType EulerAffineTransformType;
  typedef typename EulerAffineTransformType::Pointer EulerAffinePointerType;

  typedef typename itk::ImageMomentsCalculator< InputImageType > ImageMomentCalculatorType;

  typedef typename itk::MammogramMaskSegmentationImageFilter<InputImageType, InputImageType> MammogramMaskFilterType;


  void SetVerboseOn( void ) { m_FlgVerbose = true; }
  void SetVerboseOff( void ) { m_FlgVerbose = false; }

  void SetDebugOn( void ) { m_FlgDebug = true; }
  void SetDebugOff( void ) { m_FlgDebug = false; }

  void SetOverwriteRegistration( void ) { m_FlgOverwrite = true; }

  void SetExecutablesDirectoryToTry( std::string dir ) { m_DirExecutable = dir; }

  typedef enum {
    REGISTER_ORIGINAL_IMAGES,
    REGISTER_MASKS,
    REGISTER_DISTANCE_TRANSFORMS
  } enumRegistrationImagesType;

  void SetTypeOfInputImagesToRegister( enumRegistrationImagesType regImagesType ) {
    m_TypeOfInputImagesToRegister = regImagesType;
  }

  itkSetMacro( ControlPointSpacing, float );
  itkGetMacro( ControlPointSpacing, float );

  itkSetMacro( NumberOfLevels, unsigned int );
  itkGetMacro( NumberOfLevels, unsigned int );

  itkSetMacro( NumberOfLevelsToUse, unsigned int );
  itkGetMacro( NumberOfLevelsToUse, unsigned int );


  void SetTargetImage(InputImagePointer imTarget) { this->SetInput(0, imTarget); }

  void SetSourceImage(InputImagePointer imSource) { this->SetInput(1, imSource); }

  void SetTargetMask(InputImagePointer maskTarget) { this->SetInput(2, maskTarget); }

  void SetSourceMask(InputImagePointer maskSource) { this->SetInput(3, maskSource); }

  void SetTargetRegnMask(InputImagePointer maskTargetRegn) { this->SetInput(4, maskTargetRegn); }



  void SetWorkingDirectory( std::string directory ) {
    m_DirWorking = directory;
  }


  void SetFileTarget( std::string filename ) {
    m_FileTarget = filename;
  }
  void SetFileSource( std::string filename ) {
    m_FileSource = filename;
  }

  void SetFileTargetMask( std::string filename ) {
    m_FileTargetMask = filename;
  }
  void SetFileSourceMask( std::string filename ) {
    m_FileSourceMask = filename;
  }

  void SetFileInputTargetRegistrationMask( std::string filename ) {
    m_FileInputTargetRegistrationMask = filename;
  }

  void SetFileOutputTargetRegistrationMask( std::string fileOut ) {
    m_FileOutputTargetRegistrationMask = fileOut;
  }

  void SetFileTargetDistanceTransform( std::string fileOut ) {
    m_FileTargetDistanceTransform = fileOut;
  }
  void SetFileSourceDistanceTransform( std::string fileOut ) {
    m_FileSourceDistanceTransform = fileOut;
  }

  void SetFileOutputAffineTransformation( std::string fileOut ) {
    m_FileOutputAffineTransformation = fileOut;
  }
  void SetFileOutputNonRigidTransformation( std::string fileOut ) {
    m_FileOutputNonRigidTransformation = fileOut;
  }
  void SetFileOutputDeformation( std::string fileOut ) {
    m_FileOutputDeformation = fileOut;
  }

  void SetFileOutputAffineRegistered( std::string fileOut ) {
    m_FileOutputAffineRegistered = fileOut;
  }
  void SetFileOutputNonRigidRegistered( std::string fileOut ) {
    m_FileOutputNonRigidRegistered = fileOut;
  }

  void SetRegisterNonRigid( void ) { m_FlgRegisterNonRigid = true; }

  InputImagePointType TransformPoint( InputImagePointType point );

  void NonRigidlyTransformImageFile( std::string fileImage, std::string fileResult );

#ifdef ITK_USE_CONCEPT_CHECKING
  itkConceptMacro(DimensionShouldBe2,
                  (Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension),2>));
  itkConceptMacro(InputHasNumericTraitsCheck,
                  (Concept::HasNumericTraits<InputImagePixelType>));
  itkConceptMacro(OutputHasPixelTraitsCheck,
                  (Concept::HasPixelTraits<OutputImagePixelType>));
#endif


protected:
  MammogramRegistrationFilter();
  ~MammogramRegistrationFilter(){}

  bool m_FlgVerbose;
  bool m_FlgDebug;

  bool m_FlgOverwrite;

  bool m_FlgRegisterNonRigid;

  enumRegistrationImagesType m_TypeOfInputImagesToRegister;

  float m_ControlPointSpacing;

  unsigned int m_NumberOfLevels;
  unsigned int m_NumberOfLevelsToUse;

  std::string m_DirWorking;
  std::string m_DirExecutable;

  std::string m_FileTarget;
  std::string m_FileSource;

  std::string m_FileTargetMask;
  std::string m_FileSourceMask;

  std::string m_FileInputTargetRegistrationMask;

  std::string m_FileOutputTargetRegistrationMask;

  std::string m_FileTargetDistanceTransform;
  std::string m_FileSourceDistanceTransform;

  std::string m_FileOutputAffineTransformation;
  std::string m_FileOutputNonRigidTransformation;

  std::string m_FileOutputDeformation;

  std::string m_FileOutputAffineRegistered;
  std::string m_FileOutputNonRigidRegistered;

  InputImagePointer m_Target;
  InputImagePointer m_Source;

  InputImagePointer m_TargetMask;
  InputImagePointer m_SourceMask;

  InputImagePointer m_TargetRegnMask;

  EulerAffinePointerType m_AffineTransform;

  typename DeformationFieldType::Pointer m_DeformationField;

  std::string ImageFileIsNiftiOrConvert( std::string fileInput );

  InputImagePointer GetDistanceTransform( InputImagePointer imMask );

  InputImagePointer GetTargetRegistrationMask( InputImagePointer imMask );

  void InitialiseTransformationFromImageMoments( InputImagePointer imTarget,
                                                 InputImagePointer imSource );

  std::string AddSamplingFactorSuffix( std::string fileInput, float ampling );
  std::string FileOfImageWithDimensionsLessThan2048( std::string fileInput );

  void Print( void );

  InputImagePointer RunAffineRegistration( InputImagePointer imTarget,
                                           InputImagePointer imSource,
                                           int finalInterpolator=4,
                                           int registrationInterpolator=2 );

  InputImagePointer RunNonRigidRegistration( void );

  bool ReadAffineTransformation( std::string fileAffineTransformation );
  bool ReadNonRigidDeformationField( std::string fileInputDeformation );

  bool ReadRegistrationData();

  virtual void GenerateData();

  DataObject::Pointer MakeOutput(unsigned int idx);

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

};


} // namespace itk


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

#endif