#include "toonz/tcenterlinevectorizer.h"

// TnzCore includes

#include "tsystem.h"

#include "tstopwatch.h"

#include "tpalette.h"

#include "trastercm.h"

#include "ttoonzimage.h"

#include "tregion.h"

#include "tstroke.h"

#include "trasterimage.h"

#include "tmathutil.h"

// tcg includes

#include "tcg/tcg_numeric_ops.h"

#include "tcg/tcg_function_types.h"

// STD includes

#include <cmath></cmath>

#include <functional></functional>

#undef DEBUG

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

struct ControlPoint {

  TStroke *m_stroke;

  int m_index;

  ControlPoint(TStroke *stroke, int index) : m_stroke(stroke), m_index(index) {}

  TPointD getPoint() const { return m_stroke->getControlPoint(m_index); }

  void setPoint(const TPointD &p) {

    TThickPoint point = m_stroke->getControlPoint(m_index);

    point.x           = p.x;

    point.y           = p.y;

    m_stroke->setControlPoint(m_index, point);

  }

};

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

class Node;

class DataPixel {

public:

  TPoint m_pos;

  int m_value;

  bool m_ink;

  Node *m_node;

  DataPixel() : m_value(0), m_ink(false), m_node(0) {}

};

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

#ifdef _WIN32

template class DV_EXPORT_API TSmartPointerT<trastert<datapixel>>;</trastert<datapixel>

#endif

typedef TRasterPT<datapixel> DataRasterP;</datapixel>

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

class Junction;

class Node {

public:

  Node *m_other;

  DataPixel *m_pixel;

  Node *m_prev, *m_next;

  Junction *m_junction;

#ifdef DEBUG

  bool m_flag;

#endif

  bool m_visited;

  Node()

      : m_pixel(0)

      , m_prev(0)

      , m_next(0)

      , m_junction(0)

      ,

#ifdef DEBUG

      m_flag(false)

      ,

#endif

      m_visited(false) {

  }

};

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

class ProtoStroke;

class Junction {

public:

  TThickPoint m_center;

  std::deque<node *=""> m_nodes;</node>

  int m_junctionOrder;

  std::vector<protostroke *=""> m_protoStrokes;</protostroke>

  bool m_locked;

  Junction()

      : m_center()

      , m_nodes()

      , m_junctionOrder(0)

      , m_protoStrokes()

      , m_locked(false) {}

  bool isConvex();

};

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

class ProtoStroke {

public:

  TPointD m_startDirection, m_endDirection;

  Junction *m_startJunction, *m_endJunction;

  std::deque<tthickpoint> m_points;</tthickpoint>

  ProtoStroke()

      : m_points()

      , m_startDirection()

      , m_endDirection()

      , m_startJunction(0)

      , m_endJunction(0) {}

  ProtoStroke(std::deque<tthickpoint>::iterator it_b,</tthickpoint>

              std::deque<tthickpoint>::iterator it_e)</tthickpoint>

      : m_points(it_b, it_e)

      , m_startDirection()

      , m_endDirection()

      , m_startJunction(0)

      , m_endJunction(0) {}

};

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

static double computeDistance2(Node *na, Node *nb) {

  assert(na->m_pixel);

  assert(nb->m_pixel);

  TPointD d = convert(na->m_pixel->m_pos - nb->m_pixel->m_pos);

  return d * d;

}

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

static void renormalizeImage(TVectorImage *vi) {

  int i, j;

  int n = vi->getStrokeCount();

  std::vector<controlpoint> points;</controlpoint>

  points.reserve(n * 2);

  for (i = 0; i < n; i++) {

    TStroke *stroke = vi->getStroke(i);

    int m           = stroke->getControlPointCount();

    if (m > 0) {

      if (m == 1)

        points.push_back(ControlPoint(stroke, 0));

      else {

        points.push_back(ControlPoint(stroke, 0));

        points.push_back(ControlPoint(stroke, m - 1));

      }

    }

  }

  int count = points.size();

  for (i = 0; i < count; i++) {

    ControlPoint &pi = points[i];

    TPointD posi     = pi.getPoint();

    TPointD center   = posi;

    std::vector<int> neighbours;</int>

    neighbours.push_back(i);

    for (j = i + 1; j < count; j++) {

      TPointD posj = points[j].getPoint();

      double d     = tdistance(posj, posi);

      if (d < 0.01) {

        neighbours.push_back(j);

        center += posj;

      }

    }

    int m = neighbours.size();

    if (m == 1) continue;

    center = center * (1.0 / m);

    for (j = 0; j < m; j++) points[neighbours[j]].setPoint(center);

  }

}

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

class OutlineVectorizer {

  TPalette *m_palette;

public:

  TRasterP m_src;

  OutlineConfiguration m_configuration;

  DataRasterP m_dataRaster;

  std::vector<std::pair<int, datarasterp="">> m_dataRasterArray;</std::pair<int,>

  TVectorImageP m_vimage;

  std::vector<node *=""> m_nodes;</node>

  std::list<std::vector<tthickpoint>> m_protoOutlines;</std::vector<tthickpoint>

  std::vector<junction *=""> m_junctions;</junction>

  OutlineVectorizer(const OutlineConfiguration &configuration,

                    TPalette *palette)

      : m_configuration(configuration), m_palette(palette) {}

  ~OutlineVectorizer();

  void traceOutline(Node *initialNode);

  void createOutlineStrokes();

  void makeDataRaster(const TRasterP &src);

  Node *findOtherSide(Node *node);

  void clearNodes();

  Node *createNode(DataPixel *pix);

  void clearJunctions();

  void init();

  void link(DataPixel *pix, DataPixel *from, DataPixel *to);

  TPoint computeGradient(DataPixel *pix) {

    assert(m_dataRaster);

    const int wrap = m_dataRaster->getWrap();

    TPoint g(0, 0);

    int n, s, w, e, nw, sw, ne, se;

    w  = pix[-1].m_value;

    nw = pix[-1 + wrap].m_value;

    sw = pix[-1 - wrap].m_value;

    e  = pix[+1].m_value;

    ne = pix[+1 + wrap].m_value;

    se = pix[+1 - wrap].m_value;

    n = pix[+wrap].m_value;

    s = pix[-wrap].m_value;

    g.y = -sw + ne - se + nw + 2 * (n - s);

    g.x = -sw + ne + se - nw + 2 * (e - w);

    return g;

  }

private:

  // not implemented

  OutlineVectorizer(const OutlineVectorizer &);

  OutlineVectorizer &operator=(const OutlineVectorizer &);

};

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

OutlineVectorizer::~OutlineVectorizer() {

  m_protoOutlines.clear();

  clearNodes();

  clearJunctions();

}

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

void OutlineVectorizer::init() {

  int y;

  DataRasterP dataRaster = m_dataRaster;

  const int wrap         = dataRaster->getWrap();

  const int delta[]      = {-wrap - 1, -wrap, -wrap + 1, 1,

                       wrap + 1,  wrap,  wrap - 1,  -1};

  for (y = 1; y < dataRaster->getLy() - 1; y++) {

    DataPixel *pix    = dataRaster->pixels(y);

    DataPixel *endPix = pix + dataRaster->getLx() - 1;

    pix++;

    for (pix++; pix < endPix; ++pix) {

      if ((pix->m_ink == false) || (pix[-wrap].m_ink && pix[wrap].m_ink &&

                                    pix[-1].m_ink && pix[1].m_ink))

        continue;

      int i;

      for (i = 0; i < 8; i++)

        if (pix[delta[i]].m_ink && pix[delta[(i + 1) & 0x7]].m_ink == false)

          break;

      int start = i;

      if (i == 8) continue;  // punto isolato

      for (;;) {

        int j = (i + 1) & 0x7;

        assert(i < 8 && pix[delta[i]].m_ink);

        assert(j < 8 && pix[delta[j]].m_ink == false);

        do

          j = (j + 1) & 0x7;

        while (pix[delta[j]].m_ink == false);

        assert(j < 8 && pix[delta[j]].m_ink);

        if (((i + 2) & 0x7) != j || (i & 1) == 0) {

          // il bianco comprende anche un fianco

          link(pix, pix + delta[i], pix + delta[j]);

        }

        i = j;

        assert(i < 8);

        while (pix[delta[(i + 1) & 0x7]].m_ink) i = (i + 1) & 0x7;

        assert(i < 8 && pix[delta[i]].m_ink);

        assert(pix[delta[(i + 1) & 0x7]].m_ink == false);

        if (i == start) break;

      }

    }

  }

}

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

Node *OutlineVectorizer::createNode(DataPixel *pix) {

  Node *node    = new Node();

  node->m_pixel = pix;

  node->m_other = pix->m_node;

  pix->m_node   = node;

  m_nodes.push_back(node);

  return node;

}

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

void OutlineVectorizer::clearNodes() {

  int i;

  for (i = 0; i < (int)m_nodes.size(); i++) delete m_nodes[i];

  m_nodes.clear();

}

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

void OutlineVectorizer::clearJunctions() {

  int i;

  for (i = 0; i < (int)m_junctions.size(); i++) delete m_junctions[i];

  m_junctions.clear();

}

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

void OutlineVectorizer::link(DataPixel *pix, DataPixel *srcPix,

                             DataPixel *dstPix) {

  Node *srcNode = 0, *dstNode = 0, *node = 0;

  Node *tmp;

  for (tmp = pix->m_node; tmp; tmp = tmp->m_other) {

    if (tmp->m_pixel == 0) continue;

    if (tmp->m_prev && tmp->m_prev->m_pixel == srcPix) {

      assert(srcNode == 0);

      if (node) {

        assert(node->m_next->m_pixel == dstPix);

        assert(node->m_prev == 0);

        node->m_prev        = tmp->m_prev;

        tmp->m_prev->m_next = node;

        tmp->m_next = tmp->m_prev = 0;

        tmp->m_pixel              = 0;

        return;

      }

      assert(tmp->m_next == 0);

      srcNode = tmp->m_prev;

      node    = tmp;

    }

    if (tmp->m_next && tmp->m_next->m_pixel == dstPix) {

      assert(dstNode == 0);

      if (node) {

        assert(node->m_prev->m_pixel == srcPix);

        assert(node->m_next == 0);

        node->m_next        = tmp->m_next;

        tmp->m_next->m_prev = node;

        tmp->m_next = tmp->m_prev = 0;

        tmp->m_pixel              = 0;

        return;

      }

      assert(tmp->m_prev == 0);

      dstNode = tmp->m_next;

      node    = tmp;

    }

  }

  if (!node) node       = createNode(pix);

  if (!srcNode) srcNode = createNode(srcPix);

  if (!dstNode) dstNode = createNode(dstPix);

  if (!node->m_next) {

    node->m_next = dstNode;

    assert(dstNode->m_prev == 0);

    dstNode->m_prev = node;

  }

  if (!node->m_prev) {

    node->m_prev = srcNode;

    assert(srcNode->m_next == 0);

    srcNode->m_next = node;

  }

  assert(node->m_next == dstNode);

  assert(node->m_prev == srcNode);

  assert(dstNode->m_prev == node);

  assert(srcNode->m_next == node);

}

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

void OutlineVectorizer::traceOutline(Node *initialNode) {

  Node *startNode = initialNode;

  Node *node;

  do {

    if (!startNode) break;

    node = findOtherSide(startNode);

    if (!node) break;

    double startDist2 = computeDistance2(startNode, node);

    if (startDist2 > 0.1) break;

    startNode = startNode->m_next;

  } while (startNode != initialNode);

  if (!startNode) return;

  node = startNode;

  std::vector<tthickpoint> points;</tthickpoint>

  do {

    node = node->m_next;

    if (!node) break;

    node->m_visited = true;

    points.push_back(TThickPoint(convert(node->m_pixel->m_pos), 0));

  } while (node != startNode);

  m_protoOutlines.push_back(points);

}

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

Node *OutlineVectorizer::findOtherSide(Node *node) {

  DataPixel *pix = node->m_pixel;

  TPoint dir = -computeGradient(pix);

  if (dir == TPoint(0, 0)) return 0;

  TPoint d1(tsign(dir.x), 0), d2(0, tsign(dir.y));

  int num = abs(dir.y), den = abs(dir.x);

  if (num > den) {

    std::swap(d1, d2);

    std::swap(num, den);

  }

  TPoint pos = pix->m_pos;

  int i;

  for (i = 0;; i++) {

    TPoint q(pos.x + d1.x * i + d2.x * num * i / den,

             pos.y + d1.y * i + d2.y * num * i / den);

    DataPixel *nextPix = m_dataRaster->pixels(q.y) + q.x;

    if (nextPix->m_ink == false) break;

    pix = nextPix;

  }

  assert(pix);

  if (!pix->m_node) {

    const int wrap = m_dataRaster->getWrap();

    if (pix[-1].m_node)

      pix--;

    else if (pix[1].m_node)

      pix++;

    else if (pix[wrap].m_node)

      pix += wrap;

    else if (pix[-wrap].m_node)

      pix -= wrap;

    else {

      assert(0);

    }

  }

  if (!pix->m_node) return 0;

  Node *q                                 = pix->m_node;

  while (q->m_pixel == 0 && q->m_other) q = q->m_other;

  assert(q && q->m_pixel == pix);

  for (i = 0; i < 5; i++) {

    if (!q->m_prev) break;

    q = q->m_prev;

  }

  Node *best       = q;

  double bestDist2 = computeDistance2(q, node);

  for (i = 0; i < 10; i++) {

    q = q->m_next;

    if (!q) break;

    double dist2 = computeDistance2(q, node);

    if (dist2 < bestDist2) {

      bestDist2 = dist2;

      best      = q;

    }

  }

  return best;

}

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

void OutlineVectorizer::createOutlineStrokes() {

  m_vimage->enableRegionComputing(true, false);

  int j;

  for (j = 0; j < (int)m_nodes.size(); j++) {

    Node *node = m_nodes[j];

    if (node->m_pixel == 0 || node->m_visited) continue;

    traceOutline(node);

  }

#ifdef DEBUG

  for (j = 0; j < (int)m_nodes.size(); j++) {

    Node *node = m_nodes[j];

    if (node->m_pixel == 0 || node->m_flag) continue;

    outputNodes(node);

  }

#endif

  std::list<std::vector<tthickpoint>>::iterator it_outlines =</std::vector<tthickpoint>

      m_protoOutlines.begin();

  for (it_outlines; it_outlines != m_protoOutlines.end(); it_outlines++) {

    if (it_outlines->size() > 3) {

      std::vector<tthickpoint> points;</tthickpoint>

      std::vector<tthickpoint>::iterator it;</tthickpoint>

      if (it_outlines->size() > 10) {

        it = it_outlines->begin() + 1;

        for (;;) {

          // Baco: Ricontrolla l'if seguente - in alcuni casi va fuori bounds...

          if ((int)it_outlines->size() <= m_configuration.m_smoothness + 1)

            break;

          if (it >= it_outlines->end() - (m_configuration.m_smoothness + 1))

            break;

          for (j = 0; j < m_configuration.m_smoothness; j++)

            it = it_outlines->erase(it);

          ++it;

        }

      }

      points.push_back(it_outlines->front());

      it              = it_outlines->begin();

      TThickPoint old = *it;

      ++it;

      for (; it != it_outlines->end(); ++it) {

        TThickPoint point((1 / 2.0) * (*it + old));

        points.push_back(point);

        old = *it;

      }

      points.push_back(it_outlines->back());

      points.push_back(it_outlines->front());

      TStroke *stroke =

          TStroke::interpolate(points, m_configuration.m_interpolationError);

      stroke->setStyle(m_configuration.m_strokeStyleId);

      stroke->setSelfLoop();

      m_vimage->addStroke(stroke);

    }

  }

}

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

inline int colorDistance2(const TPixel32 &c0, const TPixel32 &c1) {

  return ((c0.r - c1.r) * (c0.r - c1.r) + (c0.g - c1.g) * (c0.g - c1.g) +

          (c0.b - c1.b) * (c0.b - c1.b));

}

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

#define MAX_TOLERANCE 20

#include "tcolorstyles.h"

void OutlineVectorizer::makeDataRaster(const TRasterP &src) {

  m_vimage = new TVectorImage();

  if (!src) return;

  m_src = src;

  clearNodes();

  clearJunctions();

  int x, y, ii = 0;

  TRaster32P srcRGBM = (TRaster32P)m_src;

  TRasterCM32P srcCM = (TRasterCM32P)m_src;

  TRasterGR8P srcGR  = (TRasterGR8P)m_src;

  // Inizializzo DataRasterP per i casi in cui si ha un TRaster32P, un

  // TRasterGR8P o un TRasterCM32P molto grande

  DataRasterP dataRaster(m_src->getSize().lx + 2, m_src->getSize().ly + 2);

  if (srcRGBM || srcGR ||

      (srcCM && srcCM->getLx() * srcCM->getLy() > 5000000)) {

    int ly              = dataRaster->getLy();

    int lx              = dataRaster->getLx();

    int wrap            = dataRaster->getWrap();

    DataPixel *dataPix0 = dataRaster->pixels(0);

    DataPixel *dataPix1 = dataRaster->pixels(0) + m_src->getLx() + 1;

    for (y = 0; y < ly; y++, dataPix0 += wrap, dataPix1 += wrap) {

      dataPix0->m_pos.x = 0;

      dataPix1->m_pos.x = lx - 1;

      dataPix0->m_pos.y = dataPix1->m_pos.y = y;

      dataPix0->m_value = dataPix1->m_value = 0;

      dataPix0->m_ink = dataPix1->m_ink = false;

      dataPix0->m_node = dataPix1->m_node = 0;

    }

    dataPix0 = dataRaster->pixels(0);

    dataPix1 = dataRaster->pixels(ly - 1);

    for (x = 0; x < lx; x++, dataPix0++, dataPix1++) {

      dataPix0->m_pos.x = dataPix1->m_pos.x = x;

      dataPix0->m_pos.y                     = 0;

      dataPix1->m_pos.y                     = ly - 1;

      dataPix0->m_value = dataPix1->m_value = 0;

      dataPix0->m_ink = dataPix1->m_ink = false;

      dataPix0->m_node = dataPix1->m_node = 0;

    }

  }

  if (srcRGBM) {

    assert(m_palette);

    int inkId = m_palette->getClosestStyle(m_configuration.m_inkColor);

    if (!inkId ||

        m_configuration.m_inkColor !=

            m_palette->getStyle(inkId)->getMainColor()) {

      inkId = m_palette->getStyleCount();

      m_palette->getStylePage(1)->insertStyle(1, m_configuration.m_inkColor);

      m_palette->setStyle(inkId, m_configuration.m_inkColor);

    }

    assert(inkId);

    m_dataRasterArray.push_back(std::pair<int, datarasterp="">(inkId, dataRaster));</int,>

    int maxDistance2 =

        m_configuration.m_threshold * m_configuration.m_threshold;

    for (y = 0; y < m_src->getLy(); y++) {

      TPixel32 *inPix    = srcRGBM->pixels(y);

      TPixel32 *inEndPix = inPix + srcRGBM->getLx();

      DataPixel *dataPix = dataRaster->pixels(y + 1) + 1;

      x                  = 0;

      while (inPix < inEndPix) {

        *dataPix      = DataPixel();

        int distance2 = colorDistance2(m_configuration.m_inkColor, *inPix);

        if (y == 0 || y == m_src->getLy() - 1 || x == 0 ||

            x == m_src->getLx() - 1 || inPix->m == 0) {

          dataPix->m_value = 255;

          dataPix->m_ink   = false;

        } else {

          dataPix->m_value = (inPix->r + 2 * inPix->g + inPix->b) >> 2;

          dataPix->m_ink   = (distance2 < maxDistance2);

        }

        dataPix->m_pos.x = x++;

        dataPix->m_pos.y = y;

        dataPix->m_node  = 0;

        inPix++;

        dataPix++;

      }

    }

  } else if (srcGR) {

    assert(m_palette);

    int inkId = m_palette->getClosestStyle(m_configuration.m_inkColor);

    if (!inkId ||

        m_configuration.m_inkColor !=

            m_palette->getStyle(inkId)->getMainColor()) {

      inkId = m_palette->getStyleCount();

      m_palette->getStylePage(1)->insertStyle(1, m_configuration.m_inkColor);

      m_palette->setStyle(inkId, m_configuration.m_inkColor);

    }

    assert(inkId);

    m_dataRasterArray.push_back(std::pair<int, datarasterp="">(inkId, dataRaster));</int,>

    int threshold = m_configuration.m_threshold;

    for (y = 0; y < m_src->getLy(); y++) {

      TPixelGR8 *inPix    = srcGR->pixels(y);

      TPixelGR8 *inEndPix = inPix + srcGR->getLx();

      DataPixel *dataPix  = dataRaster->pixels(y + 1) + 1;

      x                   = 0;

      while (inPix < inEndPix) {

        *dataPix = DataPixel();

        if (y == 0 || y == m_src->getLy() - 1 || x == 0 ||

            x == m_src->getLx() - 1) {

          dataPix->m_value = 255;

          dataPix->m_ink   = false;

        } else {

          dataPix->m_value = inPix->value;

          dataPix->m_ink   = (inPix->value < threshold);

        }

        dataPix->m_pos.x = x++;

        dataPix->m_pos.y = y;

        dataPix->m_node  = 0;

        inPix++;

        dataPix++;

      }

    }

  }

  else if (srcCM) {

    int currInk, nextInk = 0;

    if (srcCM->getLx() * srcCM->getLy() > 5000000) {

      int threshold = m_configuration.m_threshold;

      int inkId     = m_palette->getClosestStyle(TPixel::Black);

      if (TPixel::Black != m_palette->getStyle(inkId)->getMainColor()) {

        inkId = m_palette->getStyleCount();

        m_palette->getStylePage(1)->insertStyle(1, m_configuration.m_inkColor);

        m_palette->setStyle(inkId, m_configuration.m_inkColor);

      }

      assert(inkId);

      m_dataRasterArray.push_back(

          std::pair<int, datarasterp="">(inkId, dataRaster));</int,>

      // inizializza la parte centrale

      for (y = 0; y < m_src->getLy(); y++) {

        TPixelCM32 *inPix    = srcCM->pixels(y);

        TPixelCM32 *inEndPix = inPix + m_src->getLx();

        DataPixel *dataPix   = dataRaster->pixels(y + 1) + 1;

        x                    = 0;

        while (inPix < inEndPix) {

          *dataPix                                     = DataPixel();

          int value                                    = inPix->getTone();

          if (m_configuration.m_ignoreInkColors) inkId = 1;

          if (y == 0 || y == m_src->getLy() - 1 || x == 0 ||

              x == m_src->getLx() - 1) {

            dataPix->m_value = 255;

            dataPix->m_ink   = false;

          } else {

            dataPix->m_value = value;

            dataPix->m_ink   = (value < threshold);

          }

          dataPix->m_pos.x = x++;

          dataPix->m_pos.y = y;

          dataPix->m_node  = 0;

          inPix++;

          dataPix++;

        }

      }

    } else {

      do {

        // Inizializzo DataRasterP

        DataRasterP dataRaster(m_src->getSize().lx + 2,

                               m_src->getSize().ly + 2);

        int ly              = dataRaster->getLy();

        int lx              = dataRaster->getLx();

        int wrap            = dataRaster->getWrap();

        DataPixel *dataPix0 = dataRaster->pixels(0);

        DataPixel *dataPix1 = dataRaster->pixels(0) + m_src->getLx() + 1;

        for (y = 0; y < ly; y++, dataPix0 += wrap, dataPix1 += wrap) {

          dataPix0->m_pos.x = 0;

          dataPix1->m_pos.x = lx - 1;

          dataPix0->m_pos.y = dataPix1->m_pos.y = y;

          dataPix0->m_value = dataPix1->m_value = 0;

          dataPix0->m_ink = dataPix1->m_ink = false;

          dataPix0->m_node = dataPix1->m_node = 0;

        }

        dataPix0 = dataRaster->pixels(0);

        dataPix1 = dataRaster->pixels(ly - 1);

        for (x = 0; x < lx; x++, dataPix0++, dataPix1++) {

          dataPix0->m_pos.x = dataPix1->m_pos.x = x;

          dataPix0->m_pos.y                     = 0;

          dataPix1->m_pos.y                     = ly - 1;

          dataPix0->m_value = dataPix1->m_value = 0;

          dataPix0->m_ink = dataPix1->m_ink = false;

          dataPix0->m_node = dataPix1->m_node = 0;

        }

        int threshold =

            m_configuration.m_threshold;  // tolerance: 1->MAX thresh: 1-255

        currInk = nextInk;

        nextInk = 0;

        m_dataRasterArray.push_back(

            std::pair<int, datarasterp="">(currInk, dataRaster));</int,>

        // inizializza la parte centrale

        for (y = 0; y < m_src->getLy(); y++) {

          TPixelCM32 *inPix    = srcCM->pixels(y);

          TPixelCM32 *inEndPix = inPix + m_src->getLx();

          DataPixel *dataPix   = dataRaster->pixels(y + 1) + 1;

          x                    = 0;

          while (inPix < inEndPix) {

            *dataPix  = DataPixel();

            int value = inPix->getTone();

            if (value < 255 && !m_configuration.m_ignoreInkColors) {

              int ink = inPix->getInk();

              if (currInk == 0) {

                currInk                        = ink;

                m_dataRasterArray.back().first = ink;

              } else if (ink != currInk) {

                value = 255;

                if (nextInk == 0) {

                  for (ii = 0; ii < (int)m_dataRasterArray.size() - 1; ii++)

                    if (m_dataRasterArray[ii].first == ink) break;

                  if (ii == (int)m_dataRasterArray.size() - 1) nextInk = ink;

                }

              }

            }

            dataPix->m_pos.x = x++;

            dataPix->m_pos.y = y;

            dataPix->m_value = value;

            dataPix->m_ink   = (value < threshold);

            dataPix->m_node  = 0;

            inPix++;

            dataPix++;

          }

        }

      } while (nextInk != 0);

    }

    if (m_configuration.m_ignoreInkColors) {

      assert(m_dataRasterArray.size() == 1);

      m_dataRasterArray.back().first = 1;

    }

  } else

    assert(false);

}

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

TVectorImageP VectorizerCore::outlineVectorize(

    const TImageP &image, const OutlineConfiguration &configuration,

    TPalette *palette) {

  TVectorImageP out;

  OutlineVectorizer vectorizer(configuration, palette);

  TRasterImageP ri = image;

  TToonzImageP vi  = image;

  if (ri)

    vectorizer.makeDataRaster(ri->getRaster());

  else

    vectorizer.makeDataRaster(vi->getRaster());

  int layersCount = vectorizer.m_dataRasterArray.size();

  if (layersCount > 1) {

    out = new TVectorImage();

    out->setPalette(palette);

  }

  int i;

  for (i = 0; i < (int)layersCount; i++) {

    vectorizer.m_dataRaster = vectorizer.m_dataRasterArray[i].second;

    vectorizer.m_configuration.m_strokeStyleId =

        vectorizer.m_dataRasterArray[i].first;

    vectorizer.m_protoOutlines.clear();

    vectorizer.init();

    vectorizer.createOutlineStrokes();

    renormalizeImage(vectorizer.m_vimage.getPointer());

    vectorizer.m_vimage->setPalette(palette);

    if (layersCount > 1) out->mergeImage(vectorizer.m_vimage, TAffine());

    if (i != (int)layersCount - 1) vectorizer.m_vimage = new TVectorImage();

  }

  return (layersCount == 1) ? vectorizer.m_vimage : out;

}

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

static bool isPointInRegion(TPointD p, TRegion *r) {

  int i;

  for (i = 0; i < 5; i++) {

    double stepX = i * 0.2;

    int j;

    for (j = 0; j < 5; j++) {

      double stepY = j * 0.2;

      if (r->contains(TPointD(p.x + stepX, p.y + stepY))) return true;

    }

  }

  return false;

}

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

// Se findInk == true :

//    trova il punto piu' vicino a p con ink puro e restituisce true se e'

//    contenuto nella regione

// Se findInk == false :

//    Trova il punto piu' vicino a p con paint puro e restituisce true se e'

//    contenuto nella regione

//(Daniele) Aggiunti controlli per evitare uscite dai bounds

static bool isNearestInkOrPaintInRegion(bool findInk, const TRasterCM32P &ras,

                                        TRegion *r, const TAffine &aff,

                                        const TPoint &p) {

  bool isTheLastSquare = false;

  int mx, my, Mx, My;

  int i;

  for (i = 1; i <= 100; i++) {

    int j, t, s, e;

    if (p.x - i >= 0) {

      my = std::max(p.y - i, 0);

      My = std::min(p.y + i, ras->getLy() - 1);

      for (j = my; j <= My; j++) {

        TPixelCM32 col = ras->pixels(j)[p.x - i];

        int tone       = col.getTone();

        if ((findInk && tone == 0) || (!findInk && tone == 255)) {

          if (isPointInRegion(aff * TPointD(double(p.x - i), double(j)), r))

            return true;

          else

            isTheLastSquare = true;