#pragma once

#ifndef TELLIPTIC_BRUSH_P_H

#define TELLIPTIC_BRUSH_P_H

#include "tcurves.h"

#include "tstroke.h"

#include "tgl.h"  //tglPixelSize

#include "tstrokeoutline.h"

namespace tellipticbrush {

//! Tolerance parameter used somewhere throughout this code.

const double tolPar = 1e-6;

//********************************************************************************

//    Geometric Helper Functions

//********************************************************************************

double dist(const TPointD &P1, const TPointD &P2);

double dist(const TThickPoint &P1, const TThickPoint &P2);

double angle(const TPointD &v1, const TPointD &v2);

TPointD intersectionCoords(const TPointD &P0, const TPointD &d0,

                           const TPointD &P1, const TPointD &d1,

                           double detTol = 1e-2);

void buildEnvelopeDirection(const TThickPoint &p, const TThickPoint &d,

                            bool left, TPointD &res);

void buildEnvelopeDirections(const TThickPoint &p, const TThickPoint &d,

                             TPointD &resL, TPointD &resR);

void buildEnvelopeVector(const TThickPoint &p, const TThickPoint &d, bool left,

                         TPointD &res);

void buildEnvelopeVectors(const TThickPoint &p, const TThickPoint &d,

                          TPointD &resL, TPointD &resR);

void buildAngularSubdivision(double radius, double angle, double err,

                             int &nAngles);

TRectD computeBBox(const TStroke &stroke);

//********************************************************************************

//    Options structure

//********************************************************************************

/*

  Structure needed to hold both external and internal outlinization parameters.

*/

struct OutlinizationData {

  TOutlineUtil::OutlineParameter m_options;

  double m_pixSize;

  OutlinizationData() : m_options(), m_pixSize(0.0) {}

  OutlinizationData(const TOutlineUtil::OutlineParameter &options)

      : m_options(options), m_pixSize(sqrt(tglGetPixelSize2())) {}

};

//********************************************************************************

//    Centerline Point struct

//********************************************************************************

/*!

  CenterlinePoint contains the data a about a discretized centerline stroke

  point -

  which includes its position, and eventual forward and backward derivative-like

  directions. Thickness data is included in the structure.

  These informations are necessary and sufficient to build associated outline

  points,

  and eventual additional points related to caps.

*/

struct CenterlinePoint {

  int m_chunkIdx;  //!< The quadratic chunk index containing this point

  double m_t;      //!< The quadratic parameter where this point can be found

  TThickPoint m_p;  //!< The point's thick coordinates

  bool m_posBuilt;  //!< Wheteher m_p has been calculated

  TThickPoint m_prevD;  //!< The backward direction

  bool m_hasPrevD;      //!< If the point has (envelopable) backward direction

  TThickPoint m_nextD;  //!< The forward direction

  bool m_hasNextD;      //!< If the point has (envelopable) forward direction

  bool m_dirsBuilt;  //!< Whether directions have been calculated

  bool m_covered;  //!< Whether this point's outline can't be seen

  int m_countIdx;  //!< Additional index needed by some procedural style...

  CenterlinePoint() : m_chunkIdx(-1), m_posBuilt(false), m_dirsBuilt(false) {}

  CenterlinePoint(int chunk, double t)

      : m_chunkIdx(chunk)

      , m_t(t)

      , m_posBuilt(false)

      , m_dirsBuilt(false)

      , m_countIdx(0) {}

  ~CenterlinePoint() {}

  void buildPos(const TStroke &stroke);

  void buildDirs(const TStroke &stroke);

  bool operator<(const CenterlinePoint &cp) const {

    return m_chunkIdx < cp.m_chunkIdx

               ? true

               : m_chunkIdx > cp.m_chunkIdx ? false : m_t < cp.m_t;

  }

};

//********************************************************************************

//    Linearizator Classes

//********************************************************************************

/*!

  The StrokeLinearizator class models a stroke linearization interface that

  extracts points of interest from a succession of stroke quadratics.

*/

class StrokeLinearizator {

protected:

  const TStroke *m_stroke;

public:

  StrokeLinearizator(const TStroke *stroke) : m_stroke(stroke) {}

  virtual ~StrokeLinearizator() {}

  /*!

Adds interesting stroke points to be discretized in the

chunk-th TThickQuadratic stroke.

\note The initial point (P0) of the quadratic is always added by the

outlinization algorithm before these linearization functions are invoked

(whereas P2 belongs to the next quadratic).

*/

  virtual void linearize(std::vector<centerlinepoint> &cPoints, int chunk) = 0;</centerlinepoint>

};

//********************************************************************************

//    Outline Builder classes

//********************************************************************************

/*!

  The OutlineBuilder class is the object used to translate centerline points

  into outline points. The purpose of this class is to take a CenterlinePoint

  instance and build a couple of outline points - at either side of the

  centerline - eventually adding (cap) points to form a smooth outline.

*/

class OutlineBuilder {

  double m_pixSize;

  TStroke::OutlineOptions m_oOptions;

  int m_lastChunk;

private:

  typedef void (OutlineBuilder::*OutlineBuilderFunc)(

      std::vector<toutlinepoint> &outPoints, const CenterlinePoint &cPoint);</toutlinepoint>

  OutlineBuilderFunc m_addBeginCap;

  OutlineBuilderFunc m_addEndCap;

  OutlineBuilderFunc m_addSideCaps;

  typedef void (OutlineBuilder::*BBoxBuilderFunc)(

      TRectD &bbox, const CenterlinePoint &cPoint);

  BBoxBuilderFunc m_addBeginCap_ext;

  BBoxBuilderFunc m_addEndCap_ext;

  BBoxBuilderFunc m_addSideCaps_ext;

private:

  /*

Type-specific outline container functions.

Used with outline building sub-routines that may be used to supply

different outline container types.

For example, a TRectD may be considered a container class to be used

when building the outline bbox.

*/

  template <typename t=""></typename>

  void addEnvelopePoint(T &container, const TPointD &oPoint, int countIdx = 0);

  template <typename t=""></typename>

  void addExtensionPoint(T &container, const TPointD &oPoint, int countIdx = 0);

  template <typename t=""></typename>

  void addOutlineBuilderFunc(OutlineBuilder::OutlineBuilderFunc func,

                             T &container, const CenterlinePoint &cPoint);

public:

  OutlineBuilder(const OutlinizationData &data, const TStroke &stroke);

  ~OutlineBuilder() {}

  /*!

Transforms the specified centerline point into outline points, and adds them to

the supplied outline points vector.

*/

  void buildOutlinePoints(std::vector<toutlinepoint> &outPoints,</toutlinepoint>

                          const CenterlinePoint &cPoint);

  void buildOutlineExtensions(TRectD &bbox, const CenterlinePoint &cPoint);

private:

  void addCircle(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                 const CenterlinePoint &cPoint);

  void addCircularArcPoints(int idx, std::vector<toutlinepoint> &outPoints,</toutlinepoint>

                            const TPointD ¢er, const TPointD &ray,

                            double angle, int nAngles, int countIdx);

  void addRoundBeginCap(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                        const CenterlinePoint &cPoint);

  void addRoundEndCap(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                      const CenterlinePoint &cPoint);

  void addButtBeginCap(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                       const CenterlinePoint &cPoint);

  void addButtEndCap(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                     const CenterlinePoint &cPoint);

  template <typename t=""></typename>

  void addProjectingBeginCap(T &oPoints, const CenterlinePoint &cPoint);

  template <typename t=""></typename>

  void addProjectingEndCap(T &oPoints, const CenterlinePoint &cPoint);

  void addRoundSideCaps(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                        const CenterlinePoint &cPoint);

  void addBevelSideCaps(std::vector<toutlinepoint> &oPoints,</toutlinepoint>

                        const CenterlinePoint &cPoint);

  template <typename t=""></typename>

  void addMiterSideCaps(T &oPoints, const CenterlinePoint &cPoint);

};

//********************************************************************************

//    Explicit specializations of OutlineBuilder's methods

//********************************************************************************

// Container of Outline Points (for common outline extraction)

template <>

inline void OutlineBuilder::addEnvelopePoint(

    std::vector<toutlinepoint> &oPoints, const TPointD &oPoint, int countIdx) {</toutlinepoint>

  oPoints.push_back(TOutlinePoint(oPoint, countIdx));

}

template <>

inline void OutlineBuilder::addExtensionPoint(

    std::vector<toutlinepoint> &oPoints, const TPointD &oPoint, int countIdx) {</toutlinepoint>

  oPoints.push_back(TOutlinePoint(oPoint, countIdx));

}

template <>

inline void OutlineBuilder::addOutlineBuilderFunc(

    OutlineBuilder::OutlineBuilderFunc func,

    std::vector<toutlinepoint> &oPoints, const CenterlinePoint &cPoint) {</toutlinepoint>

  (this->*func)(oPoints, cPoint);

}

//============================================================================================

// Rect (for bounding box extraction)

template <>

inline void OutlineBuilder::addEnvelopePoint(TRectD &bbox,

                                             const TPointD &oPoint,

                                             int countIdx) {}

template <>

inline void OutlineBuilder::addExtensionPoint(TRectD &bbox,

                                              const TPointD &oPoint,

                                              int countIdx) {

  bbox.x0 = std::min(bbox.x0, oPoint.x);

  bbox.y0 = std::min(bbox.y0, oPoint.y);

  bbox.x1 = std::max(bbox.x1, oPoint.x);

  bbox.y1 = std::max(bbox.y1, oPoint.y);

}

template <>

inline void OutlineBuilder::addOutlineBuilderFunc(

    OutlineBuilder::OutlineBuilderFunc func, TRectD &container,

    const CenterlinePoint &cPoint) {}

//********************************************************************************

//    Standard Outline Builder (from Centerline Points)

//********************************************************************************

void buildOutline(const TStroke &stroke, std::vector<centerlinepoint> &cPoints,</centerlinepoint>

                  TStrokeOutline &outline, const OutlinizationData &data);

}  // namespace tellipticbrush

#endif  // TELLIPTIC_BRUSH_P_H