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

};

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

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;

}

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

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;

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

	TVectorImageP m_vimage;

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

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

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

		tswap(d1, d2);

		tswap(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 = m_protoOutlines.begin();</std::vector<tthickpoint>

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

}

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

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