//#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 "tcomputeregions.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);

}

static 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 final : 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 final : 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,</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>

                      bool isVectorized);

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

                     int ii, int jj, DoublePair intersections, int strokeSize,

                     bool isVectorized);

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

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

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

}

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

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

      }

    }

}

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

static void cleanNextIntersection(const VIList<intersection> &interList,</intersection>

                                  TStroke *s) {

  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 &&

      is->m_edge.m_index < m_strokes.size())  // 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(),</tedge>

                            it_e = s->m_edgeList.end();

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

	  m_intersectionData->m_autocloseMap.erase(index);

	  delete deleteIt;

  }

}

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

UINT TVectorImage::Imp::getFillData(std::unique_ptr<intersectionbranch[]> &v) {</intersectionbranch[]>

  // 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.reset(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(

    std::unique_ptr<intersectionbranch[]> const &v, UINT branchCount,</intersectionbranch[]>

    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

      {

        break;

      }

      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 && b.m_strokeIndex < m_strokes.size())

      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 && v[j].m_strokeIndex < m_strokes.size())

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