AlphaThickSegmentComputer.h

#pragma once

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

#define AlphaThickSegmentComputer_RECURSES

#if !defined AlphaThickSegmentComputer_h

#define AlphaThickSegmentComputer_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ReverseIterator.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/geometry/surfaces/ParallelStrip.h"
#include "DGtal/geometry/tools/MelkmanConvexHull.h"
#include "DGtal/geometry/tools/determinant/InHalfPlaneBySimple3x3Matrix.h"

namespace DGtal
{

// class AlphaThickSegmentComputer
template <typename TInputPoint,
          typename TConstIterator = typename std::vector< TInputPoint >::const_iterator >

class AlphaThickSegmentComputer
{

  // ----------------------- public types --------------------------------------
  BOOST_STATIC_ASSERT(( TInputPoint::dimension == 2 ));
  BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<TConstIterator>));

public:
  typedef TInputPoint InputPoint;

  typedef std::vector< InputPoint > InputPointContainer;
  typedef typename InputPointContainer::size_type Size;
  typedef typename InputPointContainer::const_iterator ContainerConstIterator;
  typedef typename DGtal::functions::Hull2D::ThicknessDefinition ThicknessDef;

  typedef typename InputPointContainer::iterator Iterator;
  typedef TConstIterator ConstIterator;
  typedef ParallelStrip< SpaceND< 2, DGtal::int32_t > ,true,true> Primitive;  

  typedef DGtal::PointVector<2, double> PointD;

  typedef AlphaThickSegmentComputer<InputPoint, ConstIterator> Self;
  typedef AlphaThickSegmentComputer<InputPoint, ReverseIterator<ConstIterator> > Reverse;
  typedef DGtal::InHalfPlaneBySimple3x3Matrix<InputPoint, typename InputPoint::Component> Functor;
  typedef typename  DGtal::MelkmanConvexHull<InputPoint, Functor>::ConstIterator ConvexhullConstIterator;

  // ----------------------- internal types --------------------------------------

private:
  struct State{
    DGtal::MelkmanConvexHull<InputPoint, Functor> melkmanCH;
    InputPoint lastFront;
    InputPoint lastBack;
    InputPoint edgePh;
    InputPoint edgeQh;
    InputPoint vertexSh;
    double actualThickness;
  };


  // ----------------------- Standard services ------------------------------
public:



  AlphaThickSegmentComputer(const double maximalThickness = 1.0,
                            const ThicknessDef &thicknessDefinition = functions::Hull2D::HorizontalVerticalThickness,
                            const double thickCompPrecision=1e-6);



  ~AlphaThickSegmentComputer();


  AlphaThickSegmentComputer ( const AlphaThickSegmentComputer & other );


  AlphaThickSegmentComputer & operator= ( const AlphaThickSegmentComputer & other );


  Self getSelf() const;


  Reverse getReverse() const;

  bool operator==( const AlphaThickSegmentComputer & other ) const;

  bool operator!=( const AlphaThickSegmentComputer & other ) const;



  //-------------------- model of ForwardContainer -----------------------------
public:

  Size size() const;


  bool empty() const;


  ContainerConstIterator containerBegin() const;


  ContainerConstIterator containerEnd() const;

  ConvexhullConstIterator convexhullBegin() const;


  ConvexhullConstIterator convexhullEnd() const;

  ConstIterator begin() const;


  ConstIterator end() const;


  Size max_size() const;




  //-------------------- model of CForwardSegmentComputer ----------------

public:

  void init(const ConstIterator &it);


  bool extendFront();


  bool isExtendableFront();


  bool isExtendableFront(const InputPoint &aPoint);


  bool extendFront(const InputPoint &aPoint);



  //-------------------- Primitive services -----------------------------


  Primitive primitive() const;




    // ----------------------- Interface --------------------------------------
public:


  bool isValid() const;


  std::pair<InputPoint, InputPoint>  getExtremityPoints() const;


  std::pair<std::pair<InputPoint, InputPoint>, InputPoint>
  getAntipodalLeaningPoints() const;


  void computeParallelStripParams(double &mu, PointD &N, double &nu) const;


  PointD getNormal() const;


  double getThickness() const;


  double getMu() const;


  double getNu() const;


  double getSegmentLength() const;


  bool isStoringSegmentPoints() const;


  unsigned int getNumberSegmentPoints() const;



  // ------------------------- Display services ------------------------------


  std::vector<InputPoint> getConvexHull() const;



  void getBoundingBoxFromExtremPoints(const InputPoint &aFirstPt,
                                      const InputPoint &aLastPt,
                                      PointD &pt1LongestSegment1,
                                      PointD &pt2LongestSegment1,
                                      PointD &pt3LongestSegment2,
                                      PointD &pt4LongestSegment2,
                                      double minVisibleWidthBounds = 0.2) const;


  void getBoundingBox(PointD &pt1LongestSegment1,
                      PointD &pt2LongestSegment1,
                      PointD &pt3LongestSegment2,
                      PointD &pt4LongestSegment2) const;





  std::string className() const;


  void selfDisplay ( std::ostream & out ) const;

    // ------------------------- Protected Datas ------------------------------
protected:


  ConstIterator myBegin;

  ConstIterator myEnd;




    // ------------------------- Private Datas --------------------------------
private:

  mutable InputPointContainer myPointContainer;

  double myMaximalThickness;

  double myThicknessCompPrecision;


  ThicknessDef myThicknessDefinition;


  State myState;

  mutable State myPreviousState;

  bool myIsStoringPoints;

  unsigned int myNbPointsAddedFromIterators;




    // ------------------------- Hidden services ------------------------------
protected:



  bool melkmanIsConvexValid() ;


  double updateMainHeightAndAntiPodal();



  template<typename TPointD>
  bool projectOnStraightLine(const TPointD & ptA, const TPointD & ptB,
                             const TPointD & ptC, PointD & ptProjected) const;


  template<typename TConstIteratorG>
  void computeExtremaPoints(const TConstIteratorG & itBegin, const TConstIteratorG & itEnd,
                            InputPoint & aFirstExtrPt, InputPoint & aLastExtrPt) const;


    // ------------------------- Internals ------------------------------------
private:

}; // end of class AlphaThickSegmentComputer


template <typename TInputPoint, typename TConstIterator>
std::ostream&
operator<< ( std::ostream & out, const AlphaThickSegmentComputer<TInputPoint, TConstIterator> & object );


} // namespace DGtal


// Includes inline functions.
#if !defined(BUILD_INLINE)
#include "DGtal/geometry/curves/AlphaThickSegmentComputer.ih"
#endif


//                                                                           //

#endif // !defined AlphaThickSegmentComputer_h

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