#include "tcenterlinevectP.h"

// tcg includes

#include "tcg/tcg_numeric_ops.h"

// Boost includes

#include <boost container="" flat_map.hpp=""></boost>

#include <boost algorithm="" minmax_element.hpp=""></boost>

namespace boost_c = boost::container;

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

//*************************

//*    Colors handling    *

//*************************

//Riassunto: Nel caso di normali raster, i tratti di penna sono colorati con

//l'elemento della palette data maggiormente tendente al nero.

//Per le Toonz colormap abilitiamo una gestione piu' complessa, che tiene

//conto del colore dell'inchiostro specificato direttamente nell'immagine.

//Nello specifico:

//  a) I tratti di penna vengono rilevati in base al valore del campo *tone*

//     di un TPixleCM32, non in base alla luminosita' del colore.

//     (vv. Poligonizzazione)

//  b) Sulle centerline grezze viene costruito un insieme di 'punti di assaggio'

//     dell'immagine; gli id di inchiostro rilevati vengono assegnati

//     direttamente alla stroke: se si verifica un cambio nell'id del colore,

//     il punto di cambio del colore viene identificato e la centerline viene

//     spezzata li'.

//  c) Una volta identificati i colori delle stroke, le si ordina *prima*

//     di inserirle nella vector image di output, in base al colore dell'immagine

//     ai loro estremi (attualmente ordinamento solo parziale).

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

TPixelCM32 pixel(const TRasterCM32 &ras, int x, int y)

{

	// Seems that raster access was not very much double-checked at the time

	// I wrote this. Too bad. Enforcing it now.

	return ras.pixels(tcrop(y, 0, ras.getLy() - 1))[tcrop(x, 0, ras.getLx() - 1)];

}

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

T3DPointD firstInkChangePosition(

	const TRasterCM32P &ras, const T3DPointD &start, const T3DPointD &end,

	int threshold)

{

	double dist = norm(end - start);

	int sampleMax = tceil(dist), sampleCount = sampleMax + 1;

	double sampleMaxD = double(sampleMax);

	// Get first ink color

	int s, color = -1;

	for (s = 0; s != sampleCount; ++s) {

		T3DPointD p = tcg::numeric_ops::lerp(start, end, s / sampleMaxD);

		const TPixelCM32 &pix = pixel(*ras, p.x, p.y);

		if (pix.getTone() < threshold) {

			color = pix.getInk();

			break;

		}

	}

	// Get second color

	for (; s != sampleCount; ++s) {

		T3DPointD p = tcg::numeric_ops::lerp(start, end, s / sampleMaxD);

		const TPixelCM32 &pix = pixel(*ras, p.x, p.y);

		if (pix.getTone() < threshold && pix.getInk() != color)

			break;

	}

	// Return middle position between s-1 and s

	if (s < sampleCount)

		return tcg::numeric_ops::lerp(start, end, (s - 0.5) / sampleMaxD);

	return TConsts::nap3d;

}

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

//Find color of input sequence. Will be copied to its equivalent stroke.

//Currently in use only on colormaps

//Riassunto: Per saggiare il colore da assegnare alle strokes e' meglio controllare

//le sequenze *prima* di convertirle in TStroke (visto che si perde parte dell'aderenza originale

//al tratto). Si specifica un numero di 'punti di assaggio' della spezzata equidistanti tra loro,

//su cui viene prelevato il valore dell'ink del pixel corrispondente. Se si identifica un cambio

//di colore, viene lanciata la procedura di spezzamento della sequenza: si identifica il punto

//di spezzamento, e la sequenza s viene bloccata li'; si costruisce una nuova sequenza newSeq e

//viene rilanciata sampleColor(ras,newSeq,sOpposite). Le sequenze tra due punti di spezzamento

//vengono inserite nel vector 'globals->singleSequences'.

//Nel caso di sequenze circolari c'e' una piccola modifica: il primo punto di spezzamento

//*ridefinisce solo* il nodo-raccordo di s, senza introdurre nuove sequenze.

//La sequenza sOpposite, 'inversa' di s, rimane e diventa 'forward-oriented' previo aggiornamento

//della coda.

//Osservare che i nodi di spezzamento vengono inseriti con la signature 'SAMPLECOLOR_SIGN'.

//NOTA: La struttura a grafo J-S 'superiore' non viene alterata qui dentro. Eventualm. da fare fuori.

void sampleColor(const TRasterCM32P &ras, int threshold, Sequence &seq, Sequence &seqOpposite,

				 SequenceList &singleSequences)

{

	SkeletonGraph *currGraph = seq.m_graphHolder;

	// Calculate sequence parametrization

	std::vector<unsigned int=""> nodes;</unsigned>

	std::vector<double> params;</double>

	// Meanwhile, ensure each point belong to ras. Otherwise, typically an error occured

	// in the thinning process and it's better avoid sampling procedure. Only exception, when

	// a point has x==ras->getLx() || y==ras->getLy(); that is accepted.

	{

		const T3DPointD &headPos = *currGraph->getNode(seq.m_head);

		if (!ras->getBounds().contains(TPoint(headPos.x, headPos.y))) {

			if (headPos.x < 0 || ras->getLx() < headPos.x ||

				headPos.y < 0 || ras->getLy() < headPos.y)

				return;

		}

	}

	unsigned int curr, currLink, next;

	double meanThickness = currGraph->getNode(seq.m_head)->z;

	params.push_back(0);

	nodes.push_back(seq.m_head);

	for (curr = seq.m_head, currLink = seq.m_headLink;

		 curr != seq.m_tail || params.size() == 1;

		 seq.next(curr, currLink)) {

		next = currGraph->getNode(curr).getLink(currLink).getNext();

		const T3DPointD &nextPos = *currGraph->getNode(next);

		if (!ras->getBounds().contains(TPoint(nextPos.x, nextPos.y))) {

			if (nextPos.x < 0 || ras->getLx() < nextPos.x ||

				nextPos.y < 0 || ras->getLy() < nextPos.y)

				return;

		}

		params.push_back(params.back() + tdistance(*currGraph->getNode(next), *currGraph->getNode(curr)));

		nodes.push_back(next);

		meanThickness += currGraph->getNode(next)->z;

	}

	meanThickness /= params.size();

	// Exclude 0-length sequences

	if (params.back() < 0.01) {

		seq.m_color = pixel(*ras, currGraph->getNode(seq.m_head)->x,

							currGraph->getNode(seq.m_head)->y)

						  .getInk();

		return;

	}

	// Prepare sampling procedure

	int paramCount = params.size(),

		paramMax = paramCount - 1;

	int sampleMax = std::max(params.back() / std::max(meanThickness, 1.0), 3.0), // Number of color samples depends on

		sampleCount = sampleMax + 1;									 // the ratio params.back() / meanThickness

	std::vector<double> sampleParams(sampleCount); // Sampling lengths</double>

	std::vector<tpoint> samplePoints(sampleCount); // Image points for color sampling</tpoint>

	std::vector<int> sampleSegments(sampleCount);  // Sequence segment index for the above</int>

	// Sample colors

	for (int s = 0, j = 0; s != sampleCount; ++s) {

		double samplePar = params.back() * (s / double(sampleMax));

		while (j != paramMax && params[j + 1] < samplePar) // params[j] < samplePar <= params[j+1]

			++j;

		double t = (samplePar - params[j]) / (params[j + 1] - params[j]);

		T3DPointD samplePoint(*currGraph->getNode(nodes[j]) * (1 - t) + *currGraph->getNode(nodes[j + 1]) * t);

		sampleParams[s] = samplePar;

		samplePoints[s] = TPoint(std::min(samplePoint.x, double(ras->getLx() - 1)),  // This deals with sample points at

								 std::min(samplePoint.y, double(ras->getLy() - 1))); // the top/right raster border

		sampleSegments[s] = j;

	}

	// NOTE: Extremities of a sequence are considered unreliable: they typically happen

	//       to be junction points shared between possibly different-colored strokes.

	// Find first and last extremity-free sampled points

	T3DPointD first(*currGraph->getNode(seq.m_head));

	T3DPointD last(*currGraph->getNode(seq.m_tail));

	int i, k;

	for (i = 1; params.back() * i / double(sampleMax) <= first.z && i < sampleCount; ++i)

		;

	for (k = sampleMax - 1; params.back() * (sampleMax - k) / double(sampleMax) <= last.z && k >= 0; --k)

		;

	// Give s the first sampled ink color found

	// Initialize with a last-resort reasonable color - not just 0

	seq.m_color = seqOpposite.m_color =

		ras->pixels(samplePoints[0].y)[samplePoints[0].x].getInk();

	int l;

	for (l = i - 1; l >= 0; --l) {

		if (ras->pixels(samplePoints[l].y)[samplePoints[l].x].getTone() < threshold) {

			seq.m_color = seqOpposite.m_color =

				ras->pixels(samplePoints[l].y)[samplePoints[l].x].getInk();

			break;

		}

	}

	// Then, look for the first reliable ink

	for (l = i; l <= k; ++l) {

		if (ras->pixels(samplePoints[l].y)[samplePoints[l].x].getTone() < threshold) {

			seq.m_color = seqOpposite.m_color =

				ras->pixels(samplePoints[l].y)[samplePoints[l].x].getInk();

			break;

		}

	}

	if (i >= k)

		goto _getOut; // No admissible segment found for splitting

					  // check.

	// Find color changes between sampled colors

	for (l = i; l < k; ++l) {

		const TPixelCM32 &nextSample = ras->pixels(samplePoints[l + 1].y)[samplePoints[l + 1].x],

						 &nextSample2 = ras->pixels(samplePoints[l + 2].y)[samplePoints[l + 2].x]; // l < k < sampleMax - so +2 is ok

		if (nextSample.getTone() < threshold && nextSample.getInk() != seq.m_color && nextSample2.getTone() < threshold && nextSample2.getInk() == nextSample.getInk()) // Ignore single-sample color changes

		{

			// Found a color change - apply splitting procedure

			// NOTE: The function RETURNS BEFORE THE FOR IS CONTINUED!

			int nextColor = nextSample.getInk();

			// Identify split segment

			int u;

			for (u = sampleSegments[l]; u < sampleSegments[l + 1]; ++u) {

				const TPixelCM32 &pix = pixel(*ras, currGraph->getNode(nodes[u + 1])->x,

											  currGraph->getNode(nodes[u + 1])->y);

				if (pix.getTone() < threshold && pix.getInk() != seq.m_color)

					break;

			}

			// Now u indicates the splitting segment. Search for splitting point by binary subdivision.

			const T3DPointD &nodeStartPos = *currGraph->getNode(nodes[u]),

							&nodeEndPos = *currGraph->getNode(nodes[u + 1]);

			T3DPointD splitPoint = firstInkChangePosition(ras, nodeStartPos, nodeEndPos, threshold);

			if (splitPoint == TConsts::nap3d)

				splitPoint = 0.5 * (nodeStartPos + nodeEndPos); // A color change was found, but could

																// not be precisely located. Just take

																// a reasonable representant.

			// Insert a corresponding new node in basic graph structure.

			unsigned int splitNode = currGraph->newNode(splitPoint);

			unsigned int nodesLink = currGraph->getNode(nodes[u]).linkOfNode(nodes[u + 1]);

			currGraph->insert(splitNode, nodes[u], nodesLink);

			*currGraph->node(splitNode).link(0) = *currGraph->getNode(nodes[u]).getLink(nodesLink);

			nodesLink = currGraph->getNode(nodes[u + 1]).linkOfNode(nodes[u]);

			currGraph->insert(splitNode, nodes[u + 1], nodesLink);

			*currGraph->node(splitNode).link(1) = *currGraph->getNode(nodes[u + 1]).getLink(nodesLink);

			currGraph->node(splitNode).setAttribute(SAMPLECOLOR_SIGN); // Sign all split-inserted nodes

			if (seq.m_head == seq.m_tail && currGraph->getNode(seq.m_head).getLinksCount() == 2 && !currGraph->getNode(seq.m_head).hasAttribute(SAMPLECOLOR_SIGN)) {

				// Circular case: we update s to splitNode and relaunch this very procedure on it.

				seq.m_head = seq.m_tail = splitNode;

				sampleColor(ras, threshold, seq, seqOpposite, singleSequences);

			} else {

				// Update upper (Joint-Sequence) graph data

				Sequence newSeq;

				newSeq.m_graphHolder = currGraph;

				newSeq.m_head = splitNode;

				newSeq.m_headLink = 0;

				newSeq.m_tail = seq.m_tail;

				newSeq.m_tailLink = seq.m_tailLink;

				seq.m_tail = splitNode;

				seq.m_tailLink = 1; // (link from splitNode to nodes[u] inserted for second by 'insert')

				seqOpposite.m_graphHolder = seq.m_graphHolder; // Inform that a split was found

				// NOTE: access on s terminates at newSeq's push_back, due to possible reallocation of globals->singleSequences

				if ((!(seq.m_head == newSeq.m_tail && currGraph->getNode(seq.m_head).getLinksCount() == 2)) && currGraph->getNode(seq.m_head).hasAttribute(SAMPLECOLOR_SIGN))

					singleSequences.push_back(seq);

				sampleColor(ras, threshold, newSeq, seqOpposite, singleSequences);

			}

			return;

		}

	}

_getOut:

	// Color changes not found (and therefore no newSeq got pushed back); if a split happened, update sOpposite.

	if (currGraph->getNode(seq.m_head).hasAttribute(SAMPLECOLOR_SIGN)) {

		seqOpposite.m_color = seq.m_color;

		seqOpposite.m_head = seq.m_tail;

		seqOpposite.m_headLink = seq.m_tailLink;

		seqOpposite.m_tail = seq.m_head;

		seqOpposite.m_tailLink = seq.m_headLink;

	}

}

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

//Take samples of image colors to associate each sequence to its corresponding

//palette color. Currently working on colormaps.

//void calculateSequenceColors(const TRasterP &ras)

void calculateSequenceColors(const TRasterP &ras, VectorizerCoreGlobals &g)

{

	int threshold = g.currConfig->m_threshold;

	SequenceList &singleSequences = g.singleSequences;

	JointSequenceGraphList &organizedGraphs = g.organizedGraphs;

	TRasterCM32P cm = ras;

	unsigned int i, j, k;

	int l;

	if (cm && g.currConfig->m_maxThickness > 0.0) {

		//singleSequence is traversed back-to-front because new, possibly splitted sequences

		//are inserted at back - and don't have to be re-sampled.

		for (l = singleSequences.size() - 1; l >= 0; --l) {

			Sequence rear;

			sampleColor(ras, threshold, singleSequences[l], rear, singleSequences);

			//If rear is built, a split occurred and the rear of this

			//single sequence has to be pushed back.

			if (rear.m_graphHolder)

				singleSequences.push_back(rear);

		}

		for (i = 0; i < organizedGraphs.size(); ++i)

			for (j = 0; j < organizedGraphs[i].getNodesCount(); ++j)

				if (!organizedGraphs[i].getNode(j).hasAttribute(JointSequenceGraph::ELIMINATED)) //due to junction recovery

					for (k = 0; k < organizedGraphs[i].getNode(j).getLinksCount(); ++k) {

						Sequence &s = *organizedGraphs[i].node(j).link(k);

						if (s.isForward() && !s.m_graphHolder->getNode(s.m_tail).hasAttribute(SAMPLECOLOR_SIGN)) {

							unsigned int next = organizedGraphs[i].node(j).link(k).getNext();

							unsigned int nextLink = organizedGraphs[i].tailLinkOf(j, k);

							Sequence &sOpposite = *organizedGraphs[i].node(next).link(nextLink);

							sampleColor(cm, threshold, s, sOpposite, singleSequences);

						}

					}

	}

}

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

inline void applyStrokeIndices(VectorizerCoreGlobals *globals)

{

	unsigned int i, j, k, n;

	unsigned int next, nextLink;

	for (i = 0; i < globals->singleSequences.size(); ++i)

		globals->singleSequences[i].m_strokeIndex = i;

	n = i;

	for (i = 0; i < globals->organizedGraphs.size(); ++i) {

		JointSequenceGraph *currJSGraph = &globals->organizedGraphs[i];

		for (j = 0; j < currJSGraph->getNodesCount(); ++j)

			if (!currJSGraph->getNode(j).hasAttribute(JointSequenceGraph::ELIMINATED))

				for (k = 0; k < currJSGraph->getNode(j).getLinksCount(); ++k) {

					Sequence &s = *currJSGraph->node(j).link(k);

					if (s.isForward()) {

						s.m_strokeIndex = n;

						if (!s.m_graphHolder->getNode(s.m_tail).hasAttribute(SAMPLECOLOR_SIGN)) {

							next = currJSGraph->getNode(j).getLink(k).getNext();

							nextLink = currJSGraph->tailLinkOf(j, k);

							currJSGraph->node(next).link(nextLink)->m_strokeIndex = n;

						}

						++n;

					}

				}

	}

}

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

//Riassunto: Dato un grafo superiore, possiamo associare ad ogni nodo il colore

//del pixel associato a quel punto; se una sequenza e' nascosta, ha entrambi

// i nodi agli estremi di colore diverso, viceversa per sequenze esposte.

//Data una sequenza, a partire dai nodi superiori adiacenti possiamo stabilire un

//insieme di sequenze che gli stanno sotto, ed uno di seq. che gli stanno sopra.

//NOTA: Questo problema e' un caso particolare di 'graph labeling', di cui non

//ho ancora trovato soluzione. In rete qualcosa si trova...

//La seguente funzione fa qualcosa di piu' debole: ad ogni joint ed ogni Sequence

//viene assegnata una altezza (intero). Dato un Joint, le sequenze che lo hanno

//per estremo e che hanno lo stesso colore dell'immagine in quella posizione hanno

//un'altezza +1 rispetto al giunto, e viceversa altezza -1. Partendo da

//un giunto iniziale, quest'informazione viene propagata sul grafo; il problema

//sta ritornando ai giunti gia' percorsi...

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

//Find predominant ink color in a circle of given radius and center

int getInkPredominance(const TRasterCM32P &ras, TPalette *palette, int x, int y, int radius, int threshold)

{

	int i, j;

	int mx, my, Mx, My;

	std::vector<int> inksFound(palette->getStyleCount());</int>

	radius = std::min(radius, 7); //Restrict radius for a minimum significative neighbour

	mx = std::max(x - radius, 0);

	my = std::max(y - radius, 0);

	Mx = std::min(x + radius, ras->getLx() - 1);

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

	//Check square grid around (x,y)

	for (i = mx; i <= Mx; ++i)

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

			if (sq(i) + sq(j) <= sq(radius) && ras->pixels(j)[i].getTone() < threshold) {

				//Update color table

				inksFound[ras->pixels(j)[i].getInk()] += 255 - ras->pixels(j)[i].getTone();

			}

	//return the most found ink

	int maxCount = 0, mostFound = 0;

	for (i = 0; i < (int)inksFound.size(); ++i)

		if (inksFound[i] > maxCount) {

			maxCount = inksFound[i];

			mostFound = i;

		}

	return mostFound;

}

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

/*!

  \brief    Find the predominant color in sequences adjacent to the

            input graph node.

  \return   The predominant branch color if found, \p -1 otherwise.

*/

int getBranchPredominance(const TRasterCM32P &ras, TPalette *palette, JointSequenceGraph::Node &node)

{

	struct locals {

		static inline bool valueLess(

			const std::pair<int, int=""> &a, const std::pair<int, int=""> &b)</int,></int,>

		{

			return (a.second < b.second);

		}

	};

	boost_c::flat_map<int, int=""> branchInksHistogram;</int,>

	UINT l, lCount = node.getLinksCount();

	for (l = 0; l != lCount; ++l) {

		int color = node.getLink(l)->m_color;

		if (color >= 0 && color <= palette->getStyleCount())

			++branchInksHistogram[color];

	}

	// Return the most found ink, or -1 if a predominance color could not be found

	if (branchInksHistogram.empty())

		return -1;

	typedef boost_c::flat_map<int, int="">::iterator histo_it;</int,>

	const std::pair<histo_it, histo_it=""> &histoRange =</histo_it,>

		boost::minmax_element(branchInksHistogram.begin(), branchInksHistogram.end(),

							  locals::valueLess);

	return (histoRange.first->second == histoRange.second->second) ? -1 : histoRange.second->first;

}

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

//NOTA: Da implementare una versione in grado di ordinare *pienamente* la vector image.

void sortJS(JointSequenceGraph *js, std::vector<std::pair<int, *="" tstroke="">> &toOrder,</std::pair<int,>

			const TRasterCM32P &ras, TPalette *palette)

{

	enum { SORTED = 0x10 };

	std::vector<std::pair<unsigned int="" int,="">> nodesToDo;</std::pair<unsigned>

	unsigned int currNodeIdx, nextNodeIdx;

	int currColor, currHeight, nextColor, nextHeight;

	T3DPointD pD;

	TPoint p;

	SkeletonGraph *currGraph = js->getNode(0).getLink(0)->m_graphHolder;

	unsigned int n, nCount = js->getNodesCount();

	for (n = 0; n != nCount; ++n) {

		// Get the first non-ELIMINATED and non-already treated JS node

		if (!js->getNode(n).hasAttribute(JointSequenceGraph::ELIMINATED | SORTED)) {

			nodesToDo.push_back(std::make_pair(n, 0));

			while (!nodesToDo.empty()) {

				currNodeIdx = nodesToDo.back().first;

				currHeight = nodesToDo.back().second;

				nodesToDo.pop_back();

				JointSequenceGraph::Node &currNode = js->node(currNodeIdx);

				// Sign current node

				currNode.setAttribute(SORTED);

				// Initialize this node infos

				pD = *currGraph->getNode(currNode.getLink(0)->m_head);

				p = TPoint(pD.x, pD.y);

				if (!ras->getBounds().contains(p))

					continue;

				//currColor = getInkPredominance(ras, palette, p.x, p.y, (int) pD.z); //ras->pixels(p.y)[p.x].getInk();

				currColor = getBranchPredominance(ras, palette, currNode);

				if (currColor < 0)

					currColor = ras->pixels(p.y)[p.x].getInk();

				int l, lCount = currNode.getLinksCount();

				for (l = 0; l != lCount; ++l) {

					nextNodeIdx = currNode.getLink(l).getNext();

					Sequence &s = *currNode.link(l);

					// Check if outgoing sequence has current color (front) or not (back)

					toOrder[s.m_strokeIndex].first = (s.m_color == currColor) ? currHeight : currHeight - 1;

					if (!(currNode.getLink(l).getAccess() == SORTED)) {

						// Deal with this unchecked branch

						// If sequence was not split (due to color change)

						if (!currGraph->getNode(s.m_tail).hasAttribute(SAMPLECOLOR_SIGN)) {

							JointSequenceGraph::Node &nextNode = js->node(nextNodeIdx);

							// Then check nextNode

							pD = *currGraph->getNode(nextNode.getLink(0)->m_head);

							p = TPoint(pD.x, pD.y);

							if (!ras->getBounds().contains(p))

								continue;

							// If nextNode was not already inserted in ToDo vector, do it now.

							if (!nextNode.hasAttribute(SORTED)) {

								//nextColor = getInkPredominance(ras, palette, p.x, p.y, (int) pD.z);

								nextColor = getBranchPredominance(ras, palette, nextNode);

								if (nextColor < 0)

									nextColor = ras->pixels(p.y)[p.x].getInk();

								nextHeight = (s.m_color == nextColor) ? toOrder[s.m_strokeIndex].first : toOrder[s.m_strokeIndex].first + 1;

								nodesToDo.push_back(std::make_pair(nextNodeIdx, nextHeight));

							}

							// Deny access to its inverse (already processed now)

							nextNode.link(js->tailLinkOf(currNodeIdx, l)).setAccess(SORTED);

						}

					}

				}

			}

		}

	}

}

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

inline void orderColoredStrokes(JointSequenceGraphList &organizedGraphs, std::vector<tstroke *=""> &strokes,</tstroke>

								const TRasterCM32P &ras, TPalette *palette)

{

	// Initialize ordering

	std::vector<std::pair<int, *="" tstroke="">> strokesByHeight(</std::pair<int,>

		strokes.size(), std::make_pair(-(std::numeric_limits<int>::max)(), (TStroke *)0));</int>

	size_t s, sCount = strokes.size();

	for (s = 0; s != sCount; ++s)

		strokesByHeight[s].second = strokes[s];

	size_t og, ogCount = organizedGraphs.size();

	for (og = 0; og != ogCount; ++og)

		sortJS(&organizedGraphs[og], strokesByHeight, ras, palette);

	// Now, we have the order vector filled, apply sorting algorithm.

	std::sort(strokesByHeight.begin(), strokesByHeight.end());

	for (s = 0; s != sCount; ++s)

		strokes[s] = strokesByHeight[s].second;

}

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

//Take samples of image colors to associate each stroke to its corresponding

//palette color. Currently working on colormaps, closest-to-black strokes

//otherwise.

void applyStrokeColors(std::vector<tstroke *=""> &strokes, const TRasterP &ras, TPalette *palette,</tstroke>

					   VectorizerCoreGlobals &g)

{

	JointSequenceGraphList &organizedGraphs = g.organizedGraphs;

	SequenceList &singleSequences = g.singleSequences;

	TRasterCM32P cm = ras;

	unsigned int i, j, k, n;

	if (cm && g.currConfig->m_maxThickness > 0.0) {

		applyStrokeIndices(&g);

		//Treat single sequences before, like conversionToStrokes(..)

		for (i = 0; i < singleSequences.size(); ++i)

			strokes[i]->setStyle(singleSequences[i].m_color);

		//Then, treat remaining graph-strokes

		n = i;

		for (i = 0; i < organizedGraphs.size(); ++i)

			for (j = 0; j < organizedGraphs[i].getNodesCount(); ++j)

				if (!organizedGraphs[i].getNode(j).hasAttribute(JointSequenceGraph::ELIMINATED)) //due to junction recovery

					for (k = 0; k < organizedGraphs[i].getNode(j).getLinksCount(); ++k) {

						Sequence &s = *organizedGraphs[i].node(j).link(k);

						if (s.isForward()) {

							//vi->getStroke(n)->setStyle(s.m_color);

							strokes[n]->setStyle(s.m_color);

							++n;

						}

					}

		//Order vector image according to actual color-coverings at junctions.

		orderColoredStrokes(organizedGraphs, strokes, cm, palette);

	} else {

		//Choose closest-to-black palette color

		int blackStyleId = palette->getClosestStyle(TPixel32::Black);

		unsigned int i;

		for (i = 0; i < strokes.size(); ++i)

			strokes[i]->setStyle(blackStyleId);

	}

}