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:
  ITK_DISALLOW_COPY_AND_ASSIGN(MorphologicalContourInterpolator);

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

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

  using SliceSetType = std::set< typename TImage::IndexValueType >;

  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 )
  {
    SliceSetType sliceSet;
    sliceSet.insert( indices.begin(), indices.end() );
    m_LabeledSlices[axis][label] = sliceSet;
    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
  using LabeledSlicesType = itksys::hash_map< typename TImage::PixelType, SliceSetType >;
  using SliceIndicesType = std::vector< LabeledSlicesType >;

  SliceIndicesType
  GetLabeledSliceIndices()
  {
    return m_LabeledSlices;
  }

protected:
  MorphologicalContourInterpolator();
  ~MorphologicalContourInterpolator() override = default;
  typename TImage::PixelType m_Label;
  int                        m_Axis{ -1 };
  bool                       m_HeuristicAlignment{ true };
  bool                       m_UseDistanceTransform{ true };
  bool                       m_UseBallStructuringElement{ false };
  bool                       m_UseCustomSlicePositions{ false };
  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

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

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

  void
  GenerateData() 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 );

  void
  InterpolateAlong( int axis, TImage* out, float startProgress, float endProgress);

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

  typename FloatSliceType::Pointer
  MaurerDM( typename BoolSliceType::Pointer& inImage );

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

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

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

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

  using PixelList = std::vector< typename TImage::PixelType >;

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

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

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

  void
  AllocateOutputs() 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 );

  using BoundingBoxesType = itksys::hash_map< typename TImage::PixelType, typename TImage::RegionType >;
  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 );

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

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

  using ConnectedComponentsType = ConnectedComponentImageFilter< BoolSliceType, SliceType >;
  typename ConnectedComponentsType::Pointer m_ConnectedComponents;
};
} // namespace itk

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

#endif // itkMorphologicalContourInterpolator_h