itkBinaryThinningImageFilter3D.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#ifndef __itkBinaryThinningImageFilter3D_h
#define __itkBinaryThinningImageFilter3D_h
 
#include <itkNeighborhoodIterator.h>
#include <itkImageToImageFilter.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkConstantBoundaryCondition.h>
 
namespace itk
{
template <class TInputImage,class TOutputImage>
class BinaryThinningImageFilter3D :
    public ImageToImageFilter<TInputImage,TOutputImage>
{
public:
  typedef BinaryThinningImageFilter3D    Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro( BinaryThinningImageFilter3D, ImageToImageFilter );
 
  typedef   TInputImage       InputImageType;
 
  typedef   TOutputImage      OutputImageType;
 
  typedef typename InputImageType::RegionType RegionType;
 
  typedef typename RegionType::IndexType  IndexType;
 
  typedef typename InputImageType::PixelType InputImagePixelType ;
 
  typedef typename OutputImageType::PixelType OutputImagePixelType ;
 
  typedef typename RegionType::SizeType SizeType;
 
  typedef typename InputImageType::ConstPointer InputImagePointer;
 
  typedef typename OutputImageType::Pointer OutputImagePointer;
  
  typedef ConstantBoundaryCondition< TInputImage > ConstBoundaryConditionType;
  
  typedef NeighborhoodIterator<TInputImage, ConstBoundaryConditionType> NeighborhoodIteratorType;
  
  typedef typename NeighborhoodIteratorType::NeighborhoodType NeighborhoodType;
 
  OutputImageType * GetThinning(void);
 
  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension );
  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TOutputImage::ImageDimension );
 
#ifdef ITK_USE_CONCEPT_CHECKING
 
  itkConceptMacro(SameDimensionCheck,
    (Concept::SameDimension<InputImageDimension, 3>));
  itkConceptMacro(SameTypeCheck,
    (Concept::SameType<InputImagePixelType, OutputImagePixelType>));
  itkConceptMacro(InputAdditiveOperatorsCheck,
    (Concept::AdditiveOperators<InputImagePixelType>));
  itkConceptMacro(InputConvertibleToIntCheck,
    (Concept::Convertible<InputImagePixelType, int>));
  itkConceptMacro(IntConvertibleToInputCheck,
    (Concept::Convertible<int, InputImagePixelType>));
  itkConceptMacro(InputIntComparableCheck,
    (Concept::Comparable<InputImagePixelType, int>));
#endif
 
protected:
  BinaryThinningImageFilter3D();
  virtual ~BinaryThinningImageFilter3D() {};
  void PrintSelf(std::ostream& os, Indent indent) const;
 
  void GenerateData();
 
  void PrepareData();
 
  void ComputeThinImage();
  
  bool isEulerInvariant(NeighborhoodType neighbors, int *LUT);
  void fillEulerLUT(int *LUT);  
  bool isSimplePoint(NeighborhoodType neighbors);
  void Octree_labeling(int octant, int label, int *cube);
 
 
private:   
  BinaryThinningImageFilter3D(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
 
}; // end of BinaryThinningImageFilter3D class
 
} //end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBinaryThinningImageFilter3D.txx"
#endif
 
#endif