itk::PSMCleanAndCenterLabelMapImageFilter< TImage > Class Template Reference

Process an input segmentation to produce an isotropically spaced version with holes filled and center-of-mass at the origin. More...

#include <itkPSMCleanAndCenterLabelMapImageFilter.h>

Inheritance diagram for itk::PSMCleanAndCenterLabelMapImageFilter< TImage >:

Collaboration diagram for itk::PSMCleanAndCenterLabelMapImageFilter< TImage >:

Public Types
typedef PSMCleanAndCenterLabelMapImageFilter	Self
typedef ImageToImageFilter< TImage, TImage >	Superclass
typedef SmartPointer< Self >	Pointer
typedef SmartPointer< const Self >	ConstPointer
typedef TImage	ImageType
typedef ImageType::PixelType	PixelType
typedef ImageType::PointType	PointType
typedef ImageType::RegionType	RegionType
typedef RegionType::SizeType	SizeType
typedef RegionType::IndexType	IndexType

Public Member Functions
	itkNewMacro (Self)
	itkTypeMacro (PSMCleanAndCenterLabelMapImageFilter, ImageToImageFilter)
	itkStaticConstMacro (Dimension, unsigned int, TImage::ImageDimension)
void	GenerateData ()
	itkSetMacro (ForegroundValue, PixelType)
	itkGetMacro (ForegroundValue, PixelType)
	itkSetMacro (BackgroundValue, PixelType)
	itkGetMacro (BackgroundValue, PixelType)

Protected Member Functions
void	PrintSelf (std::ostream &os, Indent indent) const
void	IsolateLargestComponent (ImageType *) const
void	FillHoles (ImageType *) const
void	ResampleToIsotropic (ImageType *) const
void	Center (ImageType *)
virtual void	GenerateOutputInformation ()
virtual void	GenerateInputRequestedRegion ()

Detailed Description

template<class TImage>
class itk::PSMCleanAndCenterLabelMapImageFilter< TImage >

Process an input segmentation to produce an isotropically spaced version with holes filled and center-of-mass at the origin.

This filter may be used to turn a label map (segmentation) image into an isotropic version with its center-of-mass at the origin. This filter is intended to be used as part of a preprocessing pipeline to prepare segmentations for use with any of the Particle Shape Modeling filters (e.g. PSMEntropyModelFilter).

The filter processes the input image as follows:

1) The largest connected component for the specified foreground component is identified and isolated. All other pixels in the image are set to the background value (default zero).

2) Holes are filled in the segmentation resulting from Step 1.

3) The image is resampled to isotropic voxels, if necessary.

4) The center of mass of the foreground object is computed and the center of the image is transformed to that location.

NOTE: This filter assumes that the upper-left-hand corner of the image is NOT part of the foreground.

WHAT ARE THE PARAMETERS?

This filter is templated over the input image type. It produces an output image of the same type.

Author

Josh Cates

Definition at line 63 of file itkPSMCleanAndCenterLabelMapImageFilter.h.

Member Typedef Documentation

template<class TImage>

typedef TImage itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::ImageType

Image-type-related typedefs

Definition at line 74 of file itkPSMCleanAndCenterLabelMapImageFilter.h.

template<class TImage>

typedef PSMCleanAndCenterLabelMapImageFilter itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::Self

Standard class typedefs.

Definition at line 68 of file itkPSMCleanAndCenterLabelMapImageFilter.h.

Member Function Documentation

template<class TImage >

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::Center ( ImageType *  work )

protected

Translates the center-of-mass to the center of the image. Also modifies the image information.

Definition at line 214 of file itkPSMCleanAndCenterLabelMapImageFilter.hxx.

{
  // Reset the physical coordinates at the center of the image to (0,0,0)
  PointType lower;
  PointType upper;
  PointType ul_physical_coords;
  work->TransformIndexToPhysicalPoint(work->GetBufferedRegion().GetIndex(),
                                      lower);
  work->TransformIndexToPhysicalPoint(work->GetBufferedRegion().GetIndex() 
                                      + work->GetBufferedRegion().GetSize(), upper);
  for (unsigned int i = 0; i < Dimension; i++)
    {
    ul_physical_coords[i] = -(lower[i] + upper[i]) / 2.0;
    }
  
  // IndexType idx;
  // work->TransformPhysicalPointToIndex(ul_physical_coords,idx);
  
  // It is confusing, but the following command sets the physical coordinates
  // of pixel number 0,0,0... (i.e. the upper-left corner of the volume).
  work->SetOrigin(ul_physical_coords);
  
 // Find the center of mass.
  ImageRegionIteratorWithIndex<ImageType> oit(work, work->GetBufferedRegion());
  oit.GoToBegin();
  
  Array<double> params(Dimension);
  params.Fill(0.0);
  double count = 0.0;
  Point<double, Dimension> point;
  for (; ! oit.IsAtEnd(); ++oit)
    {
    if (oit.Get() != m_BackgroundValue)
      {
      // Get the physical index from the image index.
      work->TransformIndexToPhysicalPoint(oit.GetIndex(), point);
      for (unsigned int i = 0; i < Dimension; i++) { params[i] += point[i]; }
      count += 1.0;
      }
    }
  
  // Compute center of mass.
  for (unsigned int i = 0; i < Dimension; i++)
    {
    params[i] = params[i] / count;
    }
  
  // Translate the segmentation into the output
  typename TranslationTransform<double,Dimension>::Pointer trans
    = TranslationTransform<double,Dimension>::New();
  trans->SetParameters(params);
  
  typename NearestNeighborInterpolateImageFunction<ImageType,double>::Pointer
    interp = NearestNeighborInterpolateImageFunction<ImageType,double>::New();
  
  typename ResampleImageFilter<ImageType, ImageType>::Pointer resampler
    = ResampleImageFilter<ImageType, ImageType>::New();
  resampler->SetOutputParametersFromImage(work);
  resampler->SetTransform(trans);
  resampler->SetInterpolator(interp);
  resampler->SetInput(work);

 // the size.
  this->GetOutput()->SetRegions(this->GetInput()->GetLargestPossibleRegion());
  this->GetOutput()->Allocate();

  // pipe to the output image
  resampler->GraftOutput(this->GetOutput());
  resampler->Update();

  // also necessary for pipe to output
  // see itkImageSource for description
  this->GraftOutput(resampler->GetOutput());

  // Make sure the image information is correct.
  //  itk::Matrix<double,3,3> I;
  //  I.SetIdentity();
  // this->GetOutput()->SetDirection(I);
}

template<class TImage >

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::FillHoles ( ImageType *  work ) const

protected

Fills holes in the foreground segmentation.

Definition at line 171 of file itkPSMCleanAndCenterLabelMapImageFilter.hxx.

{

  // TODO: Need a check to see if the UL corner is background value.
  IndexType idx;
  idx.Fill(0);

  if (work->GetPixel(idx) == m_ForegroundValue)
    {
    itkWarningMacro("Could not fill holes. Upper-left hand corner is not in the background. See documentation for this filter for more information.")
    }
  
  // Find a background value seed at the boundary. Assumption is that
  // the corner index is background.
  typename ConnectedThresholdImageFilter<ImageType, ImageType>::IndexType seed;
  seed.Fill(NumericTraits<PixelType>::Zero);
  
  // Flood fill the background with the foreground value.
  typename itk::ConnectedThresholdImageFilter<ImageType, ImageType >::Pointer
    ccfilter = itk::ConnectedThresholdImageFilter<ImageType, ImageType>::New();
  ccfilter->SetInput(work);
  ccfilter->SetLower(m_BackgroundValue);
  ccfilter->SetUpper(m_BackgroundValue);
  ccfilter->SetSeed(seed);
  ccfilter->SetReplaceValue(m_ForegroundValue);
  ccfilter->Update();

  // Logical "OR" the original image with the inverse (foreground/background flipped)
  // of the flood-filled copy.
  itk::ImageRegionConstIterator<ImageType> rit(ccfilter->GetOutput(),
                                               work->GetBufferedRegion());
  itk::ImageRegionIterator<ImageType> it(work,work->GetBufferedRegion());
  for (; !rit.IsAtEnd(); ++rit, ++it)
    {
    if (rit.Get() == m_BackgroundValue)
      {
      it.Set(m_ForegroundValue);
      }
    }
}

template<class TImage >

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::GenerateData

(

)

Do the work of batch-processing the input images.

Definition at line 91 of file itkPSMCleanAndCenterLabelMapImageFilter.hxx.

{
  // Allocate work image.  Same size as input.  Later we will crop it.
  typename ImageType::Pointer work = ImageType::New();
  work->CopyInformation(this->GetInput());
  work->SetRegions(this->GetInput()->GetRequestedRegion());
  work->Allocate();

  // Isolate largest connected component into the work image.
  // Modifies the work image.
  this->IsolateLargestComponent(work);

  // We are done with inputs.  Release them if requested.
  this->ReleaseInputs();

  // Fill holes in the working image
  this->FillHoles(work);

  // Resample the image to isotropic volumes, in case it is not already.
  this->ResampleToIsotropic(work);
  
  // Reset the origin to the center of the image and translate the
  // center-of-mass of the segmentation to the origin.
  this->Center(work);



}

template<class TImage >

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::GenerateInputRequestedRegion ( )

protectedvirtual

This filter must provide an implementation for GenerateInputRequestedRegion() in order to inform the pipeline execution model.

See also

ProcessObject::GenerateInputRequestedRegion()

Definition at line 62 of file itkPSMCleanAndCenterLabelMapImageFilter.hxx.

{
  // We need the whole image!
  // Get pointers to the input and output.
  typename Superclass::InputImagePointer inputPtr =
    const_cast< TImage * >( this->GetInput() );
  typename Superclass::OutputImagePointer outputPtr 
    = this->GetOutput();

  if ( !inputPtr || !outputPtr )
    {
    return;
    }

  inputPtr->SetRequestedRegion( inputPtr->GetLargestPossibleRegion());
}

template<class TImage >

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::GenerateOutputInformation ( )

protectedvirtual

This filter must provide an implementation for GenerateOutputInformation() in order to inform the pipeline execution model. The original documentation of this method is below.

See also

ProcessObject::GenerateOutputInformaton()

Definition at line 82 of file itkPSMCleanAndCenterLabelMapImageFilter.hxx.

{
  // call the superclass' implementation of this method
  Superclass::GenerateOutputInformation();
}

template<class TImage >

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::IsolateLargestComponent ( ImageType *  work ) const

protected

Isolates the largest connected component in an image. Pixels in this component are set to the foreground value and pixels in other components are set to the background value.

Definition at line 122 of file itkPSMCleanAndCenterLabelMapImageFilter.hxx.

{
  // Create a connected component filter
  typename itk::ConnectedComponentImageFilter<TImage, TImage>::Pointer ccfilter 
    = itk::ConnectedComponentImageFilter<TImage, TImage>::New();
  ccfilter->SetInput(this->GetInput());
  ccfilter->FullyConnectedOn();
  ccfilter->Update();
  
  // First find the size of the connected components.
  std::map<int, int> sizes;
  ImageRegionConstIterator<TImage> rit(ccfilter->GetOutput(),
                                       ccfilter->GetOutput()->GetBufferedRegion());
  for (; !rit.IsAtEnd(); ++rit)
    {
      if (rit.Get() > 0)
        {
          sizes[rit.Get()] = sizes[rit.Get()] + 1;
        }
    }
  
  // Find largest connected component. Assumes connected component
  // algorithm enumerates sequentially. (This is true for the ITK
  // algorithm). Copy largest connected component into work image.
  int maxsize = 0;
  int bigcomponent = 0;
  for (typename std::map<int, int>::const_iterator mapit = sizes.begin();
       mapit != sizes.end(); mapit++)
    {
      if ((*mapit).second > maxsize)
        {
          bigcomponent = (*mapit).first;
          maxsize = (*mapit).second;
        }
    }
  
  // Copy result into work image. Remove all but the largest connected component.
  ImageRegionIterator<TImage> it(work, work->GetBufferedRegion());
  rit.GoToBegin();
  it.GoToBegin();
  for ( ; ! rit.IsAtEnd(); ++it, ++rit)
    {
      if (rit.Get() == bigcomponent) it.Set(m_ForegroundValue);
      else it.Set(m_BackgroundValue);
    }  
}

template<class TImage>

itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::itkNewMacro

(

Self

)

Method for creation through the object factory.

template<class TImage>

itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::itkSetMacro	(	ForegroundValue	,
		PixelType
	)

Set/Get the foreground value. This is the label of interest in the input images. All other values in the input images will be considered background and relabeled to the background value in the output. You MUST set this value. Default value is 1.

template<class TImage>

itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::itkSetMacro	(	BackgroundValue	,
		PixelType
	)

Get/Set the background value. This is the value to which all non-foreground values will be changed in the output. The default value is zero.

template<class TImage>

itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::itkStaticConstMacro	(	Dimension	,
		unsigned	int,
		TImage::ImageDimension
	)

Dimensionality of the domain of the particle system.

template<class TImage>

itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::itkTypeMacro	(	PSMCleanAndCenterLabelMapImageFilter< TImage >	,
		ImageToImageFilter
	)

Run-time type information (and related methods).

template<class TImage>

void itk::PSMCleanAndCenterLabelMapImageFilter< TImage >::ResampleToIsotropic ( ImageType *  ) const

inlineprotected

Resamples the image to isotropic voxel spacing if needed.

Definition at line 120 of file itkPSMCleanAndCenterLabelMapImageFilter.h.

  {
    return;
  }

---

The documentation for this class was generated from the following files:

• C:/Users/Brig/Documents/ShapeWorksStudio/src/ParticleShapeworks/include/itkPSMCleanAndCenterLabelMapImageFilter.h
• C:/Users/Brig/Documents/ShapeWorksStudio/src/ParticleShapeworks/include/itkPSMCleanAndCenterLabelMapImageFilter.hxx