//#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,</intersection>

// UINT ii, double w);

void addIntersections(IntersectionData &intersectionData,

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

                      const vector<doublepair> &intersections, int numStrokes);</doublepair>

void addIntersection(IntersectionData &intData, const vector<vistroke *=""> &s,</vistroke>

                     int ii, int jj, 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();</intersection>

       it1 != interList.end(); it1++)

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

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

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

       it1 != interList.end(); it1++)

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

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

      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(),</tedge>

                            it_e = s->m_edgeList.end();

    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(</intersectedstroke>

    list<intersection>::iterator it1, list<intersectedstroke>::iterator it2) {</intersectedstroke></intersection>

  // 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,</intersectedstroke>

                                        iit2;

      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;