itkBRAINSROIAutoImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Program:   Insight Segmentation & Registration Toolkit
 *  Module:    $RCSfile: itkBRAINSROIAutoImageFilter.h,v $
 *  Language:  C++
 *  Date:      $Date: 2008-10-16 19:33:40 $
 *  Version:   $Revision: 1.7 $
 *
 *  Copyright (c) Insight Software Consortium. All rights reserved.
 *  See ITKCopyright.txt or http://www.itk.org/HTML/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 __itkBRAINSROIAutoImageFilter_h
#define __itkBRAINSROIAutoImageFilter_h

// First make sure that the configuration is available.
// This line can be removed once the optimized versions
// gets integrated into the main directories.
#include "itkConfigure.h"
#include "itkImageToImageFilter.h"
#include "itkImage.h"

#include "itkImageMaskSpatialObject.h"
#include "itkLargestForegroundFilledMaskImageFilter.h"
#include "itkCastImageFilter.h"

typedef itk::SpatialObject< 3 >    SpatialObjectType;
typedef SpatialObjectType::Pointer ImageMaskPointer;

namespace itk
{
template< class TInputImage, class TOutputImage >
class ITK_EXPORT BRAINSROIAutoImageFilter:
  public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);
  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  typedef TInputImage  InputImageType;
  typedef TOutputImage OutputImageType;

  typedef BRAINSROIAutoImageFilter                              Self;
  typedef ImageToImageFilter< InputImageType, OutputImageType > Superclass;
  typedef SmartPointer< Self >                                  Pointer;
  typedef SmartPointer< const Self >                            ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(BRAINSROIAutoImageFilter, ImageToImageFilter);

  typedef typename InputImageType::PixelType  InputPixelType;
  typedef typename OutputImageType::PixelType OutputPixelType;

  typedef typename InputImageType::RegionType  InputImageRegionType;
  typedef typename OutputImageType::RegionType OutputImageRegionType;

  typedef typename InputImageType::SizeType InputSizeType;

  typedef itk::Image< unsigned char, 3 >                            UCHARIMAGE;
  typedef itk::ImageMaskSpatialObject< UCHARIMAGE::ImageDimension > ImageMaskSpatialObjectType;

  itkSetMacro(OtsuPercentileThreshold, double);
  itkGetConstMacro(OtsuPercentileThreshold, double);
  itkSetMacro(ThresholdCorrectionFactor, double);
  itkGetConstMacro(ThresholdCorrectionFactor, double);
  itkSetMacro(ClosingSize, double);
  itkGetConstMacro(ClosingSize, double);
  itkSetMacro(DilateSize, double);
  itkGetConstMacro(DilateSize, double);

  // NOTE:  This will generate a new spatial object each time it is called, and
  // not return the previous spatial object
  ImageMaskPointer GetSpatialObjectROI(void)
  {
    if ( m_ResultMaskPointer.IsNull() ) // This is a cheap way to only create
                                        // the mask once, note that this is made
                                        // null when GenerateData is called.
      {
      typedef itk::CastImageFilter< OutputImageType, UCHARIMAGE > CastImageFilter;
      typename CastImageFilter::Pointer castFilter = CastImageFilter::New();
      castFilter->SetInput( this->GetOutput() );
      castFilter->Update();

      // convert mask image to mask
      typename ImageMaskSpatialObjectType::Pointer mask = ImageMaskSpatialObjectType::New();
      mask->SetImage( castFilter->GetOutput() );
      mask->ComputeObjectToWorldTransform();
      m_ResultMaskPointer = dynamic_cast< ImageMaskSpatialObjectType * >( mask.GetPointer() );
      }
    return m_ResultMaskPointer;
  }
  typename UCHARIMAGE::ConstPointer GetBinaryImageROI()
  {
    ImageMaskPointer tmp = this->GetSpatialObjectROI();
    typename UCHARIMAGE::ConstPointer rval;
    if(tmp.IsNotNull())
      {
      typename itk::ImageMaskSpatialObject<3>::Pointer imso =
        dynamic_cast<itk::ImageMaskSpatialObject<3> *>
        (tmp.GetPointer());
      if(imso.IsNotNull())
        {
        rval = imso->GetImage();
        }
      }
    return rval;
  }
#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro( SameDimensionCheck,
                   ( Concept::SameDimension< InputImageDimension, OutputImageDimension > ) );
#endif
protected:
  BRAINSROIAutoImageFilter();
  virtual ~BRAINSROIAutoImageFilter() {}
  void PrintSelf(std::ostream & os, Indent indent) const;

  void GenerateData();

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

  double           m_OtsuPercentileThreshold;
  double           m_ThresholdCorrectionFactor;
  double           m_ClosingSize;
  double           m_DilateSize;
  ImageMaskPointer m_ResultMaskPointer;
};
} // end namespace itk

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

#endif