#include "toonz/Naa2TlvConverter.h"

#include "toonz/tcenterlinevectorizer.h"

#include "toonz/stage.h"

#include "tpixelutils.h"

#include "tpalette.h"

#include <qset></qset>

#include <qtime></qtime>

#include <qdebug></qdebug>

#include <qmultimap></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);</unsigned>

	delete m_borderRas;

	m_borderRas = 0;

	delete m_dotRas;

	m_dotRas = 0;

	delete m_syntheticInkRas;

	m_syntheticInkRas = 0;

	QMap<tpixel32, int=""> colorTable;</tpixel32,>

	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);</tpixel32,>

			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</int>

	QVector<int> regionMap; // wb pixels => region indices</int>

	QList<int> freeRegions;</int>

	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 ®ion = 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);</unsigned>

	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;</int>

			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 ®ion = 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;</int>

		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;</int>

	for (int i = 0; i < m_regions.count(); i++) {

		RegionInfo ®ion = m_regions[i];

		if (region.type != RegionInfo::Unknown)

			continue;

		QList<int> &bs = region.boundaries;</int>

		if (bs[0] > 0) {

			region.type = RegionInfo::LargePaint;

			largePaintColors.insert(region.colorIndex);

		}

	}

	for (int i = 0; i < m_regions.count(); i++) {

		RegionInfo ®ion = 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 ®ion = m_regions[i];

		if (region.type != RegionInfo::Unknown)

			continue;

		QList<int> &bs = region.boundaries;</int>

		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 ®ion = 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 ®ion = 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 ®ion = 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;</int>

	for (int i = 0; i < m_regions.count(); i++) {

		RegionInfo ®ion = m_regions[i];

		if (!region.isInk())

			continue;

		if (region.type == RegionInfo::MainInk)

			continue;

		int inkBoundary = 0;

		QMap<int, int="">::ConstIterator it;</int,>

		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;</tuint32,>

	for (int i = 0; i < m_regions.count(); i++) {

		RegionInfo ®ion = 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 ®ion = 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 ®ion = 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 ®ion = m_regions[i];

		if (region.type != RegionInfo::Unknown)

			continue;

		QList<int> &bs = region.boundaries;</int>

		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);</unsigned>

	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);</unsigned>

	}

	memset(m_dotRas->pixels(), 0, lx * ly);

	// for(int i=0;i<lx*ly;i++) m_dotras-="">pixels()[i]=0;</lx*ly;i++)>

	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 ®ion = m_regions[regionId];

			int type = region.type;

			if (type == RegionInfo::Background || type == RegionInfo::LargePaint || type == RegionInfo::ThinInk)

				continue;