freROI.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freROI.h,v $
  Language:  C++
 
 
 
  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.
 
=========================================================================*/

#ifndef __freROI_h
#define __freROI_h

#include "freElementals.h"
#include "freImageTypes.h"
#include "freImageIO.h"

#include "itkMaskImageFilter.h"
#include "itkImageMaskSpatialObject.h"
#include "itkRegionOfInterestImageFilter.h"

namespace FREE
{

template<unsigned int VImageDimension>
class ImageROIBase : public itk::LightObject
{
public:
    typedef ImageROIBase  Self;
    typedef itk::LightObject Superclass;
    typedef itk::SmartPointer<Self>        Pointer;
    typedef itk::SmartPointer<const Self>  ConstPointer;

    typedef typename ImageTypes<VImageDimension>::PointType PointType;
    typedef typename ImageTypes<VImageDimension>::InternalImageType ImageType;
    typedef typename ImageType::Pointer ImagePointer;
    typedef typename ImageType::RegionType RegionType;
    typedef typename ImageType::SpacingType SpacingType;

    typedef itk::SpatialObject<VImageDimension> SpatialObjectType;
    typedef typename SpatialObjectType::Pointer SpatialObjectPointer;

    itkTypeMacro( ImageROIBase, itk::LightObject );
    itkNewMacro(Self);

    static unsigned int GetImageDimension()
    {
        return VImageDimension;
    };

    ScalarType GetOriginPoint(const unsigned int& iDimension) const
    {
        if (iDimension<VImageDimension)
            return m_dOrigin[iDimension];
        else
            return 0.0;
    };

    void SetOriginPoint(const ScalarType& dPoint, const unsigned int& iDimension)
    {
        if (iDimension<VImageDimension)
        {
            m_dOrigin[iDimension] = dPoint;
        }
    };

    ScalarType GetSize(const unsigned int& iDimension) const
    {
        if (iDimension<VImageDimension)
            return m_dSize[iDimension];
        else
            return 0.0;
    };

    void SetSize(const ScalarType& dSize, const unsigned int& iDimension)
    {
        if (iDimension<VImageDimension)
        {
            m_dSize[iDimension] = dSize;
        }
    };

    virtual void Reset()
    {
        for (unsigned int i = 0; i < VImageDimension; i++)
        {
            m_dOrigin[i] = 0.0;
            m_dSize[i] = 0.0;
        }
    };

    virtual SpatialObjectPointer GetSpatialObject(const ImageType* pImage)
    {
        SpatialObjectPointer result = SpatialObjectType::New();
        result->SetSpacing(pImage->GetSpacing().GetDataPointer());
        result->SetLargestPossibleRegion(GetITKImageRegion(pImage->GetSpacing()));
        return result;
    };

    RegionType GetITKImageRegion(const SpacingType& rSpacing)
    {
        typename RegionType::SizeType size;
        typename RegionType::IndexType index;

        for (unsigned int iDim=0; iDim<VImageDimension; iDim++)
        {
            size[iDim] = GetSize(iDim)/rSpacing[iDim];
            index[iDim] = GetOriginPoint(iDim)/rSpacing[iDim];
        };

        return RegionType(index,size);
    };

    ImagePointer ExtractImageByROI(const ImageType* pImage)
    {
        ImagePointer extractImg;
        ExtractImageByROI<ImageType>(pImage,extractImg);
        return extractImg;
    }

    template< class TImage >
    void ExtractImageByROI(const TImage* pImage, typename TImage::Pointer& rExtractedImage)
    {
        //Extract the needed part of the image
        typedef itk::RegionOfInterestImageFilter< TImage, TImage > ImageExtractorType;

        typename ImageExtractorType::Pointer extractor = ImageExtractorType::New();

        RegionType region = GetITKImageRegion(pImage->GetSpacing());

        if (!region.Crop(pImage->GetLargestPossibleRegion()))
        {// region was out of bound, so set size to zero
            typename RegionType::SizeType size;
            size.Fill(0);
            region.SetSize(size);
        };

        extractor->SetRegionOfInterest(region);
        extractor->SetInput(pImage);
        extractor->Update();

        rExtractedImage = extractor->GetOutput();
    }

    virtual ImagePointer ReadyImageByROI(const ImageType* pImage)
    {
        return ExtractImageByROI(pImage);
    }

    virtual bool PointWithinROI(PointType point)
    {
        for(unsigned int i=0; i<VImageDimension; i++)
        {
            if( point[i] < m_dOrigin[i] )
            {
                return false;
            }
            if( point[i] >= m_dOrigin[i] + m_dSize[i] )
            {
                return false;
            }
        }
        return true;
    }

    virtual ~ImageROIBase()
    { }
    ;

protected:
    ImageROIBase()
    {
        Reset();
    };

    ScalarType m_dSize[VImageDimension];
    ScalarType m_dOrigin[VImageDimension];
}
; //class ImageROIBase

template<unsigned int VImageDimension>
class ImageMaskedROI : public ImageROIBase<VImageDimension>
{
public:
    typedef ImageMaskedROI  Self;
    typedef ImageROIBase<VImageDimension> Superclass;
    typedef itk::SmartPointer<Self>        Pointer;
    typedef itk::SmartPointer<const Self>  ConstPointer;

    typedef typename ImageTypes<VImageDimension>::MaskType MaskType;
    typedef typename MaskType::Pointer MaskPointer;

    typedef typename Superclass::PointType PointType;
    typedef typename Superclass::ImageType ImageType;
    typedef typename Superclass::ImagePointer ImagePointer;
    typedef typename Superclass::RegionType RegionType;
    typedef typename Superclass::SpacingType SpacingType;

    typedef typename Superclass::SpatialObjectType SpatialObjectType;
    typedef typename Superclass::SpatialObjectPointer SpatialObjectPointer;

    itkTypeMacro( ImageMaskedROIBase, ImageROIBase );
    itkNewMacro(Self);

    virtual void Reset()
    {
        for (unsigned int i = 0; i < VImageDimension; i++)
        {
            this->m_dOrigin[i] = 0.0;
            this->m_dSize[i] = 0.0;
        }
    };

    const MaskType* GetMask() const
    {
        return m_smpMask;
    };
    MaskType* GetMask()
    {
        return m_smpMask;
    };
    MaskPointer& GetMaskSmartPointer()
    {
        return m_smpMask;
    };

    void SetMask(MaskType* pMask)
    {
        m_smpMask = pMask;
    };

    void SetMask(const std::string& sMaskFile)
    {
        typedef ImageReader<LoadingPixelType,typename MaskType::PixelType,VImageDimension> ImageReaderType;
        ImageReaderType ImageReader;
        ImageReader.SetFileName(sMaskFile);
        try
        {
            m_smpMask = ImageReader.GetOutput();
        }
        catchAllNPassMacro("Error; while loading mask from file: " << sMaskFile);

        m_sMaskFile = sMaskFile;

        //TODO entscheiden, ob hier auch gleich geladen werden soll, bzw. wann dies geschehen soll beim Build oder actualize
        //passieren. zum anpassen Maske a ROI sollte bild in gre der ROI erzeugt werden und dann itkConstantPadImageFilter
        //zum kopieren benutzt werden.
    };

    std::string GetMaskFileName() const
    {
        return m_sMaskFile;
    };

    void SetMaskFileName(const std::string& sMaskFile)
    {
        m_sMaskFile = sMaskFile;
    };

    void SetMaskImage(const bool& bMaskImage)
    {
        this->m_bMaskReadyImage = bMaskImage;
    };
    bool GetMaskImage()
    {
        return this->m_bMaskReadyImage;
    };

    void SetMaskAtROIOrigin(const bool& bSameOrigin)
    {
        this->m_bMaskAtROIOrigin = bSameOrigin;
    };
    bool GetMaskAtROIOrigin()
    {
        return this->m_bMaskAtSameOrigin;
    };

    virtual SpatialObjectPointer GetSpatialObject(const ImageType* pImage)
    {
        typedef itk::ImageMaskSpatialObject<VImageDimension> MaskSpatialObjectType;
        typename MaskSpatialObjectType::Pointer spatialObject = MaskSpatialObjectType::New();
        spatialObject->SetImage(m_smpMask);
        SpatialObjectPointer result = static_cast<SpatialObjectType*>(spatialObject.GetPointer());
        return result;
    };

    virtual ImagePointer ReadyImageByROI(const ImageType* pImage)
    {
        ImagePointer tempImage = ExtractImageByROI(pImage);

        if (m_smpMask.IsNotNull())
        { //Mask the Image
            MaskPointer tempMask;
            Superclass::template ExtractImageByROI<MaskType>(m_smpMask,tempMask);

            typedef itk::MaskImageFilter< ImageType, MaskType, ImageType > MaskFilterType;
            typename MaskFilterType::Pointer maskFilter = MaskFilterType::New();

            maskFilter->SetInput1(tempImage);
            maskFilter->SetInput2(tempMask);
            maskFilter->Update();
            tempImage = maskFilter->GetOutput();
        }
        return tempImage;
    }

    virtual bool PointWithinROI(PointType point)
    {
        if (!Superclass::PointWithinROI(point))
            return false;

        if (m_smpMask.IsNull())
            return true;

        typename MaskType::IndexType index;
        if (m_smpMask->TransformPhysicalPointToIndex(point, index))
            return m_smpMask->GetPixel(index)>0;

        return false;
    }

protected:
    ImageMaskedROI()
    {
        Reset();
    };

    MaskPointer m_smpMask;
    std::string m_sMaskFile; //File of the mask, will only be used when mask is not set.
}
; //class ImageMaskedROI

template<class TROI>
class ROICoupleBase : public itk::LightObject
{
public:
    typedef ROICoupleBase  Self;
    typedef itk::LightObject Superclass;
    typedef itk::SmartPointer<Self>        Pointer;
    typedef itk::SmartPointer<const Self>  ConstPointer;

    typedef TROI ROIType;
    typedef typename ROIType::Pointer ROIPointer;
    typedef typename ROIType::PointType PointType;
    typedef typename ROIType::ImageType ImageType;
    typedef typename ROIType::ImagePointer ImagePointer;
    typedef typename ROIType::RegionType RegionType;
    typedef typename ROIType::SpacingType SpacingType;

    typedef typename ROIType::SpatialObjectType SpatialObjectType;
    typedef typename ROIType::SpatialObjectPointer SpatialObjectPointer;


    itkTypeMacro( ROICoupleBase, itk::LightObject );
    itkNewMacro(Self);

    static unsigned int GetImageDimension()
    {
        return ROIType::GetImageDimension();
    };

    const ROIType& Fixed() const
    {
        return *m_smpFixedROI;
    };
    ROIType& Fixed()
    {
        return *m_smpFixedROI;
    };

    const ROIType& Moving() const
    {
        return *m_smpMovingROI;
    };
    ROIType& Moving()
    {
        return *m_smpMovingROI;
    };


protected:
    ROICoupleBase()
    {
        m_smpFixedROI = ROIType::New();
        m_smpMovingROI = ROIType::New();
        m_smpMovingROI->Reset();
        m_smpMovingROI->Reset();
    };

    virtual ~ROICoupleBase()
    {}
    ;

private:
    ROIPointer m_smpFixedROI;
    ROIPointer m_smpMovingROI;
}
; //class ROICoupleBase

template<unsigned int VImageDimension>
class ImageROICoupleBase : public ROICoupleBase< ImageROIBase<VImageDimension> >
{
public:
    typedef ImageROICoupleBase  Self;
    typedef ROICoupleBase< ImageROIBase<VImageDimension> > Superclass;
    typedef itk::SmartPointer<Self>        Pointer;
    typedef itk::SmartPointer<const Self>  ConstPointer;

    itkTypeMacro( ImageROICoupleBase, ROICoupleBase );
    itkNewMacro(Self);

protected:
    ImageROICoupleBase()
    {  }
    ;

    virtual ~ImageROICoupleBase()
    {  }
    ;
}
; //class ImageROICoupleBase

template<unsigned int VImageDimension>
class ImageMaskedROICouple : public ROICoupleBase< ImageMaskedROI<VImageDimension> >
{
public:
    typedef ImageMaskedROICouple  Self;
    typedef ROICoupleBase< ImageMaskedROI<VImageDimension> > Superclass;
    typedef itk::SmartPointer<Self>        Pointer;
    typedef itk::SmartPointer<const Self>  ConstPointer;

    itkTypeMacro( ImageMaskedROICouple, ImageROICoupleBase );
    itkNewMacro(Self);

protected:
    ImageMaskedROICouple()
    {  }
    ;

    virtual ~ImageMaskedROICouple()
    {  }
    ;
}
; //class ImageMaskedROICouple

}  // namespace free

#endif

---