#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 ®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);
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 ®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;
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 ®ion = 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 ®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;
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;
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;
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 ®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;
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 ®ion = 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 ®ion = 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;
}