#include "toonz/Naa2TlvConverter.h"
 
#include "toonz/tcenterlinevectorizer.h"
#include "toonz/stage.h"
#include "tpixelutils.h"
#include "tpalette.h"
 
#include <QSet>
#include <QTime>
#include <QDebug>
#include <QMultiMap>
 
QString RegionInfo::getTypeString() const
{
	switch (type) {
	case RegionInfo::Background:
		return "Background";
	case RegionInfo::Ink:
		return "Ink";
	case RegionInfo::ThinInk:
		return "ThinInk";
	case RegionInfo::MainInk:
		return "Main ink";
	case RegionInfo::SyntheticInk:
		return "SyntheticInk";
	case RegionInfo::Paint:
		return "Paint";
	case RegionInfo::LargePaint:
		return "LargePaint";
	case RegionInfo::SmallPaint:
		return "SmallPaint";
	case RegionInfo::Unused:
		return "Unused";
	case RegionInfo::Unknown:
		return "Unknown";
	default:
		return "??????";
	}
}
 
Naa2TlvConverter::Naa2TlvConverter()
	: MaxColorCount(1000), m_regionRas(0), m_borderRas(0), m_dotRas(0), m_syntheticInkRas(0), m_inkThickness(0), m_palette(0), m_valid(false)
 
{
}
 
Naa2TlvConverter::~Naa2TlvConverter()
{
	delete m_regionRas;
	delete m_borderRas;
	delete m_dotRas;
	delete m_syntheticInkRas;
	if (m_palette)
		m_palette->release();
}
 
void Naa2TlvConverter::setPalette(TPalette *palette)
{
	if (m_palette != palette) {
		if (palette)
			palette->addRef();
		if (m_palette)
			m_palette->release();
		m_palette = palette;
	}
}
 
void Naa2TlvConverter::process(const TRaster32P &srcRas)
{
	m_valid = false;
	setSourceImage(srcRas);
	if (!m_valid)
		return;
 
	separateRegions();
 
	computeLinks();
 
	findRegionBorders();
	erodeRegions();
 
	findLargePaints();
 
	findBackgroundRegions();
	findMainInks();
 
	// computeMainInkThickness();
	findThinInks();
 
	measureThickness();
 
	//findPaints();
	findPaints2();
 
	findThinPaints();
 
	findSuspectInks();
 
	addBorderInks();
}
 
//-----------------------------------------------------------------------------
 
// Input: srcRas (full color image)
// Output:
//   m_regionRas : pixel => region index
//   m_regions   : region index => RegionInfo
//
// Note: delete m_borderRas
 
void Naa2TlvConverter::setSourceImage(const TRaster32P &srcRas)
{
	int lx = srcRas->getSize().lx;
	int ly = srcRas->getSize().ly;
 
	m_colors.clear();
	m_regions.clear();
	delete m_regionRas;
	m_regionRas = new WorkRaster<unsigned short>(lx, ly);
	delete m_borderRas;
	m_borderRas = 0;
 
	delete m_dotRas;
	m_dotRas = 0;
 
	delete m_syntheticInkRas;
	m_syntheticInkRas = 0;
 
	QMap<TPixel32, int> colorTable;
	for (int y = 0; y < ly; y++) {
		TPixel32 *srcScanLine = srcRas->pixels(y);
		unsigned short *regionScanLine = m_regionRas->pixels(y);
		for (int x = 0; x < lx; x++) {
			TPixel32 srcPix = overPixOnWhite(srcScanLine[x]);
			QMap<TPixel32, int>::ConstIterator it = colorTable.find(srcPix);
			if (it == colorTable.end()) {
				// found new color (and therefore new region)
				RegionInfo r;
				// add new color
				r.colorIndex = m_colors.count();
				m_colors.append(srcPix);
				r.pixelCount = 1;
				// add new region
				int regionIndex = m_regions.count();
				m_regions.append(r);
				// update raster and colorTable
				regionScanLine[x] = regionIndex;
				colorTable.insert(srcPix, regionIndex);
				if (m_colors.count() > MaxColorCount) {
					return;
				}
			} else {
				// already defined color
				int regionIndex = it.value();
				regionScanLine[x] = regionIndex;
				m_regions[regionIndex].pixelCount++;
			}
		}
	}
	m_valid = true;
}
 
//-----------------------------------------------------------------------------
 
// color-based regions => connection-based regions  (i.e. split unconnected region parts)
// note: rebuild m_regions
 
void Naa2TlvConverter::separateRegions()
{
	if (!m_regionRas)
		return;
	const int lx = m_regionRas->getLx();
	const int ly = m_regionRas->getLy();
	const int wrap = lx;
 
	// we assume that m_regions contains almost no information (except: m_regions[i].colorIndex == i)
	m_regions.clear();
 
	WorkRaster<int> wb(lx, ly); // work buffer
 
	QVector<int> regionMap; // wb pixels => region indices
	QList<int> freeRegions;
 
	for (int y = 0; y < ly; y++) {
		unsigned short *waScanLine = m_regionRas->pixels(y);
		int *wbScanLine = wb.pixels(y);
		for (int x = 0; x < lx; x++) {
			int c = waScanLine[x];
			int cUp = y > 0 ? waScanLine[x - wrap] : -1;
			int cLeft = x > 0 ? waScanLine[x - 1] : -1;
			int cUpLeft = x > 0 && y > 0 ? waScanLine[x - wrap - 1] : -1;
 
			if (c != cUp && c != cLeft && c != cUpLeft) {
				// no connection: create a new region
				Q_ASSERT(0 <= c && c < m_colors.count());
				RegionInfo region;
				region.colorIndex = c;
				int regionIndex;
				if (!freeRegions.empty()) {
					// use a previously discarded region
					regionIndex = freeRegions.back();
					freeRegions.pop_back();
					m_regions[regionIndex] = region;
				} else {
					// create a new region
					regionIndex = m_regions.count();
					m_regions.append(region);
				}
				wbScanLine[x] = regionMap.count();
				regionMap.append(regionIndex);
			} else {
				// at least one connection
				if (c == cUpLeft)
					wbScanLine[x] = wbScanLine[x - wrap - 1];
				else if (c == cUp)
					wbScanLine[x] = wbScanLine[x - wrap];
				else {
					Q_ASSERT(c == cLeft);
					wbScanLine[x] = wbScanLine[x - 1];
				}
			}
 
			// merge if needed
			if (cUp == cLeft && cUp >= 0 && regionMap[wbScanLine[x - 1]] != regionMap[wbScanLine[x - wrap]]) {
				// merge
				int pixelToDiscard = wbScanLine[x - 1];
				int pixelToKeep = wbScanLine[x - wrap];
				Q_ASSERT(pixelToDiscard != pixelToKeep);
				int regionToDiscard = regionMap[pixelToDiscard];
				int regionToKeep = regionMap[pixelToKeep];
				Q_ASSERT(regionToDiscard != regionToKeep);
				Q_ASSERT(m_regions[regionToDiscard].type != RegionInfo::Unused);
				Q_ASSERT(m_regions[regionToKeep].type != RegionInfo::Unused);
				for (int i = 0; i < regionMap.count(); i++)
					if (regionMap[i] == regionToDiscard)
						regionMap[i] = regionToKeep;
				//wbScanLine[x] = pixelToKeep;
				m_regions[regionToDiscard].type = RegionInfo::Unused;
				freeRegions.append(regionToDiscard);
			}
		}
	}
 
	// fill gaps
	for (;;) {
		// just remove topmost Unused regions
		if (!m_regions.empty() && m_regions.back().type == RegionInfo::Unused) {
			m_regions.pop_back();
			int k = m_regions.count();
			freeRegions.removeAll(k);
		} else if (!freeRegions.empty()) {
			// last region is used, but there is at least a free region with lower index: move it there
			int regionToDiscard = m_regions.count() - 1;
			int regionToKeep = freeRegions.back();
			freeRegions.pop_back();
			Q_ASSERT(m_regions[regionToKeep].type == RegionInfo::Unused);
			Q_ASSERT(m_regions[regionToDiscard].type != RegionInfo::Unused);
			Q_ASSERT(regionToKeep < regionToDiscard);
			m_regions[regionToKeep] = m_regions[regionToDiscard];
			// pop the region to discard
			m_regions.pop_back();
			// update map
			for (int i = 0; i < regionMap.count(); i++)
				if (regionMap[i] == regionToDiscard)
					regionMap[i] = regionToKeep;
		} else
			break;
	}
 
	Q_ASSERT(freeRegions.empty());
 
	for (int i = 0; i < m_regions.count(); i++)
		m_regions[i].pixelCount = 0;
 
	// wb => m_regionRas
	for (int y = 0; y < ly; y++) {
		unsigned short *regionScanLine = m_regionRas->pixels(y);
		int *wbScanLine = wb.pixels(y);
		for (int x = 0; x < lx; x++) {
			int regionIndex = regionMap[wbScanLine[x]];
			regionScanLine[x] = (unsigned short)regionIndex;
			m_regions[regionIndex].pixelCount++;
		}
	}
}
 
//-----------------------------------------------------------------------------
 
// compute adjacency relationships
// update: m_regions[].links
// outer regions are connected to the "pseudo-region" -1
// note: check orthogonal directions only
// compute region.perimeter
 
void Naa2TlvConverter::computeLinks()
{
	if (!m_regionRas || m_regions.empty())
		return;
	const int lx = m_regionRas->getLx();
	const int ly = m_regionRas->getLy();
	const int wrap = lx;
	unsigned short *waScanLine;
	int x;
	for (int i = 0; i < m_regions.count(); i++)
		m_regions[i].perimeter = 0;
	for (int y = 0; y < ly; y++) {
		waScanLine = m_regionRas->pixels(y);
		for (x = 0; x < lx; x++) {
			int c = waScanLine[x];
			int cUp = y > 0 ? waScanLine[x - wrap] : -1;
			int cLeft = x > 0 ? waScanLine[x - 1] : -1;
			if (c != cUp) {
				m_regions[c].touchRegion(cUp);
				m_regions[c].perimeter++;
				if (cUp >= 0) {
					m_regions[cUp].touchRegion(c);
					m_regions[cUp].perimeter++;
				}
			}
			if (c != cLeft) {
				m_regions[c].touchRegion(cLeft);
				m_regions[c].perimeter++;
				if (cLeft >= 0) {
					m_regions[cLeft].touchRegion(c);
					m_regions[cLeft].perimeter++;
				}
			}
		}
		m_regions[waScanLine[lx - 1]].touchRegion(-1);
	}
	waScanLine = m_regionRas->pixels(ly - 1);
	for (x = 0; x < lx; x++) {
		m_regions[waScanLine[x]].touchRegion(-1);
	}
}
 
//-----------------------------------------------------------------------------
 
// find background regions :
// (almost) white, touching image border
//
void Naa2TlvConverter::findBackgroundRegions()
{
	if (!m_regionRas || m_regions.empty())
		return;
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
 
	// find the whitest color
	int bgColorIndex = -1;
	int maxV = 0;
	for (int i = 0; i < m_colors.count(); i++) {
		TPixel color = m_colors.at(i);
		int v = color.r + color.g + color.b;
		int a = qMin(color.r, qMin(color.g, color.b));
		if (a < 230)
			continue;
		if (v > maxV) {
			bgColorIndex = i;
			maxV = v;
		}
	}
	if (bgColorIndex < 0) {
		// no white found. no bg region
		return;
	}
 
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.colorIndex == bgColorIndex && region.links.contains(-1)) {
			region.type = RegionInfo::Background;
			;
		}
	}
}
 
//-----------------------------------------------------------------------------
 
// start computing m_borderRas : 1 for boundary pixels, 0 for internal pixels
 
void Naa2TlvConverter::findRegionBorders()
{
	if (!m_regionRas)
		return;
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
	delete m_borderRas;
	m_borderRas = new WorkRaster<unsigned char>(lx, ly);
 
	static const int dd[][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}};
 
	// find region-region boundaries
	for (int y = 0; y < ly; y++) {
		unsigned short *workScanLine = m_regionRas->pixels(y);
		unsigned char *borderScanLine = m_borderRas->pixels(y);
 
		for (int x = 0; x < lx; x++) {
			int k = workScanLine[x];
			Q_ASSERT(0 <= k && k < m_regions.count());
			int isBoundary = 0;
			for (int j = 0; j < 8; j++) {
				int x1 = x + dd[j][0], y1 = y + dd[j][1];
				if (0 <= x1 && x1 < lx && 0 <= y1 && y1 < ly) {
					int k1 = m_regionRas->pixels(y1)[x1];
					if (k1 != k) {
						isBoundary = 1;
						break;
					}
				}
			}
			borderScanLine[x] = isBoundary;
		}
	}
}
 
//-----------------------------------------------------------------------------
 
// update m_borders, adding 2,3... for internal pixels close to boundary
// update m_regions[i].boundaries (histogram : boundaries[k] is the number of pixels belonging to that region with m_border[pix] == k)
 
void Naa2TlvConverter::erodeRegions()
{
	QTime clock;
	clock.start();
	if (!m_regionRas || !m_borderRas)
		return;
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
 
	static const int dd[][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}};
 
	for (int iter = 0; iter < 10; iter++) {
		for (int y = 0; y < ly; y++) {
			unsigned short *workScanLine = m_regionRas->pixels(y);
			unsigned char *borderScanLine = m_borderRas->pixels(y);
			for (int x = 0; x < lx; x++) {
				if (borderScanLine[x] != iter + 1)
					continue;
				int c = workScanLine[x];
				for (int j = 0; j < 8; j++) {
					int x1 = x + dd[j][0], y1 = y + dd[j][1];
					if (!(0 <= x1 && x1 < lx && 0 <= y1 && y1 < ly))
						continue;
					int c1 = m_regionRas->pixels(y1)[x1];
					int b1 = m_borderRas->pixels(y1)[x1];
					if (c1 == c && b1 == 0)
						m_borderRas->pixels(y1)[x1] = iter + 2;
				}
			}
		}
	}
 
	for (int i = 0; i < m_regions.count(); i++)
		m_regions[i].boundaries.clear();
	for (int y = 0; y < ly; y++) {
		unsigned short *workScanLine = m_regionRas->pixels(y);
		unsigned char *borderScanLine = m_borderRas->pixels(y);
		for (int x = 0; x < lx; x++) {
			int c = workScanLine[x];
			int b = borderScanLine[x];
			RegionInfo &r = m_regions[c];
			QList<int> &bs = r.boundaries;
			while (bs.count() <= b)
				bs.append(0);
			bs[b]++;
			if (b == bs.count() - 1)
				r.pos = QPoint(x, y);
			if (r.x0 > r.x1) {
				r.x0 = r.x1 = x;
				r.y0 = r.y1 = y;
			} else {
				if (x < r.x0)
					r.x0 = x;
				else if (x > r.x1)
					r.x1 = x;
				if (y < r.y0)
					r.y0 = y;
				else if (y > r.y1)
					r.y1 = y;
			}
		}
	}
	qDebug() << "Erode regions. time = " << clock.elapsed();
}
 
//-----------------------------------------------------------------------------
 
// main inks touch background regions and don't have large interior
void Naa2TlvConverter::findMainInks()
{
 
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
		if (region.isBackground() || region.type == RegionInfo::LargePaint || region.boundaries[0] > 0)
			continue;
		double ap2 = 100000.0 * (double)region.pixelCount / pow((double)region.perimeter, 2);
		if (ap2 > 100)
			continue;
		foreach (int c, region.links.keys()) {
			if (c >= 0 && (m_regions[c].isBackground() || m_regions[c].type == RegionInfo::LargePaint)) {
				int strength = region.links[c];
				if (strength > 50) {
					m_regions[i].type = RegionInfo::MainInk;
					break;
				}
			}
		}
	}
}
 
//-----------------------------------------------------------------------------
 
// compute the average thickness of the main ink region
 
void Naa2TlvConverter::computeMainInkThickness()
{
	m_inkThickness = 0.0;
	int largestArea = 0;
	for (int i = 0; i < m_regions.count(); i++) {
		if (m_regions[i].type != RegionInfo::MainInk)
			continue;
		if (m_regions[i].pixelCount < largestArea)
			continue;
		largestArea = m_regions[i].pixelCount;
		if (i == 55) {
			int x = 123;
		}
		QList<int> &bs = m_regions[i].boundaries;
		Q_ASSERT(bs[1] > 0);
		int perimeter = m_regions[i].perimeter;
		int area = bs[1];
		for (int j = 2; j < bs.count() && bs[j] * 2 > bs[1]; j++)
			area += bs[j];
		if (perimeter > 0) {
			m_inkThickness = 2 * (double)area / (double)perimeter;
		}
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::findLargePaints()
{
	if (!m_regionRas || !m_borderRas || m_regions.empty())
		return;
	QSet<int> largePaintColors;
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
		QList<int> &bs = region.boundaries;
		if (bs[0] > 0) {
			region.type = RegionInfo::LargePaint;
			largePaintColors.insert(region.colorIndex);
		}
	}
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
		if (largePaintColors.contains(region.colorIndex))
			region.type = RegionInfo::LargePaint;
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::findThinInks()
{
	if (!m_regionRas || !m_borderRas || m_regions.empty())
		return;
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
		QList<int> &bs = region.boundaries;
		if (bs.count() == 2)
			region.type = RegionInfo::ThinInk;
		else if (bs.count() == 3) {
			continue;
			if (bs[2] * 5 < bs[1])
				region.type = RegionInfo::ThinInk;
		} else {
			continue;
			int k = 1;
			int s = 0;
			while (k < bs.count() && s * 100 < region.pixelCount * 90)
				s += bs[k++];
			if (region.pixelCount > 100 && k <= 3)
				region.type = RegionInfo::ThinInk; // era Ink per qualche ragione
		}
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::findPaints()
{
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
		foreach (int c, m_regions[i].links.keys()) {
			if (c >= 0 && m_regions[c].isInk()) {
				m_regions[i].type = RegionInfo::Paint;
				break;
			}
		}
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::findPaints2()
{
	double avThickness = 0.0;
	int m = 0;
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type == RegionInfo::MainInk) {
			avThickness += region.thickness * region.pixelCount;
			m += region.pixelCount;
		}
	}
	if (m > 0) {
		avThickness = avThickness / m;
	} else {
		avThickness = 1.5; // this should never happen
	}
 
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
 
		if (region.thickness > 0.0) {
			if (region.thickness < 1.2 * avThickness)
				region.type = RegionInfo::Ink;
			else
				region.type = RegionInfo::Paint;
		}
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::findThinPaints()
{
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
 
	QList<int> regions;
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (!region.isInk())
			continue;
		if (region.type == RegionInfo::MainInk)
			continue;
 
		int inkBoundary = 0;
		QMap<int, int>::ConstIterator it;
		for (it = region.links.begin(); it != region.links.end(); ++it) {
			int c = it.key();
			int linkStrength = it.value(); // number of contact points
			if (c >= 0 && m_regions[c].isInk())
				inkBoundary += linkStrength;
		}
		region.inkBoundary = inkBoundary;
		if (inkBoundary * 100 > region.perimeter * 80)
			regions.append(i);
	}
 
	foreach (int c, regions)
		m_regions[c].type = RegionInfo::SmallPaint;
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::findSuspectInks()
{
	QMultiMap<TUINT32, int> paintColorTable;
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (0 == (region.type & RegionInfo::Paint))
			continue;
		TPixel32 color = m_colors[region.colorIndex];
		if (color == TPixel32(0, 0, 0)) {
			int x = 1234;
			continue;
		}
		TUINT32 rawColor = *(TUINT32 *)&color;
		paintColorTable.insert(rawColor, i);
	}
 
	int count = 0;
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.isInk() && region.links.size() == 2) {
			int ra = region.links.keys().at(0), rb = region.links.keys().at(1);
			if (ra >= 0 && rb >= 0) {
				if (!m_regions[ra].isInk())
					qSwap(ra, rb);
				if (m_regions[ra].isInk() && !m_regions[rb].isInk()) {
					int sa = region.links[ra];
					int sb = region.links[rb];
					if (sa > sb) {
						region.type = RegionInfo::Paint;
						count++;
						continue;
					}
				}
			}
		}
 
		if (region.type != RegionInfo::ThinInk)
			continue;
		TUINT32 rawColor = *(TUINT32 *)&m_colors[region.colorIndex];
		if (paintColorTable.contains(rawColor)) {
			region.type = RegionInfo::Unknown;
			count++;
		}
	}
 
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.isInk() && 10 <= region.pixelCount && region.pixelCount < 100) {
			int lx = region.x1 - region.x0 + 1;
			int ly = region.y1 - region.y0 + 1;
			int d = qMax(lx, ly);
			if (qMin(lx, ly) * 2 > qMax(lx, ly) && region.pixelCount > d * d / 2) {
				region.type = RegionInfo::Paint;
			}
		}
 
		if (region.type == RegionInfo::Paint || region.type == RegionInfo::Unknown) {
			bool isInk = false;
			if (region.boundaries.at(0) == 0) {
				if (region.boundaries.count() == 2)
					isInk = true;
				else if (region.boundaries.count() == 3) {
					int b1 = region.boundaries.at(1);
					int b2 = region.boundaries.at(2);
					if (b1 * 2 < b2)
						isInk = true;
				}
			}
			if (isInk)
				region.type = RegionInfo::Ink;
		}
	}
}
 
//-----------------------------------------------------------------------------
 
//
 
void Naa2TlvConverter::assignColorTypes()
{
 
	if (!m_regionRas || !m_borderRas || m_regions.empty())
		return;
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
 
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		if (region.type != RegionInfo::Unknown)
			continue;
		QList<int> &bs = region.boundaries;
		if (bs[0] > 0) {
			region.type = RegionInfo::LargePaint;
		} else {
			int b = 0;
			for (int j = 1; j <= 2 && j < bs.count(); j++)
				b += bs[j];
			if (region.pixelCount > 200 && (region.pixelCount - b) * 10 < region.pixelCount) {
				region.type = RegionInfo::ThinInk;
			}
		}
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::addBorderInks() // add syntethic inks: lines between two adjacent fill-regions
{
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
	static const int dd[][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}, {1, 1}, {-1, -1}, {-1, 1}, {1, -1}};
 
	m_syntheticInkRas = new WorkRaster<unsigned char>(lx, ly);
	for (int i = 0; i < lx * ly; i++)
		m_syntheticInkRas->pixels(0)[i] = 0;
 
	int borderInkColorIndex = m_colors.count();
	m_colors.append(TPixel32(255, 0, 0));
 
	RegionInfo borderInkRegion;
	borderInkRegion.type = RegionInfo::SyntheticInk;
	borderInkRegion.colorIndex = borderInkColorIndex;
	int borderInkRegionIndex = m_regions.count();
	m_regions.append(borderInkRegion);
 
	for (int y = 0; y < ly; y++) {
		unsigned short *workScanLine = m_regionRas->pixels(y);
		unsigned char *borderScanLine = m_borderRas->pixels(y);
		for (int x = 0; x < lx; x++) {
			int c = workScanLine[x];
			if (borderScanLine[x] != 1)
				continue; // consider border pixel only
			if (0 == (m_regions[c].type & RegionInfo::Paint) && m_regions[c].type != RegionInfo::Unknown)
				continue; // consider paint pixels only
 
			// is touching a different no-ink pixel?
			bool touchesOtherRegion = false;
			for (int j = 0; j < 8; j++) {
				int x1 = x + dd[j][0], y1 = y + dd[j][1];
				if (0 <= x1 && x1 < lx && 0 <= y1 && y1 < ly) {
					int c1 = m_regionRas->pixels(y1)[x1];
 
					if (m_regions[c1].type == RegionInfo::Background) {
						touchesOtherRegion = true;
						break;
					} else if (m_regions[c1].type == RegionInfo::Unknown || (m_regions[c1].type & RegionInfo::Paint) != 0) {
						// OLD: note: we consider only regions with a lower index, to avoid to create double border strokes
						// NEW: we put syntetic ink pixels in larger regions
						if (m_regions[c1].pixelCount < m_regions[c].pixelCount) {
							touchesOtherRegion = true;
							break;
						}
					}
				}
			}
 
			if (touchesOtherRegion) {
				m_syntheticInkRas->pixels(y)[x] = 1;
			}
		}
	}
}
 
//-----------------------------------------------------------------------------
 
void Naa2TlvConverter::measureThickness()
{
	QTime timer;
	timer.start();
	if (!m_regionRas || !m_borderRas)
		return;
	unsigned short *regionBuffer = m_regionRas->pixels();
	unsigned char *borderBuffer = m_borderRas->pixels();
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
 
	if (!m_dotRas || m_dotRas->getLx() != lx || m_dotRas->getLy() != ly) {
		delete m_dotRas;
		m_dotRas = new WorkRaster<unsigned char>(lx, ly);
	}
	memset(m_dotRas->pixels(), 0, lx * ly);
	// for(int i=0;i<lx*ly;i++) m_dotRas->pixels()[i]=0;
 
	unsigned char *dotBuffer = m_dotRas->pixels();
 
	for (int y = 0; y < ly; y++) {
		for (int x = 0; x < lx; x++) {
			if (borderBuffer[y * lx + x] != 1)
				continue;
			if (dotBuffer[y * lx + x] != 0)
				continue;
			int regionId = regionBuffer[y * lx + x];
			RegionInfo &region = m_regions[regionId];
			int type = region.type;
			if (type == RegionInfo::Background || type == RegionInfo::LargePaint || type == RegionInfo::ThinInk)
				continue;
 
			int thickness = measureThickness(x, y);
			if (thickness < 1)
				continue;
			QMap<int, int>::Iterator it = region.thicknessHistogram.find(thickness);
			if (it != region.thicknessHistogram.end())
				it.value() += 1;
			else
				region.thicknessHistogram.insert(thickness, 1);
		}
	}
 
	for (int i = 0; i < m_regions.count(); i++) {
		RegionInfo &region = m_regions[i];
		int type = region.type;
		if (type == RegionInfo::Background || type == RegionInfo::LargePaint || type == RegionInfo::ThinInk)
			continue;
		int thicknessCount = 0;
		double thickness = 0.0;
		for (QMap<int, int>::Iterator it = region.thicknessHistogram.begin(); it != region.thicknessHistogram.end(); ++it) {
			thicknessCount += it.value();
			thickness += it.key() * it.value();
		}
		if (thicknessCount > 0) {
			thickness *= 1.0 / thicknessCount;
			region.thickness = thickness;
		}
	}
	qDebug() << "measure thickness. time=" << timer.elapsed();
}
 
//-----------------------------------------------------------------------------
 
int Naa2TlvConverter::measureThickness(int x0, int y0)
{
 
	if (!m_regionRas || !m_borderRas || !m_dotRas)
		return -1;
	unsigned short *regionBuffer = m_regionRas->pixels();
	unsigned char *borderBuffer = m_borderRas->pixels();
	unsigned char *dotBuffer = m_dotRas->pixels();
 
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
 
	int k0 = lx * y0 + x0;
	// no needs to worry about image limits
	if (x0 - 1 < 0 || x0 + 1 >= lx || y0 - 1 < 0 || y0 + 1 >= ly)
		return -1;
	// we must start from a border
	if (borderBuffer[k0] != 1)
		return -1;
 
	// far from other measures
	if (dotBuffer[k0] != 0)
		return -1;
 
	int regionId = regionBuffer[k0];
	RegionInfo &info = m_regions[regionId];
 
	// directions
	const int dd[8] = {1, lx + 1, lx, lx - 1, -1, -1 - lx, -lx, 1 - lx};
 
	// a is a direction index; a : inside; a+1 : outside
	int a = 0;
	while (a < 8 && !(regionBuffer[k0 + dd[a]] == regionId && regionBuffer[k0 + dd[(a + 1) % 8]] != regionId))
		a++;
	if (a == 8) {
		// k0 is an isolated point or (strange!) an intern point
		qDebug() << "Isolated point or intern point";
		return -1;
	}
	int ka = k0 + dd[a];
 
	int b = (a + 2) % 8;
	while (regionBuffer[k0 + dd[b]] != regionId)
		b = (b + 1) % 8;
	// a..b = boundaries
	int kb = k0 + dd[b];
	if (a == b || ((b + 1) % 8) == a)
		return -1; // k0 is a corner
 
	dotBuffer[k0] = 1;
	dotBuffer[ka] = 2;
	dotBuffer[kb] = 3;
 
	int c = (b + 1) % 8;
	bool isThin = false;
	while (c != a) {
		if (regionBuffer[k0 + dd[c]] != regionId) {
			isThin = true;
			break;
		}
		c = (c + 1) % 8;
	}
	if (isThin) {
		// stroke larga un pixel, con paint da una parte e dall'altra.
		return 1;
	}
 
	int baseLength = 3;
 
	int d = b;
	int oldk = k0;
	int k = kb;
	int lastd2 = 0;
	for (int i = 0; i < baseLength; i++) {
		int x = k % lx;
		int y = k / lx;
		if (x <= 1 || x >= lx - 1 || y <= 1 || y >= ly - 1)
			break; // just to be sure
		int d2 = (x - x0) * (x - x0) + (y - y0) * (y - y0);
		if (d2 <= lastd2)
			break;
		lastd2 = d2;
		int d1 = (d + 4) % 8;
		d1 = (d1 + 1) % 8;
		while (regionBuffer[k + dd[d1]] != regionId)
			d1 = (d1 + 1) % 8;
		Q_ASSERT(regionBuffer[k + dd[d1]] == regionId);
		oldk = k;
		k = k + dd[d1];
		d = d1;
		dotBuffer[k] = 4;
	}
 
	// punto ad un estremo (lungo il confine)
	int x1 = k % lx;
	int y1 = k / lx;
 
	d = a;
	oldk = k0;
	k = ka;
	lastd2 = 0;
	for (int i = 0; i < baseLength; i++) {
		int x = k % lx;
		int y = k / lx;
		if (x <= 1 || x >= lx - 1 || y <= 1 || y >= ly - 1)
			break; // just to be sure
		int d2 = (x - x0) * (x - x0) + (y - y0) * (y - y0);
		if (d2 <= lastd2)
			break;
		lastd2 = d2;
		int d1 = (d + 4) % 8;
		d1 = (d1 + 7) % 8;
		while (regionBuffer[k + dd[d1]] != regionId)
			d1 = (d1 + 7) % 8;
		Q_ASSERT(regionBuffer[k + dd[d1]] == regionId);
		oldk = k;
		k = k + dd[d1];
		d = d1;
		dotBuffer[k] = 5;
	}
 
	// punto all'estremo opposto (lungo il confine)
	int x2 = k % lx;
	int y2 = k / lx;
 
	int dx = y2 - y1, dy = x1 - x2;
 
	int delta2 = dx * dx + dy * dy;
	if (delta2 < baseLength * baseLength * 3)
		return -1;
 
	int adx = abs(dx), ady = abs(dy);
	int sgx = dx > 0 ? 1 : -1, sgy = dy > 0 ? 1 : -1;
	int thickness = 1;
	const int maxThickness = 64;
	for (; thickness < maxThickness; thickness++) {
		int x, y;
		if (adx > ady) {
			x = x0 + thickness * sgx;
			y = y0 + sgy * (thickness * ady + adx / 2) / adx;
		} else {
			y = y0 + thickness * sgy;
			x = x0 + sgx * (thickness * adx + ady / 2) / ady;
		}
		k = y * lx + x;
		if (0 <= x && x < lx && 0 <= y && y < ly && regionBuffer[k] == regionId)
			dotBuffer[k] = 6;
		else
			break;
	}
	return thickness;
}
 
//-----------------------------------------------------------------------------
 
TToonzImageP Naa2TlvConverter::makeTlv(bool transparentSyntheticInks)
{
 
	if (!m_valid || m_colors.empty() || m_regions.empty() || !m_regionRas)
		return TToonzImageP();
	int lx = m_regionRas->getLx();
	int ly = m_regionRas->getLy();
	TPalette *palette = m_palette;
	if (!palette)
		palette = new TPalette();
 
	TRasterCM32P ras(lx, ly);
 
	QList<int> styleIds;
 
	for (int i = 0; i < m_colors.count() - 1; i++) {
		TPixel32 color = m_colors.at(i);
		int styleId = palette->getClosestStyle(color);
		TColorStyle *cs = styleId < 0 ? 0 : palette->getStyle(styleId);
		if (cs) {
			if (cs->getMainColor() != color)
				cs = 0;
		}
		if (cs == 0) {
			styleId = palette->getPage(0)->addStyle(color);
			cs = palette->getStyle(styleId);
		}
		styleIds.append(styleId);
	}
	styleIds.append(0); // syntetic ink
 
	//int synteticInkStyleId = palette->getPage(0)->addStyle(TPixel32(0,0,0,0));
	//styleIds.append(synteticInkStyleId);
 
	for (int y = 0; y < ly; y++) {
		unsigned short *workScanLine = m_regionRas->pixels(y);
		TPixelCM32 *outScanLine = ras->pixels(y);
		for (int x = 0; x < lx; x++) {
			int c = workScanLine[x];
			Q_ASSERT(0 <= c && c < m_regions.count());
 
			int color = m_regions[c].colorIndex;
			Q_ASSERT(0 <= color && color < styleIds.count());
 
			int styleId = styleIds.at(color);
 
			RegionInfo::Type type = m_regions.at(c).type;
			if (type == RegionInfo::Background)
				outScanLine[x] = TPixelCM32();
			else if (type & RegionInfo::Ink)
				outScanLine[x] = TPixelCM32(styleId, 0, 0);
			else if (m_syntheticInkRas->pixels(y)[x] == 1)
				outScanLine[x] = TPixelCM32(transparentSyntheticInks ? 0 : styleId, styleId, 0);
			else
				outScanLine[x] = TPixelCM32(0, styleId, 255);
		}
	}
 
	TToonzImageP ti = new TToonzImage(ras, ras->getBounds());
	ti->setPalette(palette);
	ti->setDpi(72, 72);
 
	return ti;
}
 
//-----------------------------------------------------------------------------
 
TVectorImageP Naa2TlvConverter::vectorize(const TToonzImageP &ti)
{
	CenterlineConfiguration conf;
	if (!ti)
		return TVectorImageP();
	TPalette *palette = ti->getPalette();
 
	VectorizerCore vc;
 
	TAffine dpiAff;
	double factor = Stage::inch;
	double dpix = factor / 72, dpiy = factor / 72;
 
	ti->getDpi(dpix, dpiy);
	TPointD center = ti->getRaster()->getCenterD();
 
	if (dpix != 0.0 && dpiy != 0.0)
		dpiAff = TScale(factor / dpix, factor / dpiy);
	factor = norm(dpiAff * TPointD(1, 0));
 
	conf.m_affine = dpiAff * TTranslation(-center);
	conf.m_thickScale = factor;
	conf.m_leaveUnpainted = false;
	conf.m_makeFrame = true;
	conf.m_penalty = 0.0;
	conf.m_despeckling = 0;
 
	TImageP img(ti.getPointer());
	TVectorImageP vi = vc.vectorize(img, conf, palette);
	vi->setPalette(palette);
	return vi;
}