DistanceTransformation.h

#pragma once

#if defined(DistanceTransformation_RECURSES)
#error Recursive header files inclusion detected in DistanceTransformation.h
#else // defined(DistanceTransformation_RECURSES)

#define DistanceTransformation_RECURSES

#if !defined DistanceTransformation_h

#define DistanceTransformation_h

// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/CSignedInteger.h"
#include "DGtal/images/CImage.h"
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/images/imagesSetsUtils/ImageFromSet.h"

#include "DGtal/geometry/volumes/distance/SeparableMetricHelper.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"

namespace DGtal
{

  // template class DistanceTransformation
  template < typename TSpace,
             typename TPointPredicate,
             DGtal::uint32_t p, 
             typename IntegerLong = DGtal::int64_t>
  class DistanceTransformation
  {

  public:
    
    BOOST_CONCEPT_ASSERT(( CSignedInteger<IntegerLong> ));
    BOOST_CONCEPT_ASSERT(( CSpace< TSpace > ));
    BOOST_CONCEPT_ASSERT(( CPointPredicate<TPointPredicate> ));
  
    
    typedef TSpace Space;

    typedef TPointPredicate PointPredicate;

    typedef HyperRectDomain<Space> Domain;

    typedef ImageContainerBySTLVector<  Domain,
                                        IntegerLong > OutputImage;

    typedef typename Space::Vector Vector;
    typedef typename Space::Point Point;
    typedef typename Space::Dimension Dimension;
    typedef typename Space::Size Size;
    typedef typename Space::Point::Coordinate Abscissa;
 
    typedef SeparableMetricHelper<  Point ,  IntegerLong , p > SeparableMetric;
  

    DistanceTransformation(const Domain & aDomain,
                           const PointPredicate & predicate);

    ~DistanceTransformation();

  public:

    OutputImage compute( ) ;


    bool checkTypesValidity () const;
    
    
    // ------------------- Private functions ------------------------
  private:
    
    
    void computeFirstStep(OutputImage & output) const;

    void computeFirstStep1D (OutputImage & output, 
                             const Point &startingPoint) const;
    
    void computeOtherSteps(const OutputImage & inputImage,
                           OutputImage & output,
                           const Dimension dim) const;

    void computeOtherStep1D (const OutputImage & input, 
                             OutputImage & output, 
                             const Point &row, 
                             const Size dim, 
                             Abscissa s[], Abscissa t[]) const;
    

    // ------------------- protected methods ------------------------
  protected:

    DistanceTransformation();
   
    
    // ------------------- Private members ------------------------
  private:

    SeparableMetric myMetric;

    const Domain & myDomain;
    
    const PointPredicate  & myPointPredicate;
    
    Point myLowerBoundCopy;
    
    Point myUpperBoundCopy;
    
    Vector myDisplacementVector;

    Point myExtent;

    IntegerLong myInfinity;


  }; // end of class DistanceTransformation

} // namespace DGtal


// Includes inline functions.
#include "DGtal/geometry/volumes/distance/DistanceTransformation.ih"

//                                                                           //

#endif // !defined DistanceTransformation_h

#undef DistanceTransformation_RECURSES
#endif // else defined(DistanceTransformation_RECURSES)