//#include "tsystem.h"

#include "tmachine.h"

#include "tcurves.h"

#include "tcommon.h"

#include "tregion.h"

//#include "tregionutil.h"

#include "tstopwatch.h"

#include "tstroke.h"

#include "tstrokeutil.h"

#include "tvectorimageP.h"

#include "tdebugmessage.h"

#include <vector></vector>

#include "tcurveutil.h"

#include <algorithm></algorithm>

#if !defined(TNZ_LITTLE_ENDIAN)

TNZ_LITTLE_ENDIAN undefined !!

#endif

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

#ifdef IS_DOTNET

#define NULL_ITER list<intersectedstroke>::iterator()</intersectedstroke>

#else

#define NULL_ITER 0

#endif

	using namespace std;

typedef TVectorImage::IntersectionBranch IntersectionBranch;

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

inline double myRound(double x)

{

	return (1.0 / REGION_COMPUTING_PRECISION) * ((long)(x * REGION_COMPUTING_PRECISION));

}

inline TThickPoint myRound(const TThickPoint &p)

{

	return TThickPoint(myRound(p.x), myRound(p.y), p.thick);

}

void print(list<intersection> &intersectionList, char *str)</intersection>

{

	ofstream of(str);

	of << "***************************" << endl;

	list<intersection>::const_iterator it;</intersection>

	list<intersectedstroke>::const_iterator it1;</intersectedstroke>

	int i, j;

	for (i = 0, it = intersectionList.begin(); it != intersectionList.end(); it++, i++) {

		of << "***************************" << endl;

		of << "Intersection#" << i << ": " << it->m_intersection << "numBranches: " << it->m_numInter << endl;

		of << endl;

		for (j = 0, it1 = it->m_strokeList.begin(); it1 != it->m_strokeList.end(); it1++, j++) {

			of << "----Branch #" << j;

			if (it1->m_edge.m_index < 0)

				of << "(AUTOCLOSE)";

			of << "Intersection at " << it1->m_edge.m_w0 << ": "

			   << ": " << endl;

			of << "ColorId: " << it1->m_edge.m_styleId << endl;

			/*

    TColorStyle* fs = it1->m_edge.m_fillStyle;

    if (fs==0)

      of<<"NO color: "<< endl;

    else 

      {

      TFillStyleP fp = fs->getFillStyle();

      if (fp)

        {

        fp->

      assert(false) ;

    else

      of<<"Color: ("<< colorStyle->getColor().r<<", "<< colorStyle->getColor().g<<", "<< colorStyle->getColor().b<<")"<

   */

			of << "----Stroke " << (it1->m_gettingOut ? "OUT" : "IN") << " #" << it1->m_edge.m_index << ": " << endl;

			//if (it1->m_dead)

			//of<<"---- DEAD Intersection.";

			//else

			{

				of << "---- NEXT Intersection:";

				if (it1->m_nextIntersection != intersectionList.end()) {

					int dist = std::distance(intersectionList.begin(), it1->m_nextIntersection);

					of << dist;

					list<intersection>::iterator iit = intersectionList.begin();</intersection>

					std::advance(iit, dist);

					of << " " << std::distance(iit->m_strokeList.begin(), it1->m_nextStroke);

				}

				else

					of << "NULL!!";

				of << "---- NEXT Stroke:";

				if (it1->m_nextIntersection != intersectionList.end())

					of << it1->m_nextStroke->m_edge.m_index;

				else

					of << "NULL!!";

			}

			of << endl

			   << endl;

		}

	}

}

void findNearestIntersection(list<intersection> &interList,</intersection>

							 const list<intersection>::iterator &i1,</intersection>

							 const list<intersectedstroke>::iterator &i2);</intersectedstroke>

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

#ifdef _TOLGO

void checkInterList(list<intersection> &intersectionList)</intersection>

{

	list<intersection>::iterator it;</intersection>

	list<intersectedstroke>::iterator it1;</intersectedstroke>

	for (it = intersectionList.begin(); it != intersectionList.end(); it++) {

		int count = 0;

		for (it1 = it->m_strokeList.begin(); it1 != it->m_strokeList.end(); it1++) {

			int val;

			if (it1->m_nextIntersection != intersectionList.end()) {

				count++;

				//assert (it1->m_nextIntersection!=intersectionList.end());

				assert(it1->m_nextStroke->m_nextIntersection == it);

				assert(it1->m_nextStroke->m_nextStroke == it1);

				//int k = it1->m_edge.m_index;

				val = std::distance(intersectionList.begin(), it1->m_nextIntersection);

			}

			//else

			// assert(it1->m_nextIntersection==intersectionList.end());

		}

		assert(count == it->m_numInter);

	}

}

#else

#define checkInterList

#endif

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

//void addFakeIntersection(list<intersection>& intersectionList,TStroke* s, UINT ii, double w);</intersection>

void addIntersections(IntersectionData &intersectionData,

					  const vector<vistroke *=""> &s, int ii, int jj, const vector<doublepair> &intersections, int numStrokes);</doublepair></vistroke>

void addIntersection(IntersectionData &intData,

					 const vector<vistroke *=""> &s, int ii, int jj,</vistroke>

					 DoublePair intersections, int strokeSize);

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

bool sortBBox(const TStroke *s1, const TStroke *s2)

{

	return s1->getBBox().x0 < s2->getBBox().x0;

}

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

void cleanIntersectionMarks(list<intersection> &interList)</intersection>

{

	for (list<intersection>::iterator it1 = interList.begin(); it1 != interList.end(); it1++)</intersection>

		for (list<intersectedstroke>::iterator it2 = (*it1).m_strokeList.begin(); it2 != (*it1).m_strokeList.end(); it2++) {</intersectedstroke>

			it2->m_visited = false; // Ogni ramo della lista viene messo nella condizione

									// di poter essere visitato

			if (it2->m_nextIntersection != interList.end()) {

				it2->m_nextIntersection = interList.end(); //pezza tremenda, da togliere!!!

				it1->m_numInter--;

			}

		}

}

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

void cleanNextIntersection(list<intersection> &interList, TStroke *s)</intersection>

{

	for (list<intersection>::iterator it1 = interList.begin(); it1 != interList.end(); it1++)</intersection>

		for (list<intersectedstroke>::iterator it2 = (*it1).m_strokeList.begin(); it2 != (*it1).m_strokeList.end(); it2++)</intersectedstroke>

			if (it2->m_edge.m_s == s) {

				//if (it2->m_nextIntersection==NULL)

				//  return; //gia' ripulita prima

				if (it2->m_nextIntersection != interList.end()) {

					it2->m_nextIntersection = interList.end();

					it1->m_numInter--;

				}

				it2->m_nextStroke = (*it1).m_strokeList.end();

			}

}

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

void TVectorImage::Imp::eraseEdgeFromStroke(list<intersectedstroke>::iterator it2)</intersectedstroke>

{

	if (it2->m_edge.m_index >= 0) //elimino il puntatore all'edge nella lista della VIStroke

	{

		VIStroke *s;

		s = m_strokes[it2->m_edge.m_index];

		assert(s->m_s == it2->m_edge.m_s);

		list<tedge *="">::iterator iit = s->m_edgeList.begin(), it_e = s->m_edgeList.end();</tedge>

		for (; iit != it_e; ++iit)

			if ((*iit)->m_w0 == it2->m_edge.m_w0 && (*iit)->m_w1 == it2->m_edge.m_w1) {

				assert((*iit)->m_toBeDeleted == false);

				s->m_edgeList.erase(iit);

				return;

			}

	}

}

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

list<intersectedstroke>::iterator TVectorImage::Imp::eraseBranch(list<intersection>::iterator it1,</intersection></intersectedstroke>

																 list<intersectedstroke>::iterator it2)</intersectedstroke>

{

	//list<intersection>::iterator iit1;</intersection>

	//list<intersectedstroke>::iterator iit2;</intersectedstroke>

	list<intersection> &intList = m_intersectionData.m_intList;</intersection>

	if (it2->m_nextIntersection != intList.end()) {

		list<intersection>::iterator nextInt = it2->m_nextIntersection;</intersection>

		list<intersectedstroke>::iterator nextStroke = it2->m_nextStroke;</intersectedstroke>

		assert(nextStroke->m_nextIntersection == it1);

		assert(nextStroke->m_nextStroke == it2);

		assert(nextStroke != it2);

		//nextStroke->m_nextIntersection = intList.end();

		//nextStroke->m_nextStroke = nextInt->m_strokeList.end();

		if (nextStroke->m_nextIntersection != intList.end()) {

			nextStroke->m_nextIntersection = intList.end();

			nextInt->m_numInter--;

		}

		//nextInt->m_strokeList.erase(nextStroke);//non posso cancellarla, puo' servire in futuro!

	}

	if (it2->m_nextIntersection != intList.end())

		it1->m_numInter--;

	eraseEdgeFromStroke(it2);

	it2->m_edge.m_w0 = it2->m_edge.m_w1 = -3;

	it2->m_edge.m_index = -3;

	it2->m_edge.m_s = 0;

	it2->m_edge.m_styleId = -3;

	list<intersectedstroke>::iterator ret = (*it1).m_strokeList.erase(it2);</intersectedstroke>

	return ret;

}

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

void TVectorImage::Imp::eraseDeadIntersections()

{

	list<intersection>::iterator it;</intersection>

	for (it = m_intersectionData.m_intList.begin(); it != m_intersectionData.m_intList.end();) //la faccio qui, e non nella eraseIntersection. vedi commento li'.

	{

		list<intersection> &intList = m_intersectionData.m_intList;</intersection>

		if (it->m_strokeList.size() == 1) {

			eraseBranch(it, (*it).m_strokeList.begin());

			assert(it->m_strokeList.empty());

			it = intList.erase(it);

		} else if (it->m_strokeList.size() == 2 &&

				   ((*it).m_strokeList.front().m_edge.m_s == (*it).m_strokeList.back().m_edge.m_s &&

					(*it).m_strokeList.front().m_edge.m_w0 == (*it).m_strokeList.back().m_edge.m_w0)) //intersezione finta

		{

			list<intersectedstroke>::iterator it1 = it->m_strokeList.begin(), iit1, iit2;</intersectedstroke>

			list<intersectedstroke>::iterator it2 = it1;</intersectedstroke>

			it2++;

			eraseEdgeFromStroke(it1);

			eraseEdgeFromStroke(it2);

			iit1 = (it1->m_nextIntersection == intList.end()) ? NULL_ITER : it1->m_nextStroke;

			iit2 = (it2->m_nextIntersection == intList.end()) ? NULL_ITER : it2->m_nextStroke;

			if (iit1 != NULL_ITER && iit2 != NULL_ITER) {

				iit1->m_edge.m_w1 = iit2->m_edge.m_w0;

				iit2->m_edge.m_w1 = iit1->m_edge.m_w0;

			}

			if (iit1 != NULL_ITER) {

				iit1->m_nextStroke = iit2;

				iit1->m_nextIntersection = it2->m_nextIntersection;

				if (iit1->m_nextIntersection == intList.end())

					it1->m_nextIntersection->m_numInter--;

			}

			if (iit2 != NULL_ITER) {

				iit2->m_nextStroke = iit1;

				iit2->m_nextIntersection = it1->m_nextIntersection;

				if (iit2->m_nextIntersection == intList.end())

					it2->m_nextIntersection->m_numInter--;

			}

			it->m_strokeList.clear();

			it->m_numInter = 0;

			it = intList.erase(it);

		} else

			++it;

	}

}

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

void TVectorImage::Imp::doEraseIntersection(int index, vector<int> *toBeDeleted)</int>

{

	list<intersection> &interList = m_intersectionData.m_intList;</intersection>

	list<intersection>::iterator it1 = interList.begin();</intersection>

	TStroke *deleteIt = 0;

	while (it1 != interList.end()) {

		bool removeAutocloses = false;

		list<intersectedstroke>::iterator it2 = (*it1).m_strokeList.begin();</intersectedstroke>

		while (it2 != (*it1).m_strokeList.end()) {

			IntersectedStroke &is = *it2;

			if (is.m_edge.m_index == index) {

				if (is.m_edge.m_index >= 0)

					//if (!is.m_autoclose && (is.m_edge.m_w0==1 || is.m_edge.m_w0==0))

					removeAutocloses = true;

				else

					deleteIt = is.m_edge.m_s;

				it2 = eraseBranch(it1, it2);

			} else

				++it2;

			//checkInterList(interList);

		}

		if (removeAutocloses) //se ho tolto una stroke dall'inter corrente, tolgo tutti le stroke di autclose che partono da qui

		{

			assert(toBeDeleted);

			for (it2 = (*it1).m_strokeList.begin(); it2 != (*it1).m_strokeList.end(); it2++)

				if (it2->m_edge.m_index < 0 && (it2->m_edge.m_w0 == 1 || it2->m_edge.m_w0 == 0))

					toBeDeleted->push_back(it2->m_edge.m_index);

		}

		if ((*it1).m_strokeList.empty())

			it1 = interList.erase(it1);

		else

			it1++;

	}

	if (deleteIt)

		delete deleteIt;

}

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

UINT TVectorImage::Imp::getFillData(IntersectionBranch *&v)

{

	//print(m_intersectionData.m_intList, "C:\\temp\\intersectionPrimaSave.txt");

	list<intersection> &intList = m_intersectionData.m_intList;</intersection>

	if (intList.empty())

		return 0;

	list<intersection>::iterator it1;</intersection>

	list<intersectedstroke>::iterator it2;</intersectedstroke>

	UINT currInt = 0;

	vector<uint> branchesBefore(intList.size() + 1);</uint>

	branchesBefore[0] = 0;

	UINT count = 0, size = 0;

	for (it1 = intList.begin(); it1 != intList.end(); ++it1, currInt++) {

		UINT strokeListSize = it1->m_strokeList.size();

		size += strokeListSize;

		branchesBefore[currInt + 1] = branchesBefore[currInt] + strokeListSize;

	}

	v = new IntersectionBranch[size];

	currInt = 0;

	for (it1 = intList.begin(); it1 != intList.end(); ++it1, currInt++) {

		UINT currBranch = 0;

		for (it2 = it1->m_strokeList.begin(); it2 != it1->m_strokeList.end(); ++it2, currBranch++) {

			IntersectionBranch &b = v[count];

			b.m_currInter = currInt;

			b.m_strokeIndex = it2->m_edge.m_index;

			b.m_w = it2->m_edge.m_w0;

			b.m_style = it2->m_edge.m_styleId;

			//assert(b.m_style<100);

			b.m_gettingOut = it2->m_gettingOut;

			if (it2->m_nextIntersection == intList.end())

				b.m_nextBranch = count;

			else {

				UINT distInt = std::distance(intList.begin(), it2->m_nextIntersection);

				UINT distBranch = std::distance(it2->m_nextIntersection->m_strokeList.begin(), it2->m_nextStroke);

				if ((distInt < currInt) ||

					(distInt == currInt && distBranch < currBranch)) {

					UINT posNext = branchesBefore[distInt] + distBranch;

					assert(posNext < count);

					b.m_nextBranch = posNext;

					assert(v[posNext].m_nextBranch == (std::numeric_limits<uint>::max)());</uint>

					v[posNext].m_nextBranch = count;

				} else

					b.m_nextBranch = (std::numeric_limits<uint>::max)();</uint>

			}

			count++;

		}

	}

//for (UINT i=0; i

//  assert(v[i].m_nextBranch != std::numeric_limits<uint>::max());</uint>

#ifdef _DEBUG

/*ofstream of("C:\\temp\\fillDataOut.txt");

for (UINT ii=0; ii

  {

  of<

  of<<"index:"<

  of<<"w:"<

  of<<"curr inter:"<

  of<<"next inter:"<

  of<<"gettingOut:"<<((v[ii].m_gettingOut)?"TRUE":"FALSE")<

  of<<"colorId:"<

  }*/

#endif

	return size;

}

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

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

namespace

{

TStroke *reconstructAutocloseStroke(list<intersection> &intList,</intersection>

									list<intersection>::iterator it1,</intersection>

									list<intersectedstroke>::iterator it2)</intersectedstroke>

{

	bool found = false;

	list<intersection>::iterator iit1 = it1;</intersection>

	list<intersectedstroke>::iterator iit2;</intersectedstroke>

	iit1++;

	//vector<tedge*> vapp;</tedge*>

	for (; !found && iit1 != intList.end(); iit1++) {

		for (iit2 = iit1->m_strokeList.begin(); !found && iit2 != iit1->m_strokeList.end(); iit2++) {

			if (it2->m_edge.m_index == iit2->m_edge.m_index) {

				if ((iit2->m_edge.m_w0 == 1 && it2->m_edge.m_w0 == 0) ||

					(iit2->m_edge.m_w0 == 0 && it2->m_edge.m_w0 == 1)) {

					found = true;

					vector<tpointd> v;</tpointd>

					if (it2->m_edge.m_w0 == 0) {

						v.push_back(it1->m_intersection);

						v.push_back(iit1->m_intersection);

					} else {

						v.push_back(iit1->m_intersection);

						v.push_back(it1->m_intersection);

					}

					it2->m_edge.m_s = iit2->m_edge.m_s = new TStroke(v);

					//for (UINT ii=0; ii

					// vapp[ii]->m_s = it2->m_edge.m_s;

				}

				//else if (iit2->m_edge.m_w0!=0 && iit2->m_edge.m_w0!=1)

				//  vapp.push_back(&(iit2->m_edge));

			}

		}

	}

	assert(found);

	if (!found)

		it2->m_edge.m_s = 0;

	return it2->m_edge.m_s;

}

} //namespace

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

void TVectorImage::Imp::setFillData(IntersectionBranch *v, UINT branchCount)

{

#ifdef _DEBUG

/*ofstream of("C:\\temp\\fillDataIn.txt");

for (UINT ii=0; ii

  {

  of<

  of<<"index:"<

  of<<"w:"<

  of<<"curr inter:"<

  of<<"next inter:"<

  of<<"gettingOut:"<<((v[ii].m_gettingOut)?"TRUE":"FALSE")<

  of<<"colorId:"<

  }*/

#endif

	if (branchCount == 0)

		return;

	list<intersection> &intList = m_intersectionData.m_intList;</intersection>

	clearPointerContainer(m_regions);

	m_regions.clear();

	intList.clear();

	list<intersection>::iterator currInt;</intersection>

	list<intersectedstroke>::iterator currBranch;</intersectedstroke>

	vector<uint> branchesBefore(v[branchCount - 1].m_currInter + 1);</uint>

	UINT i = 0;

	for (; i < branchCount; i++) {

		const IntersectionBranch &b = v[i];

		if (i == 0 || v[i].m_currInter != v[i - 1].m_currInter) {

			assert(i == 0 || v[i].m_currInter == v[i - 1].m_currInter + 1);

			branchesBefore[v[i].m_currInter] = i;

			intList.push_back(Intersection());

			currInt = intList.begin();

			advance(currInt, intList.size() - 1);

		}

		IntersectedStroke is;

		currInt->m_strokeList.push_back(is);

		currBranch = currInt->m_strokeList.begin();

		advance(currBranch, currInt->m_strokeList.size() - 1);

		currBranch->m_edge.m_styleId = b.m_style;

		//assert(b.m_style<100);

		currBranch->m_edge.m_index = b.m_strokeIndex;

		if (b.m_strokeIndex >= 0)

			currBranch->m_edge.m_s = m_strokes[b.m_strokeIndex]->m_s;

		else

			currBranch->m_edge.m_s = 0;

		currBranch->m_gettingOut = b.m_gettingOut;

		currBranch->m_edge.m_w0 = b.m_w;

		currBranch->m_edge.m_w1 = v[b.m_nextBranch].m_w;

		assert(currBranch->m_edge.m_w0 >= -1e-8 && currBranch->m_edge.m_w0 <= 1 + 1e-8);

		assert(currBranch->m_edge.m_w1 >= -1e-8 && currBranch->m_edge.m_w1 <= 1 + 1e-8);

		if (b.m_nextBranch < i) {

			list<intersection>::iterator it1;</intersection>

			list<intersectedstroke>::iterator it2;</intersectedstroke>

			it1 = intList.begin();

			std::advance(it1, v[b.m_nextBranch].m_currInter);

			it2 = it1->m_strokeList.begin();

			assert(b.m_nextBranch - branchesBefore[v[b.m_nextBranch].m_currInter] >= 0);

			std::advance(it2, b.m_nextBranch - branchesBefore[v[b.m_nextBranch].m_currInter]);

			currBranch->m_nextIntersection = it1;

			currBranch->m_nextStroke = it2;

			it2->m_nextIntersection = currInt;

			it2->m_nextStroke = currBranch;

			//if (currBranch == currInt->m_strokeList.begin())

			//  currInt->m_intersection = currBranch->m_edge.m_s->getPoint(currBranch->m_edge.m_w0);

			currInt->m_numInter++;

			it1->m_numInter++;

		} else if (b.m_nextBranch == i)

			currBranch->m_nextIntersection = intList.end();

		else if (b.m_nextBranch == (std::numeric_limits<uint>::max)()) {</uint>

			currBranch->m_nextIntersection = intList.end();

			currBranch->m_nextStroke = currInt->m_strokeList.end();

		}

		/* {

    assert(b.m_nextBranch

    assert(v[b.m_nextBranch].m_nextBranch==i);

    }*/

		if (i == branchCount - 1 || v[i].m_currInter != v[i + 1].m_currInter) {

			int j = i;

			while (v[j].m_strokeIndex < 0 && ((j > 0 && v[j].m_currInter == v[j - 1].m_currInter) || j == 0))

				j--;

			if (v[j].m_strokeIndex >= 0)

				currInt->m_intersection = m_strokes[v[j].m_strokeIndex]->m_s->getPoint(v[j].m_w);

		}

	}

	for (i = 0; i < m_strokes.size(); i++)

		m_strokes[i]->m_isNewForFill = false;

	//computeRegions();

	list<intersection>::iterator it1;</intersection>

	list<intersectedstroke>::iterator it2;</intersectedstroke>

	vector<uint> toBeDeleted;</uint>

	for (it1 = intList.begin(); it1 != intList.end(); it1++)

		for (it2 = it1->m_strokeList.begin(); it2 != it1->m_strokeList.end(); ++it2) {

			if (it2->m_edge.m_index < 0 && !it2->m_edge.m_s &&

				(it2->m_edge.m_w0 == 0 || it2->m_edge.m_w0 == 1)) {

				it2->m_edge.m_s = reconstructAutocloseStroke(intList, it1, it2);

				if (it2->m_edge.m_s)

					m_intersectionData.m_autocloseMap[it2->m_edge.m_index] = it2->m_edge.m_s;

				else

					toBeDeleted.push_back(it2->m_edge.m_index);

			}

		}

	for (it1 = intList.begin(); it1 != intList.end(); it1++)

		for (it2 = it1->m_strokeList.begin(); it2 != it1->m_strokeList.end(); ++it2) {

			if (!it2->m_edge.m_s && it2->m_edge.m_index < 0) {

				it2->m_edge.m_s = m_intersectionData.m_autocloseMap[it2->m_edge.m_index];

				//TEdge& e = it2->m_edge;

				if (!it2->m_edge.m_s)

					toBeDeleted.push_back(it2->m_edge.m_index);

			}

		}

	for (i = 0; i < toBeDeleted.size(); i++)

		eraseIntersection(toBeDeleted[i]);

	m_areValidRegions = false;

	computeRegions();

	//print(m_intersectionData.m_intList, "C:\\temp\\intersectionDopoLoad.txt");

}

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

void TVectorImage::Imp::eraseIntersection(int index)

{

	vector<int> autocloseStrokes;</int>

	doEraseIntersection(index, &autocloseStrokes);

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

		doEraseIntersection(autocloseStrokes[i]);

		assert(autocloseStrokes[i] < 0);

		m_intersectionData.m_autocloseMap.erase(autocloseStrokes[i]);

	}

}

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

void findNearestIntersection(list<intersection> &interList)</intersection>

{

	list<intersection>::iterator i1;</intersection>

	list<intersectedstroke>::iterator i2;</intersectedstroke>

	for (i1 = interList.begin(); i1 != interList.end(); i1++) {

		for (i2 = (*i1).m_strokeList.begin(); i2 != (*i1).m_strokeList.end(); i2++) {

			if ((*i2).m_nextIntersection != interList.end()) //already set

				continue;

			int versus = (i2->m_gettingOut) ? 1 : -1;

			double minDelta = (std::numeric_limits<double>::max)();</double>

			list<intersection>::iterator it1, it1Res;</intersection>

			list<intersectedstroke>::iterator it2, it2Res;</intersectedstroke>

			for (it1 = i1; it1 != interList.end(); ++it1) {

				if (it1 == i1)

					it2 = i2, it2++;

				else

					it2 = (*it1).m_strokeList.begin();

				for (; it2 != (*it1).m_strokeList.end(); ++it2) {

					if ((*it2).m_edge.m_index == i2->m_edge.m_index &&

						(*it2).m_gettingOut == !i2->m_gettingOut) {

						double delta = versus * (it2->m_edge.m_w0 - i2->m_edge.m_w0);

						if (delta > 0 && delta < minDelta) {

							it1Res = it1;

							it2Res = it2;

							minDelta = delta;

						}

					}

				}

			}

			if (minDelta != (std::numeric_limits<double>::max)()) {</double>

				(*it2Res).m_nextIntersection = i1;

				(*it2Res).m_nextStroke = i2;

				(*it2Res).m_edge.m_w1 = i2->m_edge.m_w0;

				(*i2).m_nextIntersection = it1Res;

				(*i2).m_nextStroke = it2Res;

				(*i2).m_edge.m_w1 = it2Res->m_edge.m_w0;

				i1->m_numInter++;

				it1Res->m_numInter++;

			}

		}

	}

}

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

void markDeadIntersections(list<intersection> &intList,</intersection>

						   list<intersection>::iterator it);</intersection>

//questa funzione "cuscinetto" serve perche crashava il compilatore in release!!!

void inline markDeadIntersectionsRic(list<intersection> &intList,</intersection>

									 list<intersection>::iterator it)</intersection>

{

	markDeadIntersections(intList, it);

}

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

void markDeadIntersections(list<intersection> &intList,</intersection>

						   list<intersection>::iterator it)</intersection>

{

	list<intersectedstroke>::iterator it1 = it->m_strokeList.begin();</intersectedstroke>

	if (it->m_numInter == 1) {

		while (it1->m_nextIntersection == intList.end())

			it1++;

		assert(it1 != it->m_strokeList.end());

		list<intersection>::iterator nextInt = it1->m_nextIntersection;</intersection>

		list<intersectedstroke>::iterator nextStroke = it1->m_nextStroke;</intersectedstroke>

		it->m_numInter = 0;

		it1->m_nextIntersection = intList.end();

		if (nextInt != intList.end() /*&& !nextStroke->m_dead*/) {

			nextInt->m_numInter--;

			nextStroke->m_nextIntersection = intList.end();

			markDeadIntersectionsRic(intList, nextInt);

		}

	} else if (it->m_numInter == 2) //intersezione finta (forse)

	{

		while (it1 != it->m_strokeList.end() && it1->m_nextIntersection == intList.end())

			it1++;

		assert(it1 != it->m_strokeList.end());

		list<intersectedstroke>::iterator it2 = it1;</intersectedstroke>

		it2++;

		while (it2 != it->m_strokeList.end() && it2->m_nextIntersection == intList.end())

			it2++;

		assert(it2 != it->m_strokeList.end());

		if (it1->m_edge.m_s == it2->m_edge.m_s && it1->m_edge.m_w0 == it2->m_edge.m_w0) //intersezione finta

		{

			list<intersectedstroke>::iterator iit1, iit2;</intersectedstroke>

			assert(it1->m_nextIntersection != intList.end() && it2->m_nextIntersection != intList.end());

			iit1 = it1->m_nextStroke;

			iit2 = it2->m_nextStroke;

			iit2->m_edge.m_w1 = iit1->m_edge.m_w0;

			iit1->m_edge.m_w1 = iit2->m_edge.m_w0;

			//if (iit1!=0)

			(*iit1).m_nextStroke = iit2;

			//if (iit2!=0)

			(*iit2).m_nextStroke = iit1;

			//if (iit1!=0)

			(*iit1).m_nextIntersection = it2->m_nextIntersection;

			//if (iit2!=0)

			(*iit2).m_nextIntersection = it1->m_nextIntersection;

			it->m_numInter = 0;

			it1->m_nextIntersection = intList.end();

			it2->m_nextIntersection = intList.end();

		}

	}

}

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

//se cross val era 0, cerco di spostarmi un po' su w per vedere come sono orientate le tangenti agli stroke...

double nearCrossVal(TStroke *s0, double w0, TStroke *s1, double w1)

{

	double ltot0 = s0->getLength();

	double ltot1 = s1->getLength();

	double dl = tmin(ltot1, ltot0) / 1000;

	double crossVal, dl0 = dl, dl1 = dl;

	TPointD p0, p1;

	int count = 0;

	if (w0 == 1.0)

		dl0 = -dl0;

	if (w1 == 1.0)

		dl1 = -dl1;

	double l0 = s0->getLength(w0) + dl0;

	double l1 = s1->getLength(w1) + dl1;

	do {

		p0 = s0->getSpeed(s0->getParameterAtLength(l0));

		p1 = s1->getSpeed(s1->getParameterAtLength(l1));

		crossVal = cross(p0, p1);

		l0 += dl0, l1 += dl1;

		count++;

	} while (areAlmostEqual(crossVal, 0.0) &&

			 ((dl0 > 0 && l0 < ltot0) || (dl0 < 0 && l0 > 0)) &&

			 ((dl1 > 0 && l1 < ltot1) || (dl1 < 0 && l1 > 0)));

	return crossVal;

}

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

inline void insertBranch(Intersection &interList, IntersectedStroke &item, bool gettingOut)

{

	if (item.m_edge.m_w0 != (gettingOut ? 1.0 : 0.0)) {

		item.m_gettingOut = gettingOut;

		interList.m_strokeList.push_back(item);

	}

}

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

double getAngle(const TPointD &p0, const TPointD &p1)

{

	double angle1 = 180 * atan2(p0.x, p0.y) / TConsts::pi;

	double angle2 = 180 * atan2(p1.x, p1.y) / TConsts::pi;

	if (angle1 < 0)

		angle1 = 360 + angle1;

	if (angle2 < 0)

		angle2 = 360 + angle2;

	return (angle2 - angle1) < 0 ? 360 + angle2 - angle1 : angle2 - angle1;

}

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

//nel caso l'angolo tra due stroke in un certo w sia nullo,

// si va un po' avanti per vedere come sono orientate....

double getNearAngle(const TStroke *s1, double w1, bool out1, const TStroke *s2, double w2, bool out2)

{

	bool verse1 = (out1 && w1 < 1) || (!out1 && w1 == 0);

	bool verse2 = (out2 && w2 < 1) || (!out2 && w2 == 0);

	double ltot1 = s1->getLength();

	double ltot2 = s2->getLength();

	double l1 = s1->getLength(w1);

	double l2 = s2->getLength(w2);

	double dl = min(ltot1, ltot2) / 1000;

	double dl1 = verse1 ? dl : -dl;

	double dl2 = verse2 ? dl : -dl;

	while (((verse1 && l1 < ltot1) || (!verse1 && l1 > 0)) && ((verse2 && l2 < ltot2) || (!verse2 && l2 > 0))) {

		l1 += dl1;

		l2 += dl2;

		TPointD p1 = (out1 ? 1 : -1) * s1->getSpeed(s1->getParameterAtLength(l1));

		TPointD p2 = (out2 ? 1 : -1) * s2->getSpeed(s2->getParameterAtLength(l2));

		double angle = getAngle(p1, p2);

		if (!areAlmostEqual(angle, 0, 1e-9))

			return angle;

	}

	return 0;

}

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

bool makeEdgeIntersection(Intersection &interList, IntersectedStroke &item1, IntersectedStroke &item2,

						  const TPointD &p1a, const TPointD &p1b, const TPointD &p2a, const TPointD &p2b)

{

	double angle1 = getAngle(p1a, p1b);

	double angle2 = getAngle(p1a, p2a);

	double angle3 = getAngle(p1a, p2b);

	double angle;

	bool eraseP1b = false, eraseP2a = false, eraseP2b = false;

	if (areAlmostEqual(angle1, 0, 1e-9)) {

		angle1 = getNearAngle(item1.m_edge.m_s, item1.m_edge.m_w0, true, item1.m_edge.m_s, item1.m_edge.m_w0, false);

		if (areAlmostEqual(angle1, 1e-9))

			eraseP1b = true;

	}

	if (areAlmostEqual(angle2, 0, 1e-9)) {

		angle2 = getNearAngle(item1.m_edge.m_s, item1.m_edge.m_w0, true, item2.m_edge.m_s, item2.m_edge.m_w0, true);

		if (areAlmostEqual(angle2, 1e-9))

			eraseP2a = true;

	}

	if (areAlmostEqual(angle3, 0, 1e-9)) {

		angle3 = getNearAngle(item1.m_edge.m_s, item1.m_edge.m_w0, true, item2.m_edge.m_s, item2.m_edge.m_w0, false);

		if (areAlmostEqual(angle3, 1e-9))

			eraseP2b = true;

	}

	if (areAlmostEqual(angle1, angle2, 1e-9)) {

		angle = getNearAngle(item1.m_edge.m_s, item1.m_edge.m_w0, false, item2.m_edge.m_s, item2.m_edge.m_w0, true);