itkRelabelComponentImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkRelabelComponentImageFilter_h
#define itkRelabelComponentImageFilter_h

#include "itkInPlaceImageFilter.h"
#include "itkImage.h"
#include <vector>

namespace itk
{
template< typename TInputImage, typename TOutputImage >
class ITK_TEMPLATE_EXPORT RelabelComponentImageFilter:
  public InPlaceImageFilter< TInputImage, TOutputImage >
{
public:
  typedef RelabelComponentImageFilter                     Self;
  typedef InPlaceImageFilter< TInputImage, TOutputImage > Superclass;

  typedef typename Superclass::InputImagePointer InputImagePointer;

  typedef typename TOutputImage::PixelType         OutputPixelType;
  typedef typename TOutputImage::InternalPixelType OutputInternalPixelType;
  typedef typename TInputImage::PixelType          InputPixelType;
  typedef typename TInputImage::InternalPixelType  InputInternalPixelType;
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TOutputImage::ImageDimension);
  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef TInputImage                         InputImageType;
  typedef TOutputImage                        OutputImageType;
  typedef   typename TInputImage::IndexType   IndexType;
  typedef   typename TInputImage::SizeType    SizeType;
  typedef   typename TOutputImage::RegionType RegionType;

  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro(RelabelComponentImageFilter, ImageToImageFilter);

  itkNewMacro(Self);

  typedef IdentifierType LabelType;

  typedef SizeValueType ObjectSizeType;

  itkGetConstMacro(NumberOfObjects, LabelType);

  typedef std::vector< ObjectSizeType >   ObjectSizeInPixelsContainerType;
  typedef std::vector< float >            ObjectSizeInPhysicalUnitsContainerType;

  itkGetConstMacro(OriginalNumberOfObjects, LabelType);

  itkSetMacro(NumberOfObjectsToPrint, LabelType);
  itkGetConstReferenceMacro(NumberOfObjectsToPrint, LabelType);

  itkSetMacro(MinimumObjectSize, ObjectSizeType);

  itkGetConstMacro(MinimumObjectSize, ObjectSizeType);

  itkSetMacro(SortByObjectSize, bool);
  itkGetConstMacro(SortByObjectSize, bool);
  itkBooleanMacro(SortByObjectSize);

  const ObjectSizeInPixelsContainerType & GetSizeOfObjectsInPixels() const
    {
    // The GetConstReferenceMacro can't be used here becase this container
    // doesn't have an ostream<< operator overloaded.
    return this->m_SizeOfObjectsInPixels;
    }

  const ObjectSizeInPhysicalUnitsContainerType & GetSizeOfObjectsInPhysicalUnits() const
    {
    // The GetConstReferenceMacro can't be used here becase this container
    // doesn't have an ostream<< operator overloaded.
    return this->m_SizeOfObjectsInPhysicalUnits;
    }

  ObjectSizeType GetSizeOfObjectInPixels(LabelType obj) const
  {
    if ( obj > 0 && obj <= m_NumberOfObjects )
      {
      return m_SizeOfObjectsInPixels[obj - 1];
      }
    else
      {
      return 0;
      }
  }

  float GetSizeOfObjectInPhysicalUnits(LabelType obj) const
  {
    if ( obj > 0 && obj <= m_NumberOfObjects )
      {
      return m_SizeOfObjectsInPhysicalUnits[obj - 1];
      }
    else
      {
      return 0;
      }
  }

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( InputEqualityComparableCheck,
                   ( Concept::EqualityComparable< InputPixelType > ) );
  itkConceptMacro( UnsignedLongConvertibleToInputCheck,
                   ( Concept::Convertible< LabelType, InputPixelType > ) );
  itkConceptMacro( OutputLongConvertibleToUnsignedLongCheck,
                   ( Concept::Convertible< OutputPixelType, LabelType > ) );
  itkConceptMacro( InputConvertibleToOutputCheck,
                   ( Concept::Convertible< InputPixelType, OutputPixelType > ) );
  itkConceptMacro( SameDimensionCheck,
                   ( Concept::SameDimension< InputImageDimension, ImageDimension > ) );
  // End concept checking
#endif

protected:

  RelabelComponentImageFilter():
    m_NumberOfObjects(0), m_NumberOfObjectsToPrint(10),
    m_OriginalNumberOfObjects(0), m_MinimumObjectSize(0),
    m_SortByObjectSize(true)
  { this->InPlaceOff(); }
  virtual ~RelabelComponentImageFilter() ITK_OVERRIDE {}

  void GenerateData() ITK_OVERRIDE;

  void GenerateInputRequestedRegion() ITK_OVERRIDE;

  void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;

  struct RelabelComponentObjectType {
    LabelType m_ObjectNumber;
    ObjectSizeType m_SizeInPixels;
    float m_SizeInPhysicalUnits;
  };

  // put the function objects here for sorting in descending order
  class RelabelComponentSizeInPixelsComparator
  {
  public:
    bool operator()(const RelabelComponentObjectType & a,
                    const RelabelComponentObjectType & b)
    {
      if ( a.m_SizeInPixels > b.m_SizeInPixels )
        {
        return true;
        }
      else if ( a.m_SizeInPixels < b.m_SizeInPixels )
        {
        return false;
        }
      // size in pixels and physical units are the same, sort based on
      // original object number
      else if ( a.m_ObjectNumber < b.m_ObjectNumber )
        {
        return true;
        }
      else
        {
        return false;
        }
    }
  };

private:
  ITK_DISALLOW_COPY_AND_ASSIGN(RelabelComponentImageFilter);

  LabelType      m_NumberOfObjects;
  LabelType      m_NumberOfObjectsToPrint;
  LabelType      m_OriginalNumberOfObjects;
  ObjectSizeType m_MinimumObjectSize;
  bool           m_SortByObjectSize;

  ObjectSizeInPixelsContainerType         m_SizeOfObjectsInPixels;
  ObjectSizeInPhysicalUnitsContainerType  m_SizeOfObjectsInPhysicalUnits;
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRelabelComponentImageFilter.hxx"
#endif

#endif