itk::PSMTrimLabelMapImageFilter< TImage > Class Template Reference

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

#include <itkPSMTrimLabelMapImageFilter.h>

Inheritance diagram for itk::PSMTrimLabelMapImageFilter< TImage >:

Collaboration diagram for itk::PSMTrimLabelMapImageFilter< TImage >:

Public Types
typedef PSMTrimLabelMapImageFilter	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 (PSMTrimLabelMapImageFilter, ImageToImageFilter)
	itkStaticConstMacro (Dimension, unsigned int, TImage::ImageDimension)
void	GenerateData ()
	itkSetMacro (ForegroundValue, PixelType)
	itkGetMacro (ForegroundValue, PixelType)
	itkSetMacro (BackgroundValue, PixelType)
	itkGetMacro (BackgroundValue, PixelType)
const RegionType &	GetBoundingBox () const

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

Detailed Description

template<class TImage>
class itk::PSMTrimLabelMapImageFilter< TImage >

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

This filter may be used to turn a label map (segmentation) image into a cropped 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 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 61 of file itkPSMTrimLabelMapImageFilter.h.

Member Typedef Documentation

template<class TImage>

typedef TImage itk::PSMTrimLabelMapImageFilter< TImage >::ImageType

Image-type-related typedefs

Definition at line 72 of file itkPSMTrimLabelMapImageFilter.h.

template<class TImage>

typedef PSMTrimLabelMapImageFilter itk::PSMTrimLabelMapImageFilter< TImage >::Self

Standard class typedefs.

Definition at line 66 of file itkPSMTrimLabelMapImageFilter.h.

Member Function Documentation

template<class TImage >

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

protected

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

Definition at line 219 of file itkPSMTrimLabelMapImageFilter.hxx.

{
  // // // Reset the origin of the image to the very center of the image.
  // // //  double orig[Dimension];
   PointType lower;
   PointType upper;
   PointType center;
   work->TransformIndexToPhysicalPoint(work->GetBufferedRegion().GetIndex(),
                                       lower);
   work->TransformIndexToPhysicalPoint(work->GetBufferedRegion().GetIndex() 
                                       + work->GetBufferedRegion().GetSize(), upper);
   for (unsigned int i = 0; i < Dimension; i++)
     {
       center[i] = (lower[i] + upper[i]) / 2.0;
     }

   IndexType idx;
   work->TransformPhysicalPointToIndex(center,idx);

   work->SetPixel(idx,4.0);
  // work->SetOrigin(center);
  
  // Copy the original image and find the center of mass.
  typename ImageType::Pointer simg = ImageType::New();
  simg->CopyInformation(work);
  simg->SetRegions(work->GetBufferedRegion());
  simg->Allocate();
  
  ImageRegionIteratorWithIndex<ImageType> oit(work, work->GetBufferedRegion());
  ImageRegionIteratorWithIndex<ImageType> sit(simg, work->GetBufferedRegion());
  sit.GoToBegin();
  oit.GoToBegin();

  Array<double> params(Dimension);
  params.Fill(0.0);
  double count = 0.0;
  Point<double, Dimension> point;
  for (; ! oit.IsAtEnd(); ++oit, ++sit)
    {
    if (oit.Get() != m_BackgroundValue)
      {
      sit.Set(oit.Get());
      
      // 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;
      }
    else { sit.Set(m_BackgroundValue); }
    }
  
  // Compute center of mass.
  for (unsigned int i = 0; i < Dimension; i++)
    {
    params[i] = params[i] / count;
    // std::cout << "params " << i << " = " << params[i] <<std::endl;
    }

  // PointType pt;
  // for (unsigned i = 0; i < Dimension; i++) { pt[i] = params[i];}
  // work->TransformPhysicalPointToIndex(pt,idx);
  // work->SetPixel(idx,8.0);

  //  std::cout << "Center of mass = " << pt << std::endl;
  // std::cout << "idx = " << idx << std::endl;
  // return;
  // Zero out the original image.
  for (oit.GoToBegin(); ! oit.IsAtEnd(); ++oit)  { oit.Set(m_BackgroundValue); }

  // Translate the segmentation back into the original image.
  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(simg);

  resampler->Update();

  // Copy resampled image back to the original image 
  oit.GoToBegin();
  ImageRegionIterator<ImageType> 
    it(resampler->GetOutput(), work->GetBufferedRegion());
  for ( ; ! it.IsAtEnd(); ++it, ++oit)  
    { 
      oit.Set(it.Get()); 
    }
}

template<class TImage >

void itk::PSMTrimLabelMapImageFilter< TImage >::Crop ( ImageType *  work )

protected

Crops the image to the smallest possible bounding box that contains the image. This method alters the output of the image.

Definition at line 317 of file itkPSMTrimLabelMapImageFilter.hxx.

{
  // Find the bounding box containing the foreground
  ImageRegionIteratorWithIndex<ImageType> 
    it(work, work->GetBufferedRegion());

  SizeType  workSize   = work->GetBufferedRegion().GetSize();
  IndexType workCorner = work->GetBufferedRegion().GetIndex();
  
  // Search for bounding box.
  IndexType idx;
  IndexType lower = workCorner + workSize;
  IndexType upper = workCorner;

  for (it.GoToBegin(); ! it.IsAtEnd(); ++it)
    {
    if (it.Get() != m_BackgroundValue)
      {
      idx = it.GetIndex();
      
      for (unsigned int i = 0; i < Dimension; i++)
        {
        if (lower[i] > idx[i]) lower[i] = idx[i];
        if (upper[i] < idx[i]) upper[i] = idx[i];
        }
      }
    }

  SizeType size;
  for (unsigned int i = 0; i < Dimension; i++) 
    {
      size[i] = upper[i] - lower[i];
    }

  // Create bounding box region
  m_BoundingBox.SetSize(size);
  m_BoundingBox.SetIndex(lower);
  
  // Create cropping filter
  typename itk::ExtractImageFilter<ImageType, ImageType>::Pointer extractor
    = itk::ExtractImageFilter<ImageType, ImageType>::New();
  extractor->SetExtractionRegion(m_BoundingBox);
  extractor->SetInput(work);

  // We are finally able to allocate an output image now that we know
  // the size.
  this->GetOutput()->SetRegions(m_BoundingBox);
  this->GetOutput()->Allocate();

  // pipe to the output image
  extractor->GraftOutput(this->GetOutput());
  extractor->Update();
  // also necessary for pipe to output
  // see itkImageSource for description
  this->GraftOutput(extractor->GetOutput());

  // Make sure the image information is correct.
  // itk::Matrix<double,3,3> I;
  // I.SetIdentity();
  // extractor->GetOutput()->SetDirection(I);
  // double ss[3];
  // ss[0] = ss[1] = ss[2] = 1.0;

  // Origin at the center of the image
  // float o[3];
  // o[0] = - (extractor->GetOutput()->GetBufferedRegion().GetSize()[0] / 2.0);
  // o[1] = - (extractor->GetOutput()->GetBufferedRegion().GetSize()[1] / 2.0);
  // o[2] = - (extractor->GetOutput()->GetBufferedRegion().GetSize()[2] / 2.0);

  // std::cout << "---" << o[0] << " " << o[1] << " " << o[2] << std::endl;
 
  // extractor->GetOutput()->SetOrigin(o);
  // extractor->GetOutput()->SetSpacing(ss);
}

template<class TImage >

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

protected

Fills holes in the foreground segmentation.

Definition at line 186 of file itkPSMTrimLabelMapImageFilter.hxx.

{
  // 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();

  // "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::PSMTrimLabelMapImageFilter< TImage >::GenerateData

(

)

Do the work of batch-processing the input images.

Definition at line 91 of file itkPSMTrimLabelMapImageFilter.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();

  //  std::cout << "A work regions = " << work->GetBufferedRegion() << std::endl;
  //  std::cout << "A input regions = " << this->GetInput()->GetBufferedRegion() << std::endl;

  // 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);

  // Reset the origin to the center of the image and translate the
  // center-of-mass of the segmentation to the origin.
  this->Center(work);

  // typename ImageFileWriter<ImageType>::Pointer writer = ImageFileWriter<ImageType>::New();
  // writer->SetInput(work);
  // writer->SetFileName("tmp.nrrd");
  // writer->Update();

  // Finally, crop the image.  This method allocates the output image
  // and grafts the final result to the output image.
  this->Crop(work);

  //  std::cout << "E work regions = " << work->GetBufferedRegion() << std::endl;

  // Finally, make sure all the image information is correct: origin
  // is in the CENTER of the image and the proper spacing information
  // has been maintained.
  


}

template<class TImage >

void itk::PSMTrimLabelMapImageFilter< 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 itkPSMTrimLabelMapImageFilter.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::PSMTrimLabelMapImageFilter< 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 itkPSMTrimLabelMapImageFilter.hxx.

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

template<class TImage>

const RegionType& itk::PSMTrimLabelMapImageFilter< TImage >::GetBoundingBox ( ) const

inline

Returns the bounding box of the centered and cropped foreground label map. Only valid AFTER the filter has been run.

Definition at line 107 of file itkPSMTrimLabelMapImageFilter.h.

  {
    return m_BoundingBox;
  }

template<class TImage >

void itk::PSMTrimLabelMapImageFilter< 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 137 of file itkPSMTrimLabelMapImageFilter.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::PSMTrimLabelMapImageFilter< TImage >::itkNewMacro

(

Self

)

Method for creation through the object factory.

template<class TImage>

itk::PSMTrimLabelMapImageFilter< 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::PSMTrimLabelMapImageFilter< 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::PSMTrimLabelMapImageFilter< TImage >::itkStaticConstMacro	(	Dimension	,
		unsigned	int,
		TImage::ImageDimension
	)

Dimensionality of the domain of the particle system.

template<class TImage>

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

Run-time type information (and related methods).

---

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

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