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 TPoint, typename TPointD>
  bool projectOnStraightLine(const TPoint & ptA, const TPoint & ptB,
                             const TPoint & ptC, TPointD & 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)