//#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 : 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

};

/*

	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 {

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

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

						   vector<double>> &intersectedQuadratics);</double>

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();

}

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

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;

}

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

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 = tmax(thickQuadratic->getThickP0().thick,

						 thickQuadratic->getThickP1().thick,

						 thickQuadratic->getThickP2().thick);

		++chunkIndex;

		if (chunkIndex == chunkCount) {

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

			double thickness = tmax(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)->setP1(firstSplit.getP1());</tthickquadratic>

				const_cast<tthickquadratic *="">(thickQuadratic)->setP2(firstSplit.getP2());</tthickquadratic>

				nextQuadratic.split(nextSplit, firstSplit, secondSplit);

				const_cast<tthickquadratic *="">(nextThickQuadratic)->setP0(secondSplit.getP0());</tthickquadratic>

				const_cast<tthickquadratic *="">(nextThickQuadratic)->setP1(secondSplit.getP1());</tthickquadratic>

			}

		}

		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);

	}

}