itkMorphologicalContourInterpolator.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 itkMorphologicalContourInterpolator_h
#define itkMorphologicalContourInterpolator_h

#include "itkBinaryThresholdImageFilter.h"
#include "itkConnectedComponentImageFilter.h"
#include "itkExtractImageFilter.h"
#include "itkImageToImageFilter.h"
#include "itksys/hash_map.hxx"

namespace itk
{
template< typename TImage >
class MorphologicalContourInterpolator:
  public ImageToImageFilter< TImage, TImage >
{
  template< typename T >
  friend class MorphologicalContourInterpolatorParallelInvoker;

public:
  typedef MorphologicalContourInterpolator                                Self;
  typedef ImageToImageFilter< TImage, TImage >                            Superclass;
  typedef SmartPointer< Self >                                            Pointer;
  typedef Image< typename TImage::PixelType, TImage::ImageDimension - 1 > SliceType;

  itkNewMacro( Self );

  itkTypeMacro( MorphologicalContourInterpolator, ImageToImageFilter );

  itkSetMacro( Label, typename TImage::PixelType );

  itkGetMacro( Label, typename TImage::PixelType );

  itkGetConstMacro( Label, typename TImage::PixelType );

  itkSetMacro( Axis, int );

  itkGetMacro( Axis, int );

  itkGetConstMacro( Axis, int );

  itkSetMacro( HeuristicAlignment, bool );

  itkGetMacro( HeuristicAlignment, bool );

  itkGetConstMacro( HeuristicAlignment, bool );

  itkSetMacro( UseDistanceTransform, bool );

  itkGetMacro( UseDistanceTransform, bool );

  itkGetConstMacro( UseDistanceTransform, bool );

  itkSetMacro( UseCustomSlicePositions, bool );

  itkGetMacro( UseCustomSlicePositions, bool );

  itkGetConstMacro( UseCustomSlicePositions, bool );

  void
  SetUseBallStructuringElement( bool useBall )
  {
    if ( useBall != m_UseBallStructuringElement )
      {
      m_UseBallStructuringElement = useBall;
      m_ConnectedComponents->SetFullyConnected( useBall );
      this->Modified();
      }
  }

  itkGetMacro( UseBallStructuringElement, bool );

  itkGetConstMacro( UseBallStructuringElement, bool );

  void
  DetermineSliceOrientations();

  typedef std::set< typename TImage::IndexValueType > SliceSetType;

  void
  ClearLabeledSliceIndices()
  {
    m_LabeledSlices.clear();
    m_LabeledSlices.resize( TImage::ImageDimension );
    this->Modified();
  }

  void
  SetLabeledSliceIndices( unsigned int axis,
    typename TImage::PixelType label,
    const std::vector< typename TImage::IndexValueType >& indices )
  {
    m_LabeledSlices[axis][label] = SliceSetType().insert( indices.begin(), indices.end() );
    this->Modified();
  }

  void
  SetLabeledSliceIndices( unsigned int axis, typename TImage::PixelType label, const SliceSetType& indices )
  {
    m_LabeledSlices[axis][label] = indices;
    this->Modified();
  }

  SliceSetType
  GetLabeledSliceIndices( unsigned int axis, typename TImage::PixelType label )
  {
    return m_LabeledSlices[axis][label];
  }

  // each label gets a set of slices in which it is present
  typedef itksys::hash_map< typename TImage::PixelType, SliceSetType > LabeledSlicesType;
  typedef std::vector< LabeledSlicesType >                             SliceIndicesType;

  SliceIndicesType
  GetLabeledSliceIndices()
  {
    return m_LabeledSlices;
  }

protected:
  MorphologicalContourInterpolator();
  ~MorphologicalContourInterpolator() {}
  typename TImage::PixelType m_Label;
  int                        m_Axis;
  bool                       m_HeuristicAlignment;
  bool                       m_UseDistanceTransform;
  bool                       m_UseBallStructuringElement;
  bool                       m_UseCustomSlicePositions;
  IdentifierType             m_MinAlignIters; // minimum number of iterations in align method
  IdentifierType             m_MaxAlignIters; // maximum number of iterations in align method
  IdentifierType             m_ThreadCount;   // for thread local instances
  SliceIndicesType           m_LabeledSlices; // one for each axis

  typedef Image< bool, TImage::ImageDimension >      BoolImageType;
  typedef Image< float, TImage::ImageDimension - 1 > FloatSliceType;
  typedef Image< bool, TImage::ImageDimension - 1 >  BoolSliceType;

  bool
  ImagesEqual( typename BoolSliceType::Pointer& a, typename BoolSliceType::Pointer& b );

  virtual void
  GenerateData() ITK_OVERRIDE;

  void
  InterpolateBetweenTwo( int axis,
    TImage* out,
    typename TImage::PixelType label,
    typename TImage::IndexValueType i,
    typename TImage::IndexValueType j,
    typename SliceType::Pointer& iconn,
    typename SliceType::Pointer& jconn,
    ThreadIdType threadId );

  void
  InterpolateAlong( int axis, TImage* out );

  void
  Extrapolate( int axis,
    TImage* out,
    typename TImage::PixelType label,
    typename TImage::IndexValueType i,
    typename TImage::IndexValueType j,
    typename SliceType::Pointer& iConn,
    typename TImage::PixelType iRegionId,
    ThreadIdType threadId );

  typename FloatSliceType::Pointer
  MaurerDM( typename BoolSliceType::Pointer& inImage, ThreadIdType threadId );

  std::vector< typename BoolSliceType::Pointer >
  GenerateDilationSequence( typename BoolSliceType::Pointer& begin,
    typename BoolSliceType::Pointer& end,
    ThreadIdType threadId );

  typename BoolSliceType::Pointer
  FindMedianImageDilations( typename BoolSliceType::Pointer& intersection,
    typename BoolSliceType::Pointer& iMask,
    typename BoolSliceType::Pointer& jMask,
    ThreadIdType threadId );

  typename BoolSliceType::Pointer
  FindMedianImageDistances( typename BoolSliceType::Pointer& intersection,
    typename BoolSliceType::Pointer& iMask,
    typename BoolSliceType::Pointer& jMask,
    ThreadIdType threadId );

  void
  Interpolate1to1( int axis,
    TImage* out,
    typename TImage::PixelType label,
    typename TImage::IndexValueType i,
    typename TImage::IndexValueType j,
    typename SliceType::Pointer& iConn,
    typename TImage::PixelType iRegionId,
    typename SliceType::Pointer& jConn,
    typename TImage::PixelType jRegionId,
    const typename SliceType::IndexType& translation,
    bool recursive,
    ThreadIdType threadId );

  typedef std::vector< typename TImage::PixelType > PixelList;

  void
  Interpolate1toN( int axis,
    TImage* out,
    typename TImage::PixelType label,
    typename TImage::IndexValueType i,
    typename TImage::IndexValueType j,
    typename SliceType::Pointer& iConn,
    typename TImage::PixelType iRegionId,
    typename SliceType::Pointer& jConn,
    const PixelList& jRegionIds,
    const typename SliceType::IndexType& translation,
    ThreadIdType threadId );

  typename SliceType::Pointer
  TranslateImage( typename SliceType::Pointer& image,
    const typename SliceType::IndexType& translation,
    typename SliceType::RegionType newRegion );

  IdentifierType
  CardSymDifference( typename BoolSliceType::Pointer& shape1, typename BoolSliceType::Pointer& shape2 );

  virtual void
  AllocateOutputs() ITK_OVERRIDE;

  typename SliceType::IndexType
  Centroid( typename SliceType::Pointer& conn, const PixelList& regionIds );

  void
  IntersectionRegions( const typename SliceType::IndexType& translation,
    typename SliceType::RegionType& iRegion,
    typename SliceType::RegionType& jRegion );

  IdentifierType
  Intersection( typename SliceType::Pointer& iConn,
    typename TImage::PixelType iRegionId,
    typename SliceType::Pointer& jConn,
    const PixelList& jRegionIds,
    const typename SliceType::IndexType& translation );

  typename SliceType::IndexType
  Align( typename SliceType::Pointer& iConn,
    typename TImage::PixelType iRegionId,
    typename SliceType::Pointer& jConn,
    const PixelList& jRegionIds );

  typedef itksys::hash_map< typename TImage::PixelType, typename TImage::RegionType > BoundingBoxesType;
  BoundingBoxesType m_BoundingBoxes; // bounding box for each label

  typename SliceType::RegionType
  BoundingBox( itk::SmartPointer< SliceType > image );

  template< typename T2 >
  void
  ExpandRegion( typename T2::RegionType& region, const typename T2::IndexType& index );

  typename SliceType::Pointer
  RegionedConnectedComponents( const typename TImage::RegionType& region,
    typename TImage::PixelType label,
    IdentifierType& objectCount );

  typename BoolSliceType::Pointer
  Dilate1( typename BoolSliceType::Pointer& seed, typename BoolSliceType::Pointer& mask, ThreadIdType threadId );

  typedef ExtractImageFilter< TImage, SliceType > RoiType;
  typename RoiType::Pointer m_RoI;

  typedef BinaryThresholdImageFilter< SliceType, BoolSliceType > BinarizerType;
  typename BinarizerType::Pointer m_Binarizer;

  typedef ConnectedComponentImageFilter< BoolSliceType, SliceType > ConnectedComponentsType;
  typename ConnectedComponentsType::Pointer m_ConnectedComponents;

private:
  MorphologicalContourInterpolator( const Self & ) ITK_DELETE_FUNCTION;
  void
  operator=( const Self & ) ITK_DELETE_FUNCTION;
};
} // namespace itk

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

#endif // itkMorphologicalContourInterpolator_h