//#include "tgeometry.h"

#include <set></set>

#include <map></map>

#include "tgl.h"

#include "tstroke.h"

//#include "tstrokeoutline.h"

#include "tcurveutil.h"

//#include "drawutil.h"

#include "tvectorimage.h"

#ifdef _WIN32

#include <crtdbg.h></crtdbg.h>

#include <windows.h></windows.h>

#endif

#include "tsweepboundary.h"

#include "tcurves.h"

// Some using declaration

using namespace std;

inline bool operator<(const TPointD &a, const TPointD &b) {

  if (a.x < b.x)

    return true;

  else if (a.x > b.x)

    return false;

  else if (a.y < b.y)

    return true;

  else if (a.y > b.y)

    return false;

  else

    return true;

}

namespace {

const double delta                     = 0.000001;

const double zero                      = delta;

const double one                       = 1 - delta;

const double thicknessLimit            = 0.3;

const double nonSimpleLoopsMaxDistance = 0.5;

const int nonSimpleLoopsMaxSize        = 5;

const int smallStrokeDim               = nonSimpleLoopsMaxSize * 5;

bool isSmallStroke                     = false;

set<tpointd> simpleCrossing;</tpointd>

set<tpointd> nonSimpleCrossing;</tpointd>

class LinkedQuadratic final : public TQuadratic {

public:

  LinkedQuadratic *prev, *next;

  LinkedQuadratic() : TQuadratic(), prev(0), next(0){};

  LinkedQuadratic(const TPointD &p0, const TPointD &p1, const TPointD &p2)

      : TQuadratic(p0, p1, p2), prev(0), next(0) {}

  LinkedQuadratic(TQuadratic &Quadratic)

      : TQuadratic(Quadratic), prev(0), next(0) {}

};

typedef enum Direction {

  inward         = 0,

  outward        = 1,

  deletedInward  = 2,

  deletedOutward = 3

} Direction;

/*

        class CompareOutlines {

        public:

                bool operator()(const vector<tquadratic*> &v1,</tquadratic*>

                                                const vector<tquadratic*> &v2)</tquadratic*>

                {

                        if(v1.empty()) return false;

                        else if(v2.empty()) return true;

                        else return v1[0]->getBBox().y1 > v2[0]->getBBox().y1;

                }

        };

        class CompareQuadratics {

        public:

                bool operator()(TQuadratic *const q1,

                                                TQuadratic *const q2)

                {

                        if (q1->getBBox().y1 > q2->getBBox().y1) return true;

                        else if (q1->getBBox().y1 < q2->getBBox().y1) return

   false;

                        else if (q1->getBBox().x1 > q2->getBBox().x1) return

   true;

                        else if (q1->getBBox().x1 < q2->getBBox().x1) return

   false;

                        else return false;

                }

        };

*/

class CompareLinkedQuadratics {

public:

  bool operator()(const LinkedQuadratic &q1, const LinkedQuadratic &q2) {

    if (q1.getBBox().y1 > q2.getBBox().y1)

      return true;

    else if (q1.getBBox().y1 < q2.getBBox().y1)

      return false;

    else if (q1.getBBox().x1 > q2.getBBox().x1)

      return true;

    else if (q1.getBBox().x1 < q2.getBBox().x1)

      return false;

    else

      return false;

  }

};

class CompareBranches {

public:

  bool operator()(const pair<linkedquadratic *,="" direction=""> &b1,</linkedquadratic>

                  const pair<linkedquadratic *,="" direction=""> &b2) {</linkedquadratic>

    TPointD p1, p2;

    if (b1.second == inward) {

      p1 = b1.first->getP1() - b1.first->getP2();

    } else  //(b1.second == outward)

    {

      p1 = b1.first->getP1() - b1.first->getP0();

    }

    if (b2.second == inward) {

      p2 = b2.first->getP1() - b2.first->getP2();

    } else  //(b1.second == outward)

    {

      p2 = b2.first->getP1() - b2.first->getP0();

    }

    double alpha1, alpha2;

    if (p1.x > 0)

      alpha1 = -p1.y / sqrt(norm2(p1));

    else if (p1.x < 0)

      alpha1 = 2 + p1.y / sqrt(norm2(p1));

    else  //(p1.x = 0)

    {

      if (p1.y > 0)

        alpha1 = -1;

      else if (p1.y < 0)

        alpha1 = 1;

      else

        assert(true);

    }

    if (p2.x > 0)

      alpha2 = -p2.y / sqrt(norm2(p2));

    else if (p2.x < 0)

      alpha2 = 2 + p2.y / sqrt(norm2(p2));

    else  //(p2.x = 0)

    {

      if (p2.y > 0)

        alpha2 = -1;

      else if (p2.y < 0)

        alpha2 = 1;

      else

        assert(true);

    }

    if (alpha2 - alpha1 > 0)

      return true;

    else if (alpha2 - alpha1 < 0)

      return false;

    else

      return false;

  }

};

typedef list<linkedquadratic> LinkedQuadraticList;</linkedquadratic>

typedef list<tquadratic> QuadraticList;</tquadratic>

}  // namespace {

//---------------------------------------------------------------------------

static void splitCircularArcIntoQuadraticCurves(

    const TPointD &Center, const TPointD &Pstart, const TPointD &Pend,

    vector<tquadratic *=""> &quadArray) {</tquadratic>

  // It splits a circular anticlockwise arc into a sequence of quadratic bezier

  // curves

  // Every quadratic curve can approximate an arc no longer than 45 degrees (or

  // 60).

  // It supposes that Pstart and Pend are onto the circumference (so that their

  // lengths

  // are equal to tha radius of the circumference), otherwise the resulting

  // curves could

  // be unpredictable.

  // The last component in quadCurve[] is an ending void curve

  /*

----------------------------------------------------------------------------------

*/

  // If you want to split the arc into arcs no longer than 45 degrees (so that

  // the whole

  // curve will be splitted into 8 pieces) you have to set these constants as

  // follows:

  // cos_ang     ==> cos_45   = 0.5 * sqrt(2);

  // sin_ang     ==> sin_45   = 0.5 * sqrt(2);

  // tan_semiang ==> tan_22p5 = 0.4142135623730950488016887242097;

  // N_QUAD                   = 8;

  // If you want to split the arc into arcs no longer than 60 degrees (so that

  // the whole

  // curve will be splitted into 6 pieces) you have to set these constants as

  // follows:

  // cos_ang     ==> cos_60 = 0.5;

  // sin_ang     ==> sin_60 = 0.5 * sqrt(3);

  // tan_semiang ==> tan_30 = 0.57735026918962576450914878050196;

  // N_QUAD                 = 6;

  /*

----------------------------------------------------------------------------------

*/

  // Defines some useful constant to split the arc into arcs no longer than

  // 'ang' degrees

  // (the whole circumference will be splitted into 360/ang quadratic curves).

  const double cos_ang     = 0.5 * sqrt(2.);

  const double sin_ang     = 0.5 * sqrt(2.);

  const double tan_semiang = 0.4142135623730950488016887242097;

  const int N_QUAD         = 8;  // it's 360/ang

  // First of all, it computes the vectors from the center to the circumference,

  // in Pstart and Pend, and their cross and dot products

  TPointD Rstart = Pstart - Center;  // its length is R (radius of the circle)

  TPointD Rend   = Pend - Center;    // its length is R (radius of the circle)

  double cross_prod       = cross(Rstart, Rend);  // it's Rstart x Rend

  double dot_prod         = Rstart * Rend;

  const double sqr_radius = Rstart * Rstart;

  TPointD aliasPstart     = Pstart;

  TQuadratic *quad;

  while ((cross_prod <= 0) ||

         (dot_prod <= cos_ang * sqr_radius))  // the circular arc is longer

                                              // than a 'ang' degrees arc

  {

    if (quadArray.size() == (UINT)N_QUAD)  // this is possible if Pstart or Pend

                                           // is not onto the circumference

      return;

    TPointD Rstart_rot_ang(cos_ang * Rstart.x - sin_ang * Rstart.y,

                           sin_ang * Rstart.x + cos_ang * Rstart.y);

    TPointD Rstart_rot_90(-Rstart.y, Rstart.x);

    quad =

        new TQuadratic(aliasPstart, aliasPstart + tan_semiang * Rstart_rot_90,

                       Center + Rstart_rot_ang);

    quadArray.push_back(quad);

    // quad->computeMinStepAtNormalSize ();

    // And moves anticlockwise the starting point on the circumference by 'ang'

    // degrees

    Rstart      = Rstart_rot_ang;

    aliasPstart = quad->getP2();

    cross_prod  = cross(Rstart, Rend);  // it's Rstart x Rend

    dot_prod    = Rstart * Rend;

    // after the rotation of 'ang' degrees, the remaining part of the arc could

    // be a 0 degree

    // arc, so it must stop and exit from the function

    if ((cross_prod <= 0) && (dot_prod > 0.95 * sqr_radius)) return;

  }

  if ((cross_prod > 0) && (dot_prod > 0))  // the last quadratic curve

                                           // approximates an arc shorter than a

                                           // 'ang' degrees arc

  {

    TPointD Rstart_rot_90(-Rstart.y, Rstart.x);

    double deg_index = (sqr_radius - dot_prod) / (sqr_radius + dot_prod);

    quad = new TQuadratic(aliasPstart,

                          (deg_index < 0)

                              ? 0.5 * (aliasPstart + Pend)

                              : aliasPstart + sqrt(deg_index) * Rstart_rot_90,

                          Pend);

    quadArray.push_back(quad);

  } else  // the last curve, already computed, is as long as a 'ang' degrees arc

    quadArray.back()->setP2(Pend);

}

inline bool left(const TPointD &a, const TPointD &b, const TPointD &c) {

  double area = (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);

  return area > 0;

}

inline bool right(const TPointD &a, const TPointD &b, const TPointD &c) {

  double area = (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);

  return area < 0;

}

inline bool collinear(const TPointD &a, const TPointD &b, const TPointD &c) {

  double area = (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);

  return area == 0;

}

void computeStrokeBoundary(const TStroke &stroke,

                           LinkedQuadraticList &inputBoundaries,

                           unsigned int &chunkIndex);

void normalizeTThickQuadratic(const TThickQuadratic *&sourceThickQuadratic,

                              TThickQuadratic &tempThickQuadratic);

inline void normalizeTQuadratic(TQuadratic *&sourceQuadratic);

void getBoundaryPoints(const TPointD &P0, const TPointD &P1,

                       const TThickPoint ¢er, TPointD &fwdPoint,

                       TPointD &rwdPoint);

void getAverageBoundaryPoints(const TPointD &P0, const TThickPoint ¢er,

                              const TPointD &P2, TPointD &fwdPoint,

                              TPointD &rwdPoint);

void linkQuadraticList(LinkedQuadraticList &inputBoundaries);

void computeInputBoundaries(LinkedQuadraticList &inputBoundaries);

void processAdjacentQuadratics(LinkedQuadraticList &inputBoundaries);

void findIntersections(

    LinkedQuadratic *quadratic, set<linkedquadratic *=""> &intersectionWindow,</linkedquadratic>

    map<linkedquadratic *,="" vector<double="">> &intersectedQuadratics);</linkedquadratic>

void refreshIntersectionWindow(LinkedQuadratic *quadratic,

                               set<linkedquadratic *=""> &intersectionWindow);</linkedquadratic>

void segmentate(LinkedQuadraticList &inputBoundaries,

                LinkedQuadratic *thickQuadratic, vector<double> &splitPoints);</double>

void processIntersections(LinkedQuadraticList &intersectionBoundary);

bool processNonSimpleLoops(

    TPointD &intersectionPoint,

    vector<pair<linkedquadratic *,="" direction="">> &crossing);</pair<linkedquadratic>

bool deleteUnlinkedLoops(LinkedQuadraticList &inputBoundaries);

bool getOutputOutlines(LinkedQuadraticList &inputBoundaries,

                       vector<tstroke *=""> &sweepStrokes);</tstroke>

void removeFalseHoles(const vector<tstroke *=""> &strokes);</tstroke>

inline void TraceLinkedQuadraticList(LinkedQuadraticList &quadraticList) {

#ifdef _WIN32

  _RPT0(_CRT_WARN, "\n__________________________________________________\n");

  LinkedQuadraticList::iterator it = quadraticList.begin();

  while (it != quadraticList.end()) {

    _RPT4(_CRT_WARN, "\nP0( %f, %f)   P2( %f, %f)", it->getP0().x,

          it->getP0().y, it->getP2().x, it->getP2().y);

    _RPT3(_CRT_WARN, " currAddress = %p, nextAddress = %p prevAddress = %p\n",

          &(*it), it->next, it->prev);

    ++it;

  }

#endif

}

inline void drawPointSquare(const TPointD &point, double R, double G,

                            double B) {

#define SQUARE_DIM 0.04

  glBegin(GL_LINE_LOOP);

  glColor3d(R, G, B);

  glVertex2d(point.x + SQUARE_DIM, point.y + SQUARE_DIM);

  glVertex2d(point.x + SQUARE_DIM, point.y - SQUARE_DIM);

  glVertex2d(point.x - SQUARE_DIM, point.y - SQUARE_DIM);

  glVertex2d(point.x - SQUARE_DIM, point.y + SQUARE_DIM);

  glEnd();

}

inline void drawPointCross(const TPointD &point, double R, double G, double B) {

#define CROSS_DIM 0.04

  glBegin(GL_LINES);

  glColor3d(R, G, B);

  glVertex2d(point.x - CROSS_DIM, point.y - CROSS_DIM);

  glVertex2d(point.x + CROSS_DIM, point.y + CROSS_DIM);

  glVertex2d(point.x + CROSS_DIM, point.y - CROSS_DIM);

  glVertex2d(point.x - CROSS_DIM, point.y + CROSS_DIM);

  glEnd();

}

//-------------------------------------------------------------------

static TStroke *getOutStroke(LinkedQuadraticList &inputBoundaries) {

  vector<tpointd> aux;</tpointd>

  LinkedQuadraticList::iterator it = inputBoundaries.begin();

  aux.push_back(inputBoundaries.front().getP0());

  for (; it != inputBoundaries.end(); ++it)

  {

    // if (tdistance2(aux.back(), it->getP2())>0.25)

    {

      aux.push_back(it->getP1());

      aux.push_back(it->getP2());

    }

    // inputBoundaries.remove(*it);

  }

  return new TStroke(aux);

}

//-------------------------------------------------------------------

inline bool getOutputOutlines(LinkedQuadraticList &inputBoundaries,

                              vector<tstroke *=""> &sweepStrokes) {</tstroke>

  // int count=0;

  while (!inputBoundaries.empty()) {

    // outputOutlines.push_back(TFlash::Polyline());

    vector<tpointd> v;</tpointd>

    LinkedQuadraticList::iterator it = inputBoundaries.begin();

    // std::advance(it, count+1);

    LinkedQuadratic *first = &(*it);

    LinkedQuadratic *toRemove, *current = first;

    v.push_back(current->getP0());

    do {

      // if (tdistance2(v.back(), current->getP2())>0.25)

      {

        v.push_back(current->getP1());

        v.push_back(current->getP2());

      }

      // count++;

      // outputOutlines.back().m_quads.push_back(new TQuadratic(*current));

      toRemove = current;

      current  = current->next;

      inputBoundaries.remove(*toRemove);

      //			assert(current);

      if (!current) {

        inputBoundaries.clear();

        //				outputOutlines.pop_back();

        return false;

      }

    } while (current != first && !inputBoundaries.empty());

    sweepStrokes.push_back(new TStroke(v));

    //		sort(outputOutlines[count].begin(), outputOutlines[count].end(),

    // CompareQuadratics());

  }

  inputBoundaries.clear();

  return true;

}

//-------------------------------------------------------------------

static bool computeBoundaryStroke(const TStroke &_stroke,

                                  vector<tstroke *=""> &sweepStrokes) {</tstroke>

  // if(!outlines.empty()) return false;

  TStroke *oriStroke = const_cast<tstroke *="">(&_stroke);</tstroke>

  TStroke *stroke    = oriStroke;

  for (int i = 0; i < stroke->getControlPointCount(); i++) {

    TThickPoint p = stroke->getControlPoint(i);

    // se ci sono punti a spessore nullo, viene male il boundary.

    if (areAlmostEqual(p.thick, 0, 1e-8)) {

      if (stroke == oriStroke) stroke = new TStroke(_stroke);

      stroke->setControlPoint(i, TThickPoint(p.x, p.y, 0.0001));

    }

  }

  unsigned int chunkIndex = 0;

  while (chunkIndex < (UINT)stroke->getChunkCount()) {

    LinkedQuadraticList tempBoundary;

    LinkedQuadraticList inputBoundaries;

    simpleCrossing.clear();

    nonSimpleCrossing.clear();

    isSmallStroke = false;

    computeStrokeBoundary(*stroke, inputBoundaries, chunkIndex);

    inputBoundaries.sort(CompareLinkedQuadratics());

    computeInputBoundaries(inputBoundaries);

    if (!deleteUnlinkedLoops(inputBoundaries)) return false;

    if (!getOutputOutlines(inputBoundaries, sweepStrokes)) return false;

    // TStroke *sout = getOutStroke(inputBoundaries);

    // sweepStrokes.push_back(sout);

    // if(!getOutputOutlines(inputBoundaries, outlines)) return false;

  }

  if (stroke != &_stroke) delete stroke;

  return true;

}

//-------------------------------------------------------------------

inline void computeStrokeBoundary(const TStroke &stroke,

                                  LinkedQuadraticList &inputBoundaries,

                                  unsigned int &chunkIndex) {

  unsigned int chunkCount = stroke.getChunkCount();

  assert(chunkCount - chunkIndex > 0);

  if ((int)(chunkCount - chunkIndex) <= smallStrokeDim) isSmallStroke = true;

  unsigned int startIndex               = chunkIndex;

  const TThickQuadratic *thickQuadratic = 0, *nextThickQuadratic = 0;

  TThickQuadratic tempThickQuadratic, tempNextThickQuadratic;

  TPointD fwdP0, fwdP1, fwdP2;

  TPointD rwdP0, rwdP1, rwdP2;

  TPointD nextFwdP0, nextRwdP2;

  thickQuadratic = stroke.getChunk(chunkIndex);

  while (thickQuadratic->getP0() == thickQuadratic->getP2()) {

    double thickness;

    thickness = std::max({thickQuadratic->getThickP0().thick,

                          thickQuadratic->getThickP1().thick,

                          thickQuadratic->getThickP2().thick});

    ++chunkIndex;

    if (chunkIndex == chunkCount) {

      vector<tquadratic *=""> quadArray;</tquadratic>

      double thickness = std::max({thickQuadratic->getThickP0().thick,

                                   thickQuadratic->getThickP1().thick,

                                   thickQuadratic->getThickP2().thick});

      if (thickness < thicknessLimit) thickness = thicknessLimit;

      TPointD center        = thickQuadratic->getP0();

      TPointD diameterStart = thickQuadratic->getP0();

      diameterStart.y += thickness;

      TPointD diameterEnd = thickQuadratic->getP0();

      diameterEnd.y -= thickness;

      splitCircularArcIntoQuadraticCurves(center, diameterStart, diameterEnd,

                                          quadArray);

      unsigned int i = 0;

      for (; i < quadArray.size(); ++i) {

        assert(!(quadArray[i]->getP0() == quadArray[i]->getP2()));

        normalizeTQuadratic(quadArray[i]);

        inputBoundaries.push_back(*quadArray[i]);

        delete quadArray[i];

      }

      quadArray.clear();

      splitCircularArcIntoQuadraticCurves(center, diameterEnd, diameterStart,

                                          quadArray);

      for (i = 0; i < quadArray.size(); ++i) {

        assert(!(quadArray[i]->getP0() == quadArray[i]->getP2()));

        normalizeTQuadratic(quadArray[i]);

        inputBoundaries.push_back(*quadArray[i]);

        delete quadArray[i];

      }

      quadArray.clear();

      linkQuadraticList(inputBoundaries);

      return;

    }

    thickQuadratic = stroke.getChunk(chunkIndex);

  }

  normalizeTThickQuadratic(thickQuadratic, tempThickQuadratic);

  getBoundaryPoints(thickQuadratic->getP0(), thickQuadratic->getP1(),

                    thickQuadratic->getThickP0(), fwdP0, rwdP2);

  if (!(rwdP2 == fwdP0)) {

    //		inputBoundaries.push_front(TQuadratic(rwdP2, (rwdP2+fwdP0)*0.5,

    // fwdP0));

    vector<tquadratic *=""> quadArray;</tquadratic>

    splitCircularArcIntoQuadraticCurves((rwdP2 + fwdP0) * 0.5, rwdP2, fwdP0,

                                        quadArray);

    for (unsigned int i = 0; i < quadArray.size(); ++i) {

      if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

        normalizeTQuadratic(quadArray[i]);

        inputBoundaries.push_back(*quadArray[i]);

      }

      delete quadArray[i];

    }

    quadArray.clear();

  }

  for (/*chunkIndex*/; chunkIndex < chunkCount; ++chunkIndex) {

    thickQuadratic = stroke.getChunk(chunkIndex);

    while (thickQuadratic->getP0() == thickQuadratic->getP2()) {

      ++chunkIndex;

      if (chunkIndex == chunkCount) break;

      thickQuadratic = stroke.getChunk(chunkIndex);

    }

    if (chunkIndex >= chunkCount - 1) {

      chunkIndex = chunkCount;

      break;

    }

    unsigned int nextChunkIndex = chunkIndex + 1;

    nextThickQuadratic          = stroke.getChunk(nextChunkIndex);

    while (nextThickQuadratic->getP0() == nextThickQuadratic->getP2()) {

      ++nextChunkIndex;

      if (nextChunkIndex == chunkCount) {

        chunkIndex = chunkCount;

        break;

      }

      nextThickQuadratic = stroke.getChunk(nextChunkIndex);

    }

    if (nextChunkIndex == chunkCount) {

      chunkIndex = chunkCount;

      break;

    }

    if (thickQuadratic->getP0() == nextThickQuadratic->getP2() &&

        thickQuadratic->getP2() == nextThickQuadratic->getP0()) {

      chunkIndex = nextChunkIndex;

      continue;

    }

    if (chunkIndex == startIndex + 2 &&

        norm(stroke.getChunk(startIndex)->getP0() -

             stroke.getChunk(chunkCount - 1)->getP2()) <

            stroke.getChunk(startIndex)->getThickP0().thick / 2) {

      ++chunkIndex;

      break;

    }

    normalizeTThickQuadratic(thickQuadratic, tempThickQuadratic);

    normalizeTThickQuadratic(nextThickQuadratic, tempNextThickQuadratic);

    vector<doublepair> intersections;</doublepair>

    TQuadratic quadratic(thickQuadratic->getP0(), thickQuadratic->getP1(),

                         thickQuadratic->getP2());

    TQuadratic nextQuadratic(nextThickQuadratic->getP0(),

                             nextThickQuadratic->getP1(),

                             nextThickQuadratic->getP2());

    if (intersect(quadratic, nextQuadratic, intersections) > 1) {

      double currSplit = 1, nextSplit = 0;

      for (unsigned int i = 0; i < intersections.size(); ++i) {

        if (currSplit > intersections[i].first)

          currSplit = intersections[i].first;

        if (nextSplit < intersections[i].second)

          nextSplit = intersections[i].second;

      }

      if (currSplit < one && nextSplit > zero && currSplit > 0.5 &&

          nextSplit < 0.5) {

        TQuadratic firstSplit, secondSplit;

        quadratic.split(currSplit, firstSplit, secondSplit);

        const_cast<tthickquadratic *="">(thickQuadratic)</tthickquadratic>

            ->setP1(firstSplit.getP1());

        const_cast<tthickquadratic *="">(thickQuadratic)</tthickquadratic>

            ->setP2(firstSplit.getP2());

        nextQuadratic.split(nextSplit, firstSplit, secondSplit);

        const_cast<tthickquadratic *="">(nextThickQuadratic)</tthickquadratic>

            ->setP0(secondSplit.getP0());

        const_cast<tthickquadratic *="">(nextThickQuadratic)</tthickquadratic>

            ->setP1(secondSplit.getP1());

      }

    }

    getAverageBoundaryPoints(thickQuadratic->getP0(),

                             thickQuadratic->getThickP1(),

                             thickQuadratic->getP2(), fwdP1, rwdP1);

    getBoundaryPoints(thickQuadratic->getP1(), thickQuadratic->getP2(),

                      thickQuadratic->getThickP2(), fwdP2, rwdP0);

    getBoundaryPoints(thickQuadratic->getP2(), nextThickQuadratic->getP1(),

                      thickQuadratic->getThickP2(), nextFwdP0, nextRwdP2);

    TPointD v1 = thickQuadratic->getP2() - thickQuadratic->getP1();

    TPointD v2 = nextThickQuadratic->getP1() - nextThickQuadratic->getP0();

    if ((v1 * v2) / (norm(v1) * norm(v2)) < -0.95) {

      ++chunkIndex;

      break;

    }

    if (nextFwdP0 == fwdP2 && nextRwdP2 == rwdP0) {

      inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));

      inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));

      fwdP0 = fwdP2;

      rwdP2 = rwdP0;

    } else if (!(nextFwdP0 == fwdP2) && !(nextRwdP2 == rwdP0)) {

      bool turnLeft, turnRight;

      turnLeft = left(thickQuadratic->getP1(), thickQuadratic->getP2(),

                      nextThickQuadratic->getP1());

      turnRight = right(thickQuadratic->getP1(), thickQuadratic->getP2(),

                        nextThickQuadratic->getP1());

      if (turnLeft) {

        double thickness = thickQuadratic->getThickP2().thick;

        if (thickness < thicknessLimit) thickness = thicknessLimit;

        TPointD temp;

        if (rwdP0 + nextRwdP2 - 2 * thickQuadratic->getP2() != TPointD(0, 0)) {

          temp = (normalize(rwdP0 + nextRwdP2 - 2 * thickQuadratic->getP2()) *

                  thickness) +

                 thickQuadratic->getP2();

        } else

          temp = TPointD(0, 0);

        inputBoundaries.push_front(LinkedQuadratic(temp, rwdP1, rwdP2));

        inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));

        vector<tquadratic *=""> quadArray;</tquadratic>

        splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,

                                            nextFwdP0, quadArray);

        for (unsigned int i = 0; i < quadArray.size(); ++i) {

          if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

            normalizeTQuadratic(quadArray[i]);

            inputBoundaries.push_back(*quadArray[i]);

          }

          delete quadArray[i];

        }

        quadArray.clear();

        fwdP0 = nextFwdP0;

        rwdP2 = temp;

      } else if (turnRight) {

        double thickness = thickQuadratic->getThickP2().thick;

        if (thickness < thicknessLimit) thickness = thicknessLimit;

        TPointD temp;

        if (fwdP2 + nextFwdP0 - 2 * thickQuadratic->getP2() != TPointD(0, 0)) {

          temp = (normalize(fwdP2 + nextFwdP0 - 2 * thickQuadratic->getP2()) *

                  thickness) +

                 thickQuadratic->getP2();

        } else

          temp = TPointD(0, 0);

        inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));

        inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, temp));

        vector<tquadratic *=""> quadArray;</tquadratic>

        splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), nextRwdP2,

                                            rwdP0, quadArray);

        for (int i = quadArray.size() - 1; i >= 0; --i) {

          if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

            normalizeTQuadratic(quadArray[i]);

            inputBoundaries.push_front(*quadArray[i]);

          }

          delete quadArray[i];

        }

        quadArray.clear();

        fwdP0 = temp;

        rwdP2 = nextRwdP2;

      } else if (nextFwdP0 == rwdP0 && nextRwdP2 == fwdP2) {

        ++chunkIndex;

        break;

        //				assert(collinear(thickQuadratic->getP0(),

        //								thickQuadratic->getP2(),

        //								nextThickQuadratic->getP2()));

        if (!collinear(thickQuadratic->getP0(), thickQuadratic->getP2(),

                       nextThickQuadratic->getP2())) {

          inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));

          inputBoundaries.push_front(

              LinkedQuadratic(thickQuadratic->getP2(), rwdP1, rwdP2));

          vector<tquadratic *=""> quadArray;</tquadratic>

          splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,

                                              nextFwdP0, quadArray);

          for (unsigned int i = 0; i < quadArray.size(); ++i) {

            if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

              normalizeTQuadratic(quadArray[i]);

              inputBoundaries.push_back(*quadArray[i]);

            }

            delete quadArray[i];

          }

          quadArray.clear();

          fwdP0 = nextFwdP0;

          rwdP2 = thickQuadratic->getP2();

        } else if (left(thickQuadratic->getP0(), thickQuadratic->getP1(),

                        nextThickQuadratic->getP2())) {

          inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));

          vector<tquadratic *=""> quadArray;</tquadratic>

          splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,

                                              nextFwdP0, quadArray);

          for (unsigned int i = 0; i < quadArray.size(); ++i) {

            if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

              normalizeTQuadratic(quadArray[i]);

              inputBoundaries.push_back(*quadArray[i]);

            }

            delete quadArray[i];

          }

          quadArray.clear();

          fwdP0 = nextFwdP0;

          rwdP2 = rwdP0;

        } else if (right(thickQuadratic->getP0(), thickQuadratic->getP1(),

                         nextThickQuadratic->getP2())) {

          inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));

          vector<tquadratic *=""> quadArray;</tquadratic>

          splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,

                                              nextFwdP0, quadArray);

          for (int i = quadArray.size() - 1; i >= 0; --i) {

            if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

              normalizeTQuadratic(quadArray[i]);

              inputBoundaries.push_front(*quadArray[i]);

            }

            delete quadArray[i];

          }

          quadArray.clear();

          fwdP0 = fwdP2;

          rwdP2 = nextRwdP2;

        } else {

          //					inputBoundaries.push_back(TQuadratic(fwdP0,

          // fwdP1, fwdP2));

          //					inputBoundaries.push_front(TQuadratic(rwdP0,

          // rwdP1, rwdP2));

          //					fwdP0 = nextFwdP0;

          //					rwdP2 = nextRwdP2;

          ++chunkIndex;

          break;

        }

      } else

        assert(false);

    } else

      assert(false);

  }

  normalizeTThickQuadratic(thickQuadratic, tempThickQuadratic);

  //	if(	stroke->getChunk(0)->getP0() ==

  // stroke->getChunk(chunkCount-1)->getP2() )

  /*	if(	norm(stroke->getChunk(0)->getP0() - stroke->getChunk(chunkCount-1)->getP2()) <

		stroke->getChunk(0)->getThickP0().thick/2)

	{

		getAverageBoundaryPoints(thickQuadratic->getP0(),

					thickQuadratic->getThickP1(),

					thickQuadratic->getP2(),

					fwdP1,

					rwdP1);

		getBoundaryPoints(thickQuadratic->getP1(),

						thickQuadratic->getP2(),

						thickQuadratic->getThickPoint(one),

						fwdP2,

						rwdP0);

		inputBoundaries.push_front(TQuadratic(rwdP0, rwdP1, rwdP2));

		inputBoundaries.push_back(TQuadratic(fwdP0, fwdP1, fwdP2));

		inputBoundaries.push_back(TQuadratic(fwdP2, (fwdP2+rwdP0)*0.5, rwdP0));

	}

	else

*/ {

    getAverageBoundaryPoints(thickQuadratic->getP0(),

                             thickQuadratic->getThickP1(),

                             thickQuadratic->getP2(), fwdP1, rwdP1);

    getBoundaryPoints(thickQuadratic->getP1(), thickQuadratic->getP2(),

                      thickQuadratic->getThickP2(), fwdP2, rwdP0);

    inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));

    inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));

    if (!(fwdP2 == rwdP0)) {

      vector<tquadratic *=""> quadArray;</tquadratic>

      splitCircularArcIntoQuadraticCurves((fwdP2 + rwdP0) * 0.5, fwdP2, rwdP0,

                                          quadArray);

      for (unsigned int i = 0; i < quadArray.size(); ++i) {

        if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {

          normalizeTQuadratic(quadArray[i]);

          inputBoundaries.push_back(*quadArray[i]);

        }

        delete quadArray[i];

      }

      quadArray.clear();

    }

  }

  linkQuadraticList(inputBoundaries);

}

//-------------------------------------------------------------------

inline void normalizeTThickQuadratic(

    const TThickQuadratic *&sourceThickQuadratic,

    TThickQuadratic &tempThickQuadratic) {

  assert(!(sourceThickQuadratic->getP0() == sourceThickQuadratic->getP2()));

  if (sourceThickQuadratic->getP0() == sourceThickQuadratic->getP1() ||

      sourceThickQuadratic->getP1() == sourceThickQuadratic->getP2() ||

      collinear(sourceThickQuadratic->getP0(), sourceThickQuadratic->getP1(),

                sourceThickQuadratic->getP2())) {

    tempThickQuadratic = *sourceThickQuadratic;

    TThickPoint middleThickPoint(

        (sourceThickQuadratic->getP0() + sourceThickQuadratic->getP2()) * 0.5);

    middleThickPoint.thick = tempThickQuadratic.getThickP1().thick;

    tempThickQuadratic.setThickP1(middleThickPoint);

    sourceThickQuadratic = &tempThickQuadratic;

  }

}

inline void normalizeTQuadratic(TQuadratic *&sourceQuadratic) {

  assert(!(sourceQuadratic->getP0() == sourceQuadratic->getP2()));

  if (sourceQuadratic->getP0() == sourceQuadratic->getP1() ||

      sourceQuadratic->getP1() == sourceQuadratic->getP2() ||

      collinear(sourceQuadratic->getP0(), sourceQuadratic->getP1(),

                sourceQuadratic->getP2())) {

    TPointD middleThickPoint(

        (sourceQuadratic->getP0() + sourceQuadratic->getP2()) * 0.5);

    sourceQuadratic->setP1(middleThickPoint);

  }

}

//-------------------------------------------------------------------