//#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 "tthreadmessage.h"

#include "tl2lautocloser.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) * ((TINT32)(x * REGION_COMPUTING_PRECISION));

}

inline TThickPoint myRound(const TThickPoint &p)

{

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

}

void roundStroke(TStroke *s)

{

	int size = s->getControlPointCount();

	for (int j = 0; j < (int)s->getControlPointCount(); j++) {

		TThickPoint p = s->getControlPoint(j);

		s->setControlPoint(j, myRound(p));

	}

	if (size > 3)

	//! it can happen that a stroke has a first or last quadratic degenerated:(3 equal control points).

	// in that case, if the stroke has an intersection in an endpoint, the resulting w could not be  0 or 1 as expected.

	// since the w==0 and w==1 are used in the region computing to determine if the intersection is an endpoint,

	//

	{

		if (s->getControlPoint(0) == s->getControlPoint(1) && s->getControlPoint(0) == s->getControlPoint(2)) {

			s->setControlPoint(2, s->getControlPoint(3));

			s->setControlPoint(1, s->getControlPoint(3));

		}

		if (s->getControlPoint(size - 1) == s->getControlPoint(size - 2) && s->getControlPoint(size - 1) == s->getControlPoint(size - 3)) {

			s->setControlPoint(size - 2, s->getControlPoint(size - 4));

			s->setControlPoint(size - 3, s->getControlPoint(size - 4));

		}

	}

}

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

class VIListElem

{

public:

	VIListElem *m_prev;

	VIListElem *m_next;

	VIListElem() : m_prev(0), m_next(0) {}

	inline VIListElem *next() { return m_next; }

	inline VIListElem *prev() { return m_prev; }

};

template <class t=""></class>

class VIList

{

	int m_size;

	T *m_begin, *m_end;

public:

	VIList() : m_begin(0), m_end(0), m_size(0) {}

	inline T *first() const { return m_begin; };

	inline T *last() const { return m_end; };

	void clear();

	void pushBack(T *elem);

	void insert(T *before, T *elem);

	T *erase(T *element);

	T *getElemAt(int pos);

	int getPosOf(T *elem);

	inline int size() { return m_size; }

	inline bool empty() { return size() == 0; }

};

class Intersection : public VIListElem

{

public:

	//Intersection* m_prev, *m_next;

	TPointD m_intersection;

	int m_numInter;

	//bool m_isNotErasable;

	VIList<intersectedstroke> m_strokeList;</intersectedstroke>

	Intersection() : m_numInter(0), m_strokeList() {}

	inline Intersection *next() { return (Intersection *)VIListElem::next(); };

	inline Intersection *prev() { return (Intersection *)VIListElem::prev(); };

	//inline Intersection* operator++() {return next();}

};

class IntersectedStrokeEdges

{

public:

	int m_index;

	list<tedge *=""> m_edgeList;</tedge>

	IntersectedStrokeEdges(int index) : m_index(index), m_edgeList() {}

	~IntersectedStrokeEdges()

	{

		assert(m_index >= 0); /*clearPointerContainer(m_edgeList);*/

		m_edgeList.clear();

		m_index = -1;

	}

};

class IntersectionData

{

public:

	UINT maxAutocloseId;

	VIList<intersection> m_intList;</intersection>

	map<int, *="" vistroke=""> m_autocloseMap;</int,>

	vector<intersectedstrokeedges> m_intersectedStrokeArray;</intersectedstrokeedges>

	IntersectionData()

		: maxAutocloseId(1), m_intList()

	{

	}

	~IntersectionData();

};

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

class IntersectedStroke : public VIListElem

{

	/*double m_w;

TStroke *m_s;

UINT m_index;*/

	//IntersectedStroke* m_prev, *m_next;

public:

	TEdge m_edge;

	Intersection *m_nextIntersection;

	IntersectedStroke *m_nextStroke;

	bool m_visited, m_gettingOut; //, m_dead;

	IntersectedStroke()

		: m_visited(false), m_nextIntersection(0), m_nextStroke(0){};

	IntersectedStroke(Intersection *nextIntersection,

					  IntersectedStroke *nextStroke)

		/*: m_w(-1.0)

	 , m_s(NULL)

	 , m_index(0)*/

		: m_edge(),

		  m_nextIntersection(nextIntersection),

		  m_nextStroke(nextStroke),

		  m_visited(false)

	//, m_dead(false)

	{

	}

	IntersectedStroke(const IntersectedStroke &s)

		: m_edge(s.m_edge, false), m_nextIntersection(s.m_nextIntersection), m_nextStroke(s.m_nextStroke), m_visited(s.m_visited), m_gettingOut(s.m_gettingOut)

	//, m_dead(s.m_dead)

	{

	}

	inline IntersectedStroke *next() { return (IntersectedStroke *)VIListElem::next(); };

};

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

template <class t=""></class>

void VIList<t>::clear()</t>

{

	while (m_begin) {

		T *aux = m_begin;

		m_begin = m_begin->next();

		delete aux;

	}

	m_end = 0;

	m_size = 0;

}

template <class t=""></class>

void VIList<t>::pushBack(T *elem)</t>

{

	if (!m_begin) {

		assert(!m_end);

		elem->m_next = elem->m_prev = 0;

		m_begin = m_end = elem;

	} else {

		assert(m_end);

		assert(m_end->m_next == 0);

		m_end->m_next = elem;

		elem->m_prev = m_end;

		elem->m_next = 0;

		m_end = elem;

	}

	m_size++;

}

template <class t=""></class>

void VIList<t>::insert(T *before, T *elem)</t>

{

	assert(before && elem);

	elem->m_prev = before->m_prev;

	elem->m_next = before;

	if (!before->m_prev)

		before->m_prev = m_begin = elem;

	else {

		before->m_prev->m_next = elem;

		before->m_prev = elem;

	}

	m_size++;

}

template <class t=""></class>

T *VIList<t>::erase(T *element)</t>

{

	T *ret;

	assert(m_size > 0);

	if (!element->m_prev) {

		assert(m_begin == element);

		if (!element->m_next)

			ret = m_begin = m_end = 0;

		else {

			m_begin = (T *)m_begin->m_next;

			m_begin->m_prev = 0;

			ret = m_begin;

		}

	} else if (!element->m_next) {

		assert(m_end == element);

		m_end = (T *)m_end->m_prev;

		m_end->m_next = 0;

		ret = 0;

	} else {

		element->m_prev->m_next = element->m_next;

		element->m_next->m_prev = element->m_prev;

		ret = (T *)element->m_next;

	}

	m_size--;

	delete element;

	return ret;

}

template <class t=""></class>

T *VIList<t>::getElemAt(int pos)</t>

{

	assert(pos < m_size);

	T *p = m_begin;

	while (pos--)

		p = p->next();

	return p;

}

template <class t=""></class>

int VIList<t>::getPosOf(T *elem)</t>

{

	int count = 0;

	T *p = m_begin;

	while (p && p != elem) {

		count++;

		p = p->next();

	}

	assert(p == elem);

	return count;

}

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

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

#ifdef LEVO

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;

		}

	}

}

#endif

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, bool isVectorized);</doublepair></vistroke>

void addIntersection(IntersectionData &intData,

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

					 DoublePair intersections, int strokeSize, bool isVectorized);

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

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

{

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

}

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

void cleanIntersectionMarks(const VIList<intersection> &interList)</intersection>

{

	Intersection *p;

	IntersectedStroke *q;

	for (p = interList.first(); p; p = p->next())

		for (q = p->m_strokeList.first(); q; q = q->next()) {

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

								  // di poter essere visitato

			if (q->m_nextIntersection) {

				q->m_nextIntersection = 0;

				p->m_numInter--;

			}

		}

}

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

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

{

	Intersection *p;

	IntersectedStroke *q;

	for (p = interList.first(); p; p = p->next())

		for (q = p->m_strokeList.first(); q; q = q->next())

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

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

				//  return; //gia' ripulita prima

				if (q->m_nextIntersection) {

					q->m_nextIntersection = 0;

					p->m_numInter--;

				}

				q->m_nextStroke = 0;

			}

}

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

void TVectorImage::Imp::eraseEdgeFromStroke(IntersectedStroke *is)

{

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

	{

		VIStroke *s;

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

		assert(s->m_s == is->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 == is->m_edge.m_w0 && (*iit)->m_w1 == is->m_edge.m_w1) {

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

				s->m_edgeList.erase(iit);

				return;

			}

	}

}

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

IntersectedStroke *TVectorImage::Imp::eraseBranch(Intersection *in,

												  IntersectedStroke *is)

{

	if (is->m_nextIntersection) {

		Intersection *nextInt = is->m_nextIntersection;

		IntersectedStroke *nextStroke = is->m_nextStroke;

		assert(nextStroke->m_nextIntersection == in);

		assert(nextStroke->m_nextStroke == is);

		assert(nextStroke != is);

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

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

		if (nextStroke->m_nextIntersection) {

			nextStroke->m_nextIntersection = 0;

			nextInt->m_numInter--;

		}

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

	}

	if (is->m_nextIntersection)

		in->m_numInter--;

	eraseEdgeFromStroke(is);

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

	is->m_edge.m_index = -3;

	is->m_edge.m_s = 0;

	is->m_edge.m_styleId = -3;

	return in->m_strokeList.erase(is);

}

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

void TVectorImage::Imp::eraseDeadIntersections()

{

	Intersection *p = m_intersectionData->m_intList.first();

	while (p) //la faccio qui, e non nella eraseIntersection. vedi commento li'.

	{

		//Intersection* &intList = m_intersectionData->m_intList;

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

			eraseBranch(p, p->m_strokeList.first());

			assert(p->m_strokeList.size() == 0);

			p = m_intersectionData->m_intList.erase(p);

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

				   (p->m_strokeList.first()->m_edge.m_s == p->m_strokeList.last()->m_edge.m_s &&

					p->m_strokeList.first()->m_edge.m_w0 == p->m_strokeList.last()->m_edge.m_w0)) //intersezione finta

		{

			IntersectedStroke *it1 = p->m_strokeList.first(), *iit1, *iit2;

			IntersectedStroke *it2 = it1->next();

			eraseEdgeFromStroke(p->m_strokeList.first());

			eraseEdgeFromStroke(p->m_strokeList.first()->next());

			iit1 = (it1->m_nextIntersection) ? it1->m_nextStroke : 0;

			iit2 = (it2->m_nextIntersection) ? it2->m_nextStroke : 0;

			if (iit1 && iit2) {

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

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

			}

			if (iit1) {

				iit1->m_nextStroke = iit2;

				iit1->m_nextIntersection = it2->m_nextIntersection;

				if (!iit1->m_nextIntersection)

					it1->m_nextIntersection->m_numInter--;

			}

			if (iit2) {

				iit2->m_nextStroke = iit1;

				iit2->m_nextIntersection = it1->m_nextIntersection;

				if (!iit2->m_nextIntersection)

					it2->m_nextIntersection->m_numInter--;

			}

			p->m_strokeList.clear();

			p->m_numInter = 0;

			p = m_intersectionData->m_intList.erase(p);

		} else

			p = p->next();

	}

}

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

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

{

	Intersection *p1 = m_intersectionData->m_intList.first();

	TStroke *deleteIt = 0;

	while (p1) {

		bool removeAutocloses = false;

		IntersectedStroke *p2 = p1->m_strokeList.first();

		while (p2) {

			IntersectedStroke &is = *p2;

			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;

				p2 = eraseBranch(p1, p2);

			} else

				p2 = p2->next();

			//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 (p2 = p1->m_strokeList.first(); p2; p2 = p2->next())

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

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

		}

		if (p1->m_strokeList.empty())

			p1 = m_intersectionData->m_intList.erase(p1);

		else

			p1 = p1->next();

	}

	if (deleteIt)

		delete deleteIt;

}

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

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

{

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

	//Intersection* intList = m_intersectionData->m_intList;

	if (m_intersectionData->m_intList.empty())

		return 0;

	Intersection *p1;

	IntersectedStroke *p2;

	UINT currInt = 0;

	vector<uint> branchesBefore(m_intersectionData->m_intList.size() + 1);</uint>

	branchesBefore[0] = 0;

	UINT count = 0, size = 0;

	p1 = m_intersectionData->m_intList.first();

	for (; p1; p1 = p1->next(), currInt++) {

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

		size += strokeListSize;

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

	}

	v = new IntersectionBranch[size];

	currInt = 0;

	p1 = m_intersectionData->m_intList.first();

	for (; p1; p1 = p1->next(), currInt++) {

		UINT currBranch = 0;

		for (p2 = p1->m_strokeList.first(); p2; p2 = p2->next(), currBranch++) {

			IntersectionBranch &b = v[count];

			b.m_currInter = currInt;

			b.m_strokeIndex = p2->m_edge.m_index;

			b.m_w = p2->m_edge.m_w0;

			b.m_style = p2->m_edge.m_styleId;

			//assert(b.m_style<100);

			b.m_gettingOut = p2->m_gettingOut;

			if (!p2->m_nextIntersection)

				b.m_nextBranch = count;

			else {

				UINT distInt = m_intersectionData->m_intList.getPosOf(p2->m_nextIntersection);

				UINT distBranch = p2->m_nextIntersection->m_strokeList.getPosOf(p2->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(Intersection *p1,

									IntersectedStroke *p2)

{

	bool found = false;

	Intersection *pp1 = p1->next();

	IntersectedStroke *pp2;

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

	for (; !found && pp1; pp1 = pp1->next()) {

		for (pp2 = pp1->m_strokeList.first(); !found && pp2; pp2 = pp2->next()) {

			if (p2->m_edge.m_index == pp2->m_edge.m_index) {

				if ((pp2->m_edge.m_w0 == 1 && p2->m_edge.m_w0 == 0) ||

					(pp2->m_edge.m_w0 == 0 && p2->m_edge.m_w0 == 1)) {

					found = true;

					vector<tpointd> v;</tpointd>

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

						v.push_back(p1->m_intersection);

						v.push_back(pp1->m_intersection);

					} else {

						v.push_back(pp1->m_intersection);

						v.push_back(p1->m_intersection);

					}

					p2->m_edge.m_s = pp2->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)

		p2->m_edge.m_s = 0;

	return p2->m_edge.m_s;

}

} //namespace

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

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

{

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

	//{

	//QMutexLocker sl(m_mutex);

	VIList<intersection> &intList = m_intersectionData->m_intList;</intersection>

	clearPointerContainer(m_regions);

	m_regions.clear();

	intList.clear();

	Intersection *currInt;

	IntersectedStroke *currBranch;

	UINT size = v[branchCount - 1].m_currInter + 1;

	vector<uint> branchesBefore(size);</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) {

			if (v[i].m_currInter >= size) //pezza per immagine corrotte...evito crash

			{

				intList.clear();

				return;

			}

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

			currInt = new Intersection();

			intList.pushBack(currInt);

		}

		currBranch = new IntersectedStroke();

		currInt->m_strokeList.pushBack(currBranch);

		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;

		if (b.m_nextBranch < branchCount)

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

		else

			currBranch->m_edge.m_w1 = 1.0;

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

			Intersection *p1;

			IntersectedStroke *p2;

			p1 = intList.getElemAt(v[b.m_nextBranch].m_currInter);

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

			p2 = p1->m_strokeList.getElemAt(b.m_nextBranch - branchesBefore[v[b.m_nextBranch].m_currInter]);

			currBranch->m_nextIntersection = p1;

			currBranch->m_nextStroke = p2;

			p2->m_nextIntersection = currInt;

			p2->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++;

			p1->m_numInter++;

		} else if (b.m_nextBranch == i)

			currBranch->m_nextIntersection = 0;

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

			currBranch->m_nextIntersection = 0;

			currBranch->m_nextStroke = 0;

		}

		/* {

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

	Intersection *p1;

	IntersectedStroke *p2;

	vector<uint> toBeDeleted;</uint>

	for (p1 = intList.first(); p1; p1 = p1->next())

		for (p2 = p1->m_strokeList.first(); p2; p2 = p2->next()) {

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

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

				p2->m_edge.m_s = reconstructAutocloseStroke(p1, p2);

				if (p2->m_edge.m_s)

					m_intersectionData->m_autocloseMap[p2->m_edge.m_index] = new VIStroke(p2->m_edge.m_s, TGroupId());

				else

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

			}

		}

	for (p1 = intList.first(); p1; p1 = p1->next())

		for (p2 = p1->m_strokeList.first(); p2; p2 = p2->next()) {

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

				VIStroke *vs = m_intersectionData->m_autocloseMap[p2->m_edge.m_index];

				if (vs) {

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

					//TEdge& e = it2->m_edge;