#include "tcenterlinevectP.h"

// tcg includes
#include "tcg/tcg_numeric_ops.h"

// Boost includes
#include <boost/container/flat_map.hpp>
#include <boost/algorithm/minmax_element.hpp>

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;
	std::vector<double> params;

	// 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 = tmax(params.back() / tmax(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
	std::vector<TPoint> samplePoints(sampleCount); // Image points for color sampling
	std::vector<int> sampleSegments(sampleCount);  // Sequence segment index for the above

	// 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(tmin(samplePoint.x, double(ras->getLx() - 1)),  // This deals with sample points at
								 tmin(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());

	radius = tmin(radius, 7); //Restrict radius for a minimum significative neighbour

	mx = tmax(x - radius, 0);
	my = tmax(y - radius, 0);
	Mx = tmin(x + radius, ras->getLx() - 1);
	My = tmin(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)
		{
			return (a.second < b.second);
		}
	};

	boost_c::flat_map<int, int> branchInksHistogram;

	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;

	const std::pair<histo_it, histo_it> &histoRange =
		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,
			const TRasterCM32P &ras, TPalette *palette)
{
	enum { SORTED = 0x10 };

	std::vector<std::pair<unsigned int, int>> nodesToDo;
	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,
								const TRasterCM32P &ras, TPalette *palette)
{
	// Initialize ordering
	std::vector<std::pair<int, TStroke *>> strokesByHeight(
		strokes.size(), std::make_pair(-(std::numeric_limits<int>::max)(), (TStroke *)0));

	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,
					   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);
	}
}