razzaline/tahoma2d
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
tahoma2d/toonz/sources/toonzlib/tcenterlinevectorizerOld.cpp
Michał Janiszewski df394d6939 Move to stringstream 
std::strstream is deprecated, stringstream is the suggested replacement.
2016-04-03 02:22:18 +02:00

2872 lines
79 KiB
C++
Raw Blame History

#include "toonz/tcenterlinevectorizer.h"
#include "tsystem.h"
#include "tstopwatch.h"
#include "tpalette.h"
//#include "timage_io.h"
//#include "tstrokeutil.h"
//#include "tspecialstyleid.h"
#include "trastercm.h"
#include "ttoonzimage.h"
//#include "dpiscale.h"
#include "tregion.h"
#include "tstroke.h"
#include "trasterimage.h"
#define SEARCH_WINDOW 3
#define JUNCTION_THICKNESS_RATIO 0.7
#define JOIN_LIMIT 0.8
#define THICKNESS_LIMIT 0.2
#define THICKNESS_LIMIT_2 0.04
#undef DEBUG
//---------------------------------------------------------
struct ControlPoint {
TStroke *m_stroke;
int m_index;
ControlPoint(TStroke *stroke, int index)
: m_stroke(stroke), m_index(index)
{
}
TPointD getPoint() const
{
return m_stroke->getControlPoint(m_index);
}
void setPoint(const TPointD &p)
{
TThickPoint point = m_stroke->getControlPoint(m_index);
point.x = p.x;
point.y = p.y;
m_stroke->setControlPoint(m_index, point);
}
};
void renormalizeImage(TVectorImage *vi)
{
int i, j;
int n = vi->getStrokeCount();
std::vector<ControlPoint> points;
points.reserve(n * 2);
for (i = 0; i < n; i++) {
TStroke *stroke = vi->getStroke(i);
int m = stroke->getControlPointCount();
if (m > 0) {
if (m == 1)
points.push_back(ControlPoint(stroke, 0));
else {
points.push_back(ControlPoint(stroke, 0));
points.push_back(ControlPoint(stroke, m - 1));
}
}
}
int count = points.size();
for (i = 0; i < count; i++) {
ControlPoint &pi = points[i];
TPointD posi = pi.getPoint();
TPointD center = posi;
std::vector<int> neighbours;
neighbours.push_back(i);
for (j = i + 1; j < count; j++) {
TPointD posj = points[j].getPoint();
double d = tdistance(posj, posi);
if (d < 0.01) {
/*if(d>0)
{
int yy = 123;
}*/
neighbours.push_back(j);
center += posj;
}
}
int m = neighbours.size();
if (m == 1)
continue;
center = center * (1.0 / m);
for (j = 0; j < m; j++)
points[neighbours[j]].setPoint(center);
}
}
//---------------------------------------------------------
class Node;
class DataPixel
{
public:
TPoint m_pos;
int m_value;
bool m_ink;
//int m_index;
Node *m_node;
DataPixel() : m_value(0), m_ink(false), /*m_index(0), */ m_node(0) {}
};
//---------------------------------------------------------
#ifdef WIN32
template class DV_EXPORT_API TSmartPointerT<TRasterT<DataPixel>>;
#endif
typedef TRasterPT<DataPixel> DataRasterP;
//---------------------------------------------------------
class Junction;
class Node
{
public:
Node *m_other;
DataPixel *m_pixel;
Node *m_prev, *m_next;
Junction *m_junction;
#ifdef DEBUG
bool m_flag;
#endif
bool m_visited;
Node()
: m_pixel(0),
m_prev(0),
m_next(0),
m_junction(0),
#ifdef DEBUG
m_flag(false),
#endif
m_visited(false)
{
}
};
//---------------------------------------------------------
class ProtoStroke;
class Junction
{
public:
TThickPoint m_center;
std::deque<Node *> m_nodes;
int m_junctionOrder;
std::vector<ProtoStroke *> m_protoStrokes;
bool m_locked;
Junction()
: m_center(), m_nodes(), m_junctionOrder(0), m_protoStrokes(), m_locked(false) {}
bool isConvex();
};
//---------------------------------------------------------
class ProtoStroke
{
public:
TPointD m_startDirection, m_endDirection;
Junction *m_startJunction, *m_endJunction;
std::deque<TThickPoint> m_points;
ProtoStroke()
: m_points(), m_startDirection(), m_endDirection(), m_startJunction(0), m_endJunction(0) {}
ProtoStroke(std::deque<TThickPoint>::iterator it_b,
std::deque<TThickPoint>::iterator it_e)
: m_points(it_b, it_e), m_startDirection(), m_endDirection(), m_startJunction(0), m_endJunction(0) {}
};
class ProtoRegion
{
public:
TPointD m_center;
bool m_isConvex;
std::vector<TThickPoint> m_points;
ProtoRegion(bool isConvex)
: m_points(), m_isConvex(isConvex), m_center() {}
};
class JunctionMerge
{
public:
Junction *m_junction;
Node *m_startNode, *m_endNode;
bool m_isNext;
JunctionMerge(Junction *junction)
: m_junction(junction), m_startNode(0), m_endNode(0), m_isNext(true) {}
JunctionMerge(Junction *junction, Node *startNode, Node *endNode, bool
isNext)
: m_junction(junction), m_startNode(startNode), m_endNode(endNode), m_isNext(isNext) {}
bool operator==(const JunctionMerge &op2)
{
return (m_junction == op2.m_junction);
}
};
class JunctionLink
{
public:
Junction *m_first;
Junction *m_second;
int m_order;
JunctionLink(Junction *first, Junction *second)
: m_first(first), m_second(second), m_order(0) {}
bool operator==(const JunctionLink &op2) const
{
return (m_first == op2.m_first && m_second == op2.m_second) || (m_first ==
op2.m_second &&
m_second == op2.m_first);
}
};
class CenterLineVectorizer
{
TPalette *m_palette;
public:
// int m_delta[8];
// int m_radius;
TRasterP m_src;
VectorizerConfiguration m_configuration;
#ifdef DEBUG
TRaster32P m_output;
#endif
DataRasterP m_dataRaster;
vector<pair<int, DataRasterP>> m_dataRasterArray;
TVectorImageP m_vimage;
#ifdef DEBUG
TVectorImageP m_rimage;
#endif
#ifdef DEBUG
vector<vector<TThickPoint>> m_outlines;
vector<TPointD> m_unvisitedNodes;
vector<vector<Node *>> m_junctionPolygons;
#endif
vector<Node *> m_nodes;
vector<Junction *> m_junctions;
vector<JunctionLink> m_links;
list<ProtoStroke> m_protoStrokes;
list<ProtoRegion> m_protoRegions;
//list< std::vector<TThickPoint> > m_protoHoles;
Node *findOtherSide(Node *node);
bool testOtherSide(Node *na1, Node *nb1, double &startDist2);
TPointD computeCenter(Node *na, Node *nb, double &r);
bool isHole(Node *startNode);
void traceLine(DataPixel *pix); // , vector<TThickPoint> &points);
TPoint computeGradient(DataPixel *pix)
{
assert(m_dataRaster);
const int wrap = m_dataRaster->getWrap();
TPoint g(0, 0);
int n, s, w, e, nw, sw, ne, se;
w = pix[-1].m_value;
nw = pix[-1 + wrap].m_value;
sw = pix[-1 - wrap].m_value;
e = pix[+1].m_value;
ne = pix[+1 + wrap].m_value;
se = pix[+1 - wrap].m_value;
n = pix[+wrap].m_value;
s = pix[-wrap].m_value;
g.y = -sw + ne - se + nw + 2 * (n - s);
g.x = -sw + ne + se - nw + 2 * (e - w);
return g;
}
CenterLineVectorizer(const VectorizerConfiguration &configuration, TPalette *palette)
: m_configuration(configuration), m_palette(palette) {}
~CenterLineVectorizer();
void clearNodes();
void createNodes();
void clearJunctions();
void makeOutputRaster();
void makeDataRaster(const TRasterP &src);
DataPixel *findUnvisitedInkPixel();
bool linkNextProtoStroke(
ProtoStroke *const dstProtoStroke,
Junction *const currJunction,
const int k);
void joinProtoStrokes(ProtoStroke *const dstProtoStroke);
void resolveUnvisitedNode(Node *node);
Junction *mergeJunctions(const std::list<JunctionMerge> &junctions);
void joinJunctions();
void createJunctionPolygon(Junction *junction);
void handleLinks();
void handleJunctions();
void createStrokes();
void createRegions();
void vectorize();
void init();
// void click(const TPoint &p);
Node *createNode(DataPixel *pix);
void link(DataPixel *pix, DataPixel *from, DataPixel *to);
/*#ifdef DEBUG
inline TPixel32 &getOutPix(DataPixel*pix) {return
m_output->pixels()[pix->m_index]; }
void outputNodes(Node *node);
void outputInks();
#endif*/
private:
// not implemented
CenterLineVectorizer(const CenterLineVectorizer &);
CenterLineVectorizer &operator=(const CenterLineVectorizer &);
};
//=========================================================
class CompareJunctionNodes
{
TPointD m_center;
public:
CompareJunctionNodes(TPointD center)
: m_center(center) {}
bool operator()(const Node *n1, const Node *n2)
{
TPointD p1 = convert(n1->m_pixel->m_pos) - m_center;
TPointD p2 = convert(n2->m_pixel->m_pos) - m_center;
double alpha1, alpha2;
if (p1.x > 0)
alpha1 = -p1.y / sqrt(norm2(p1));
else if (p1.x < 0)
alpha1 = 2 + p1.y / sqrt(norm2(p1));
else //(p1.x = 0)
{
if (p1.y > 0)
alpha1 = -1;
else if (p1.y < 0)
alpha1 = 1;
else
assert(true);
}
if (p2.x > 0)
alpha2 = -p2.y / sqrt(norm2(p2));
else if (p2.x < 0)
alpha2 = 2 + p2.y / sqrt(norm2(p2));
else //(p2.x = 0)
{
if (p2.y > 0)
alpha2 = -1;
else if (p2.y < 0)
alpha2 = 1;
else
assert(true);
}
if (alpha2 - alpha1 > 0)
return true;
else if (alpha2 - alpha1 < 0)
return false;
else
return false; // n1->m_pixel->m_pos == n2->m_pixel->m_pos!!
}
};
//---------------------------------------------------------
//---------------------------------------------------------
inline bool collinear(const TPointD &a, const TPointD &b, const TPointD &c)
{
double area = (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
return area == 0;
}
//---------------------------------------------------------
inline bool right(const TPointD &a, const TPointD &b, const TPointD &c)
{
double area = (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
return area < 0;
}
//---------------------------------------------------------
enum RectIntersectionResult {
parallel,
coincident,
intersected
};
RectIntersectionResult rectsIntersect(const TPointD &a1, const TPointD &a2,
const TPointD &b1, const TPointD &b2,
TPointD &intersection)
{
double ma, mb, ca, cb;
if (a2.x == a1.x && b2.x == b1.x) {
if (collinear(a1, a2, b1) &&
collinear(a1, a2, b2))
return coincident;
else
return parallel;
} else if (a1.x == a2.x) {
mb = (b2.y - b1.y) / (b2.x - b1.x);
cb = b1.y - mb * b1.x;
intersection.x = a1.x;
intersection.y = mb * intersection.x + cb;
return intersected;
} else if (b1.x == b2.x) {
ma = (a2.y - a1.y) / (a2.x - a1.x);
ca = a1.y - ma * a1.x;
intersection.x = b1.x;
intersection.y = ma * intersection.x + ca;
return intersected;
} else {
ma = (a2.y - a1.y) / (a2.x - a1.x);
mb = (b2.y - b1.y) / (b2.x - b1.x);
if (ma == mb) {
if (collinear(a1, a2, b1) &&
collinear(a1, a2, b2))
return coincident;
else
return parallel;
}
ca = a1.y - ma * a1.x;
cb = b1.y - mb * b1.x;
intersection.x = (ca - cb) / (mb - ma);
intersection.y = ma * intersection.x + ca;
return intersected;
}
}
//---------------------------------------------------------
//---------------------------------------------------------
bool Junction::isConvex()
{
int nonConvexAngles = 0;
assert(m_nodes.size() > 2);
std::deque<Node *>::iterator it = m_nodes.begin();
std::deque<Node *>::iterator it_e = m_nodes.end() - 2;
for (; it != it_e; ++it) {
if (right(
convert((*(it))->m_pixel->m_pos),
convert((*(it + 1))->m_pixel->m_pos),
convert((*(it + 2))->m_pixel->m_pos)))
nonConvexAngles++;
if (nonConvexAngles > 1)
return false;
}
if (right(
convert((*(it))->m_pixel->m_pos),
convert((*(it + 1))->m_pixel->m_pos),
convert((*(m_nodes.begin()))->m_pixel->m_pos)))
nonConvexAngles++;
if (nonConvexAngles > 1)
return false;
return true;
}
//---------------------------------------------------------
//---------------------------------------------------------
CenterLineVectorizer::~CenterLineVectorizer()
{
clearNodes();
clearJunctions();
#ifdef DEBUG
m_outlines.clear();
m_unvisitedNodes.clear();
m_junctionPolygons.clear();
#endif
m_links.clear();
m_protoStrokes.clear();
m_protoRegions.clear();
//m_protoHoles.clear();
}
//---------------------------------------------------------
void CenterLineVectorizer::clearNodes()
{
for (int i = 0; i < (int)m_nodes.size(); i++)
delete m_nodes[i];
m_nodes.clear();
}
//---------------------------------------------------------
void CenterLineVectorizer::clearJunctions()
{
for (int i = 0; i < (int)m_junctions.size(); i++)
delete m_junctions[i];
m_junctions.clear();
}
//---------------------------------------------------------
void CenterLineVectorizer::link(
DataPixel *pix,
DataPixel *srcPix,
DataPixel *dstPix)
{
Node *srcNode = 0, *dstNode = 0, *node = 0;
Node *tmp;
for (tmp = pix->m_node; tmp; tmp = tmp->m_other) {
if (tmp->m_pixel == 0)
continue;
if (tmp->m_prev && tmp->m_prev->m_pixel == srcPix) {
assert(srcNode == 0);
if (node) {
assert(node->m_next->m_pixel == dstPix);
assert(node->m_prev == 0);
node->m_prev = tmp->m_prev;
tmp->m_prev->m_next = node;
tmp->m_next = tmp->m_prev = 0;
tmp->m_pixel = 0;
return;
}
assert(tmp->m_next == 0);
srcNode = tmp->m_prev;
node = tmp;
}
if (tmp->m_next && tmp->m_next->m_pixel == dstPix) {
assert(dstNode == 0);
if (node) {
assert(node->m_prev->m_pixel == srcPix);
assert(node->m_next == 0);
node->m_next = tmp->m_next;
tmp->m_next->m_prev = node;
tmp->m_next = tmp->m_prev = 0;
tmp->m_pixel = 0;
return;
}
assert(tmp->m_prev == 0);
dstNode = tmp->m_next;
node = tmp;
}
}
if (!node)
node = createNode(pix);
if (!srcNode)
srcNode = createNode(srcPix);
if (!dstNode)
dstNode = createNode(dstPix);
if (!node->m_next) {
node->m_next = dstNode;
assert(dstNode->m_prev == 0);
dstNode->m_prev = node;
}
if (!node->m_prev) {
node->m_prev = srcNode;
assert(srcNode->m_next == 0);
srcNode->m_next = node;
}
assert(node->m_next == dstNode);
assert(node->m_prev == srcNode);
assert(dstNode->m_prev == node);
assert(srcNode->m_next == node);
}
//---------------------------------------------------------
inline int colorDistance2(const TPixel32 &c0, const TPixel32 &c1)
{
return ((c0.r - c1.r) * (c0.r - c1.r) + (c0.g - c1.g) * (c0.g - c1.g) + (c0.b - c1.b) * (c0.b - c1.b));
}
//---------------------------------------------------------
#define MAX_TOLERANCE 20
#include "tcolorstyles.h"
void CenterLineVectorizer::makeDataRaster(const TRasterP &src)
{
m_vimage = new TVectorImage();
if (!src)
return;
m_src = src;
clearNodes();
clearJunctions();
int ii, x, y = 0;
TRaster32P srcRGBM = (TRaster32P)m_src;
TRasterCM32P srcCM = (TRasterCM32P)m_src;
TRasterGR8P srcGR = (TRasterGR8P)m_src;
DataRasterP dataRaster(m_src->getSize().lx + 2, m_src->getSize().ly + 2);
int ly = dataRaster->getLy();
int lx = dataRaster->getLx();
int wrap = dataRaster->getWrap();
DataPixel *dataPix0 = dataRaster->pixels(0);
DataPixel *dataPix1 = dataRaster->pixels(0) + m_src->getLx() + 1;
for (y = 0; y < ly; y++, dataPix0 += wrap, dataPix1 += wrap) {
dataPix0->m_pos.x = 0;
dataPix1->m_pos.x = lx - 1;
dataPix0->m_pos.y = dataPix1->m_pos.y = y;
dataPix0->m_value = dataPix1->m_value = 0;
dataPix0->m_ink = dataPix1->m_ink = false;
dataPix0->m_node = dataPix1->m_node = 0;
}
dataPix0 = dataRaster->pixels(0);
dataPix1 = dataRaster->pixels(ly - 1);
for (x = 0; x < lx; x++, dataPix0++, dataPix1++) {
dataPix0->m_pos.x = dataPix1->m_pos.x = x;
dataPix0->m_pos.y = 0;
dataPix1->m_pos.y = ly - 1;
dataPix0->m_value = dataPix1->m_value = 0;
dataPix0->m_ink = dataPix1->m_ink = false;
dataPix0->m_node = dataPix1->m_node = 0;
}
if (srcRGBM) {
assert(m_palette);
int inkId = m_palette->addStyle(m_configuration.m_inkColor);
m_dataRasterArray.push_back(pair<int, DataRasterP>(inkId, dataRaster));
int maxDistance2 = m_configuration.m_threshold * m_configuration.m_threshold;
for (y = 0; y < m_src->getLy(); y++) {
TPixel32 *inPix = srcRGBM->pixels(y);
TPixel32 *inEndPix = inPix + srcRGBM->getLx();
DataPixel *dataPix = dataRaster->pixels(y + 1) + 1;
x = 0;
while (inPix < inEndPix) {
*dataPix = DataPixel();
int distance2 = colorDistance2(m_configuration.m_inkColor, *inPix);
//int value = (inPix->r + 2*inPix->g + inPix->b)>>2;
if (y == 0 || y == m_src->getLy() - 1 || x == 0 || x == m_src->getLx() - 1) {
dataPix->m_value = 255;
dataPix->m_ink = false;
} else {
dataPix->m_value = (inPix->r + 2 * inPix->g + inPix->b) >> 2;
dataPix->m_ink = (distance2 < maxDistance2);
}
dataPix->m_pos.x = x++;
dataPix->m_pos.y = y;
dataPix->m_node = 0;
//dataPix->m_index = index++;
inPix++;
dataPix++;
}
}
} else if (srcGR) {
assert(m_palette);
int inkId = m_palette->addStyle(m_configuration.m_inkColor);
m_dataRasterArray.push_back(pair<int, DataRasterP>(inkId, dataRaster));
int threshold = m_configuration.m_threshold;
for (y = 0; y < m_src->getLy(); y++) {
TPixelGR8 *inPix = srcGR->pixels(y);
TPixelGR8 *inEndPix = inPix + srcGR->getLx();
DataPixel *dataPix = dataRaster->pixels(y + 1) + 1;
x = 0;
while (inPix < inEndPix) {
*dataPix = DataPixel();
//int distance2 = colorDistance2(m_configuration.m_inkColor, *inPix);
//int value = (inPix->r + 2*inPix->g + inPix->b)>>2;
if (y == 0 || y == m_src->getLy() - 1 || x == 0 || x == m_src->getLx() - 1) {
dataPix->m_value = 255;
dataPix->m_ink = false;
} else {
dataPix->m_value = inPix->value;
dataPix->m_ink = (inPix->value < threshold);
}
dataPix->m_pos.x = x++;
dataPix->m_pos.y = y;
dataPix->m_node = 0;
//dataPix->m_index = index++;
inPix++;
dataPix++;
}
}
}
else if (srcCM) {
int currInk, nextInk = 0;
do {
int threshold = m_configuration.m_threshold; //tolerance: 1->MAX thresh: 1-255
currInk = nextInk;
nextInk = 0;
m_dataRasterArray.push_back(pair<int, DataRasterP>(currInk, dataRaster));
// inizializza la parte centrale
for (y = 0; y < srcCM->getLy(); y++) {
TPixelCM32 *inPix = srcCM->pixels(y);
TPixelCM32 *inEndPix = inPix + m_src->getLx();
DataPixel *dataPix = dataRaster->pixels(y + 1) + 1;
x = 0;
while (inPix < inEndPix) {
*dataPix = DataPixel();
int value = inPix->getTone();
if (value < 255 && !m_configuration.m_ignoreInkColors) {
int ink = inPix->getInk();
if (currInk == 0) {
currInk = ink;
m_dataRasterArray.back().first = ink;
} else if (ink != currInk) {
value = 255;
if (nextInk == 0) {
for (ii = 0; ii < (int)m_dataRasterArray.size() - 1; ii++)
if (m_dataRasterArray[ii].first == ink)
break;
if (ii == (int)m_dataRasterArray.size() - 1)
nextInk = ink;
}
}
}
//TPixel col = m_palette->getStyle(inPix->getInk())->getMainColor();
dataPix->m_pos.x = x++;
dataPix->m_pos.y = y;
dataPix->m_value = value;
dataPix->m_ink = (value < threshold);
dataPix->m_node = 0;
//dataPix->m_index = index++;
inPix++;
dataPix++;
}
}
} while (nextInk != 0);
if (m_configuration.m_ignoreInkColors) {
assert(m_dataRasterArray.size() == 1);
m_dataRasterArray.back().first = 1;
}
} else
assert(false);
}
void CenterLineVectorizer::init()
{
int y;
/*m_links.clear();
m_protoStrokes.clear();
m_protoRegions.clear();
clearNodes();
clearJunctions();*/
DataRasterP dataRaster = m_dataRaster;
const int wrap = dataRaster->getWrap();
const int delta[] = {-wrap - 1, -wrap, -wrap + 1, 1, wrap + 1, wrap, wrap - 1, -1};
for (y = 1; y < dataRaster->getLy() - 1; y++) {
DataPixel *pix = dataRaster->pixels(y);
DataPixel *endPix = pix + dataRaster->getLx() - 1;
pix++;
for (pix++; pix < endPix; ++pix) {
if ((pix->m_ink == false) ||
(pix[-wrap].m_ink && pix[wrap].m_ink &&
pix[-1].m_ink && pix[1].m_ink))
continue;
int i;
for (i = 0; i < 8; i++)
if (pix[delta[i]].m_ink && pix[delta[(i + 1) & 0x7]].m_ink == false)
break;
int start = i;
if (i == 8)
continue; // punto isolato
for (;;) {
int j = (i + 1) & 0x7;
assert(i < 8 && pix[delta[i]].m_ink);
assert(j < 8 && pix[delta[j]].m_ink == false);
do
j = (j + 1) & 0x7;
while (pix[delta[j]].m_ink == false);
assert(j < 8 && pix[delta[j]].m_ink);
if (((i + 2) & 0x7) != j || (i & 1) == 0) {
// il bianco comprende anche un fianco
link(pix, pix + delta[i], pix + delta[j]);
}
i = j;
assert(i < 8);
while (pix[delta[(i + 1) & 0x7]].m_ink)
i = (i + 1) & 0x7;
assert(i < 8 && pix[delta[i]].m_ink);
assert(pix[delta[(i + 1) & 0x7]].m_ink == false);
if (i == start)
break;
}
}
}
}
/*
#ifdef DEBUG
int i;
for(i = 0;i<(int)m_nodes.size();i++)
{
Node *node = m_nodes[i];
if(node->m_pixel==0) continue;
assert(node->m_prev);
assert(node->m_next);
assert(node->m_prev->m_next == node);
assert(node->m_next->m_prev == node);
}
for(i = 0;i<m_dataRaster->getLx()*m_dataRaster->getLy(); i++)
{
DataPixel *pix = m_dataRaster->pixels()+i;
for(Node *node = pix->m_node; node; node=node->m_other)
{
if(node->m_pixel==0) continue;
assert(node->m_pixel == pix);
assert(node->m_prev);
assert(node->m_next);
assert(node->m_prev->m_next == node);
assert(node->m_next->m_prev == node);
}
}
#endif
*/
//---------------------------------------------------------
TPointD CenterLineVectorizer::computeCenter(Node *na, Node *nb, double &r)
{
TPointD pa = convert(na->m_pixel->m_pos);
TPointD pb = convert(nb->m_pixel->m_pos);
r = THICKNESS_LIMIT;
if (pa == pb)
return pa;
TPointD center((pa + pb) * 0.5);
r = norm(pa - pb) * 0.5;
return center;
/* double vsum = 0.0;
TPointD d = pa-pb;
if(fabs(d.x)>fabs(d.y))
{
if(pa.x>pb.x) tswap(pa,pb);
for(int x = pa.x; x<=pb.x; x++)
{
int y = pa.y + (pb.y-pa.y)*(x-pa.x)/(pb.x-pa.x);
int v = 255-m_dataRaster->pixels(y)[x].m_value;
center += v * TPointD(x,y);
vsum += v;
}
}
else
{
if(pa.y>pb.y) tswap(pa,pb);
for(int y = pa.y; y<=pb.y; y++)
{
int x = pa.x + (pb.x-pa.x)*(y-pa.y)/(pb.y-pa.y);
int v = 255-m_dataRaster->pixels(y)[x].m_value;
center += v * TPointD(x,y);
vsum += v;
}
}
assert(vsum>0);
r = 0.5*vsum/255.0;
return center * (1/vsum);
*/
}
//---------------------------------------------------------
double computeDistance2(Node *na, Node *nb)
{
assert(na->m_pixel);
assert(nb->m_pixel);
TPointD d = convert(na->m_pixel->m_pos - nb->m_pixel->m_pos);
return d * d;
}
//---------------------------------------------------------
Node *CenterLineVectorizer::findOtherSide(Node *node)
{
DataPixel *pix = node->m_pixel;
TPoint dir = -computeGradient(pix);
if (dir == TPoint(0, 0))
return 0;
TPoint d1(tsign(dir.x), 0), d2(0, tsign(dir.y));
int num = abs(dir.y), den = abs(dir.x);
if (num > den) {
tswap(d1, d2);
tswap(num, den);
}
TPoint pos = pix->m_pos;
int i;
for (i = 0;; i++) {
TPoint q(pos.x + d1.x * i + d2.x * num * i / den, pos.y + d1.y * i +
d2.y * num * i / den);
//if (!m_dataRaster->getBounds().contains(q)) break;
DataPixel *nextPix = m_dataRaster->pixels(q.y) + q.x;
if (nextPix->m_ink == false)
break;
pix = nextPix;
}
assert(pix);
if (!pix->m_node) {
const int wrap = m_dataRaster->getWrap();
if (pix[-1].m_node)
pix--;
else if (pix[1].m_node)
pix++;
else if (pix[wrap].m_node)
pix += wrap;
else if (pix[-wrap].m_node)
pix -= wrap;
else {
assert(0);
}
}
if (!pix->m_node)
return 0;
Node *q = pix->m_node;
while (q->m_pixel == 0 && q->m_other)
q = q->m_other;
assert(q && q->m_pixel == pix);
for (i = 0; i < 5; i++) {
if (!q->m_prev)
break;
q = q->m_prev;
}
Node *best = q;
double bestDist2 = computeDistance2(q, node);
for (i = 0; i < 10; i++) {
q = q->m_next;
if (!q)
break;
double dist2 = computeDistance2(q, node);
if (dist2 < bestDist2) {
bestDist2 = dist2;
best = q;
}
}
return best;
}
//---------------------------------------------------------
TPointD findDirection(Node *na, Node *nb, int skip)
{
for (int i = 0; i < skip; i++) {
na = na->m_next;
nb = nb->m_prev;
}
TPointD p0 = 0.5 * (convert(na->m_pixel->m_pos) + convert(nb->m_pixel->m_pos));
na = na->m_next;
nb = nb->m_prev;
TPointD p1 = 0.5 * (convert(na->m_pixel->m_pos) + convert(nb->m_pixel->m_pos));
na = na->m_next;
nb = nb->m_prev;
TPointD p2 = 0.5 * (convert(na->m_pixel->m_pos) + convert(nb->m_pixel->m_pos));
TPointD dir = 0.25 * (3 * (p1 - p0) + (p2 - p1));
double dirn = norm(dir);
if (dirn > 0)
return dir * (1 / dirn);
else
return dir;
}
//---------------------------------------------------------
void setEndpointsDirections(ProtoStroke &protoStroke)
{
assert(!protoStroke.m_points.empty());
int size = protoStroke.m_points.size();
double startThickness = 0, endThickness = 0;
if (size == 1)
return;
if (size < 5) {
protoStroke.m_startDirection = protoStroke.m_points[0] -
protoStroke.m_points[1];
protoStroke.m_endDirection = protoStroke.m_points[size - 1] -
protoStroke.m_points[size - 2];
} else if (size < 10) {
assert(protoStroke.m_points.front() != protoStroke.m_points.back());
protoStroke.m_startDirection = protoStroke.m_points[0] -
protoStroke.m_points[2];
protoStroke.m_endDirection = protoStroke.m_points[size - 1] -
protoStroke.m_points[size - 3];
startThickness = 0.5 * (protoStroke.m_points[1].thick +
protoStroke.m_points[2].thick);
endThickness = 0.5 * (protoStroke.m_points[size - 2].thick +
protoStroke.m_points[size - 3].thick);
} else {
protoStroke.m_startDirection = 4 * protoStroke.m_points[0];
protoStroke.m_endDirection = 4 * protoStroke.m_points[size - 1];
for (int i = 0; i < 4; ++i) {
protoStroke.m_startDirection -= protoStroke.m_points[3 + i];
protoStroke.m_endDirection -= protoStroke.m_points[size - 4 - i];
startThickness += protoStroke.m_points[i].thick;
endThickness += protoStroke.m_points[size - i - 1].thick;
}
protoStroke.m_startDirection = protoStroke.m_startDirection * (1 / 4.0);
protoStroke.m_endDirection = protoStroke.m_endDirection * (1 / 4.0);
startThickness *= (1 / 4.0);
endThickness *= (1 / 4.0);
}
double startNorm = norm(protoStroke.m_startDirection);
if (startNorm)
protoStroke.m_startDirection = protoStroke.m_startDirection *
(1 / startNorm);
double endNorm = norm(protoStroke.m_endDirection);
if (endNorm)
protoStroke.m_endDirection = protoStroke.m_endDirection * (1 / endNorm);
if (startThickness != 0)
protoStroke.m_points[0].thick = protoStroke.m_points[1].thick =
protoStroke.m_points[2].thick = startThickness;
if (endThickness != 0)
protoStroke.m_points[size - 1].thick = protoStroke.m_points[size - 2].thick =
protoStroke.m_points[size - 3].thick = endThickness;
}
//---------------------------------------------------------
bool CenterLineVectorizer::testOtherSide(Node *na1, Node *nb1, double
&startDist2)
{
if (na1->m_pixel->m_pos == nb1->m_pixel->m_pos || na1->m_next == nb1 || na1->m_prev == nb1 || na1->m_next->m_next == nb1 || na1->m_prev->m_prev == nb1)
return false;
Node *na2 = na1->m_next;
for (int i = 1; i < 3; ++i) {
na2 = na2->m_next;
Node *nb2 = findOtherSide(na2);
if (nb2 == 0 && i == 3)
return true;
if (nb2 == 0)
continue;
double newStartDist2 = computeDistance2(na2, nb2);
if (newStartDist2 > startDist2)
startDist2 = newStartDist2;
for (int j = 0; j < 3 * i + 1; ++j) {
if (nb2 == nb1)
return true;
nb2 = nb2->m_next;
}
}
return false;
}
//---------------------------------------------------------
/*
bool CenterLineVectorizer::isHole(Node *startNode)
{
Node *node = startNode;
for(int i=0; i<20; ++i)
{
node = node->m_next;
if(node == startNode)
{
std::vector<TThickPoint> points;
do
{
node = node->m_next;
node->m_visited = true;
node->m_flag = true;
points.push_back(convert(node->m_pixel->m_pos));
}
while(node != startNode);
m_protoHoles.push_back(points);
return true;
}
}
return false;
}
*/
//---------------------------------------------------------
bool isJunction(const Node *na, const Node *nb)
{
TPointD pa = convert(na->m_pixel->m_pos);
TPointD pb = convert(nb->m_pixel->m_pos);
Node *na0 = na->m_prev;
Node *na1 = na->m_next;
Node *nb0 = nb->m_next;
Node *nb1 = nb->m_prev;
TPointD da = convert(na1->m_pixel->m_pos) - pa;
TPointD db = convert(nb1->m_pixel->m_pos) - pb;
TPointD da0 = pa - convert(na0->m_pixel->m_pos);
TPointD db0 = pb - convert(nb0->m_pixel->m_pos);
if ((da0.x * da.x + da0.y * da.y) / (norm(da0) * norm(da)) <= 0) {
return true;
}
if ((db0.x * db.x + db0.y * db.y) / (norm(db0) * norm(db)) <= 0) {
return true;
}
if (right(TPointD(0, 0), da, db)) {
if ((da.x * db.x + da.y * db.y) / (norm(da) * norm(db)) <= 0) {
return true;
}
} else {
if ((da.x * db.x + da.y * db.y) / (norm(da) * norm(db)) <= -0.5) {
return true;
}
}
return false;
}
//---------------------------------------------------------
void CenterLineVectorizer::traceLine(DataPixel *pix)
{
Junction *startJunction = 0;
Junction *endJunction = 0;
assert(m_dataRaster);
const int wrap = m_dataRaster->getWrap();
// TRect bounds = m_dataRaster->getBounds();
if (!pix->m_ink)
return;
while (pix->m_node == 0)
pix -= wrap;
Node *node = pix->m_node;
while (node && node->m_pixel == 0 && node->m_other)
node = node->m_other;
assert(node && node->m_pixel == pix);
Node *naa = node;
bool isSamePixel;
if (node->m_other && node->m_other->m_pixel && (node->m_pixel->m_pos ==
node->m_other->m_pixel->m_pos)) {
node = node->m_other;
isSamePixel = true;
} else {
node = findOtherSide(node);
isSamePixel = false;
}
if (node == 0)
return;
Node *nbb = node;
if (naa->m_visited || nbb->m_visited)
return;
double startDist2 = computeDistance2(naa, nbb);
if (startDist2 > 2000)
return;
if (startDist2 < THICKNESS_LIMIT_2)
startDist2 = THICKNESS_LIMIT_2;
//try to detect errors in findOtherSide
if (!isSamePixel && !testOtherSide(naa, nbb, startDist2))
return;
double minDist2 = 0;
double maxDist2 = startDist2 + 3.0;
if (startDist2 > 36) {
minDist2 = startDist2 / 2;
maxDist2 = startDist2 + 0.25 * startDist2;
}
if (naa->m_next == nbb || naa->m_prev == nbb)
return;
naa->m_visited = nbb->m_visited = true;
std::deque<TThickPoint> dpoints;
for (int k = 0; k < 2; k++) {
Node *na = naa;
Node *nb = nbb;
for (;;) {
TPoint &pa = na->m_pixel->m_pos;
TPoint &pb = nb->m_pixel->m_pos;
TPoint ba = pb - pa;
Node *na1 = na->m_next;
Node *nb1 = nb->m_prev;
//if (!na1 || !nb1) break;
TPoint da = na1->m_pixel->m_pos - pb;
TPoint db = nb1->m_pixel->m_pos - pa;
if (na1->m_junction || nb1->m_junction) {
na1->m_visited = true;
nb1->m_visited = true;
TPointD p1;
if (na1->m_junction && nb1->m_junction) {
// assert(na1->m_junction == nb1->m_junction);
} else {
if (na1->m_junction) {
p1 = convert(nb1->m_pixel->m_pos);
nb1->m_junction = na1->m_junction;
na1->m_junction->m_nodes.push_front(nb1);
} else {
p1 = convert(na1->m_pixel->m_pos);
na1->m_junction = nb1->m_junction;
nb1->m_junction->m_nodes.push_back(na1);
}
}
double r;
TPointD center;
TThickPoint point;
center = computeCenter(na, nb, r);
if (r < THICKNESS_LIMIT)
r = THICKNESS_LIMIT;
point = TThickPoint(center, r);
if (k == 0)
dpoints.push_front(point);
else
dpoints.push_back(point);
center = computeCenter(na1, nb1, r);
if (r < THICKNESS_LIMIT)
r = THICKNESS_LIMIT;
point = TThickPoint(center, r);
if (k == 0)
dpoints.push_front(point);
else
dpoints.push_back(point);
if (k == 0)
startJunction = na1->m_junction;
else
endJunction = na1->m_junction;
break;
}
// if(da*ba>-db*ba)
if (norm2(db) >= norm2(da)) {
if (na1->m_visited)
break;
na = na1;
na->m_visited = true;
#ifdef DEBUG
getOutPix(na->m_pixel) = TPixel32::Red;
#endif
} else {
if (nb1->m_visited)
break;
nb = nb1;
nb->m_visited = true;
#ifdef DEBUG
getOutPix(nb->m_pixel) = TPixel32::Green;
#endif
}
double distance2 = computeDistance2(na, nb);
if (distance2 < 0.25)
distance2 = 0.25;
double r;
TPointD center = computeCenter(na, nb, r);
if (r < THICKNESS_LIMIT)
r = THICKNESS_LIMIT;
TThickPoint point(center, r);
TPointI pos = convert(center);
//TPixel32 *inPix = m_src->pixels(pos.y);
//inPix += pos.x;
//int value = (inPix->r + 2*inPix->g + inPix->b)>>2;
if (distance2 > maxDist2 || distance2 < minDist2 || na->m_next == nb || na->m_prev == nb
//|| isJunction(na, nb)
//|| !(value<200)
) {
if (na->m_next == nb || na->m_prev == nb || na->m_next->m_next == nb ||
na->m_prev->m_prev == nb) {
if (k == 0) {
if (!dpoints.empty())
dpoints.pop_front();
if (!dpoints.empty())
dpoints.pop_front();
} else {
if (!dpoints.empty())
dpoints.pop_back();
if (!dpoints.empty())
dpoints.pop_back();
}
}
// if(k==0) dpoints.push_front(point);
// else dpoints.push_back(point);
na->m_junction = nb->m_junction = new Junction();
na->m_junction->m_nodes.push_back(nb);
nb->m_junction->m_nodes.push_back(na);
m_junctions.push_back(na->m_junction);
if (k == 0)
startJunction = na->m_junction;
else
endJunction = na->m_junction;
break;
}
if (k == 0)
dpoints.push_front(point);
else
dpoints.push_back(point);
}
tswap(naa, nbb);
}
if (dpoints.size() == 0)
naa->m_visited = nbb->m_visited = false;
else {
m_protoStrokes.push_back(ProtoStroke(dpoints.begin(), dpoints.end()));
setEndpointsDirections(m_protoStrokes.back());
if (startJunction) {
m_protoStrokes.back().m_startJunction = startJunction;
startJunction->m_protoStrokes.push_back(&m_protoStrokes.back());
}
if (endJunction) {
m_protoStrokes.back().m_endJunction = endJunction;
endJunction->m_protoStrokes.push_back(&m_protoStrokes.back());
}
}
}
//---------------------------------------------------------
Node *CenterLineVectorizer::createNode(DataPixel *pix)
{
Node *node = new Node();
node->m_pixel = pix;
node->m_other = pix->m_node;
pix->m_node = node;
m_nodes.push_back(node);
return node;
}
//---------------------------------------------------------
void CenterLineVectorizer::createNodes()
{
}
//---------------------------------------------------------
#ifdef DEBUG
void CenterLineVectorizer::outputNodes(Node *node)
{
std::vector<TThickPoint> points;
Node *start = node, *curr = node;
int i = 0;
do {
TThickPoint point(convert(curr->m_pixel->m_pos), 0);
points.push_back(point);
curr->m_flag = true;
assert(curr->m_next);
curr = curr->m_next;
i++;
} while (curr != start);
TThickPoint point(convert(curr->m_pixel->m_pos), 0);
points.push_back(point);
m_outlines.push_back(points);
}
#endif
//---------------------------------------------------------
bool CenterLineVectorizer::linkNextProtoStroke(
ProtoStroke *const dstProtoStroke,
Junction *const currJunction,
int k)
{
assert(dstProtoStroke);
assert(currJunction);
// if(dstProtoStroke->m_startJunction == dstProtoStroke->m_endJunction)
return false;
if (k == 0 && dstProtoStroke->m_startJunction->m_locked ||
k == 1 && dstProtoStroke->m_endJunction->m_locked)
return false;
ProtoStroke *srcProtoStroke = 0;
Junction *nextJunction = 0;
std::vector<ProtoStroke *>::iterator it;
std::vector<ProtoStroke *>::iterator it_e =
currJunction->m_protoStrokes.end();
std::vector<ProtoStroke *>::iterator it_candidate = it_e;
double candidateProbability = JOIN_LIMIT;
int candidate_k;
for (it = currJunction->m_protoStrokes.begin(); it != it_e; it++) {
//erase dstProtoStroke in currJunction
if (*it == dstProtoStroke) {
it = currJunction->m_protoStrokes.erase(it);
it_e = currJunction->m_protoStrokes.end();
if (candidateProbability == JOIN_LIMIT)
it_candidate = it_e;
if (it == it_e)
break;
}
double probability;
int next_k;
if (((*it))->m_startJunction == currJunction)
next_k = 0;
else if ((*it)->m_endJunction == currJunction)
next_k = 1;
else
assert(false);
if (k == 0) {
if (next_k == 0)
probability = 1 - norm2(dstProtoStroke->m_startDirection +
(*it)->m_startDirection);
else
probability = 1 - norm2(dstProtoStroke->m_startDirection +
(*it)->m_endDirection);
} else {
if (next_k == 0)
probability = 1 - norm2(dstProtoStroke->m_endDirection +
(*it)->m_startDirection);
else
probability = 1 - norm2(dstProtoStroke->m_endDirection +
(*it)->m_endDirection);
}
if (probability > candidateProbability ||
// currJunction->m_junctionOrder == 2 ||
(*it)->m_points.size() < 3) {
it_candidate = it;
candidateProbability = probability;
candidate_k = next_k;
}
}
if (it_candidate == it_e)
return false;
srcProtoStroke = *it_candidate;
assert(srcProtoStroke);
if ((*it_candidate)->m_startJunction == (*it_candidate)->m_endJunction)
return false;
/* if(k==0)
{
if( candidate_k == 0 && dstProtoStroke->m_startJunction ==
(*it_candidate)->m_endJunction ||
candidate_k == 1 && dstProtoStroke->m_startJunction ==
(*it_candidate)->m_startJunction )
return false;
}
else if(k==1)
{
if( candidate_k == 0 && dstProtoStroke->m_endJunction ==
(*it_candidate)->m_endJunction ||
candidate_k == 1 && dstProtoStroke->m_endJunction ==
(*it_candidate)->m_startJunction )
return false;
}
*/
if (candidate_k == 0)
nextJunction = (*it_candidate)->m_endJunction;
else
nextJunction = (*it_candidate)->m_startJunction;
if (k == 0) {
if (candidate_k == 0) {
dstProtoStroke->m_points.insert(
dstProtoStroke->m_points.begin(),
srcProtoStroke->m_points.rbegin(),
srcProtoStroke->m_points.rend());
} else {
dstProtoStroke->m_points.insert(
dstProtoStroke->m_points.begin(),
srcProtoStroke->m_points.begin(),
srcProtoStroke->m_points.end());
}
} else {
if (candidate_k == 0) {
dstProtoStroke->m_points.insert(
dstProtoStroke->m_points.end(),
srcProtoStroke->m_points.begin(),
srcProtoStroke->m_points.end());
} else {
dstProtoStroke->m_points.insert(
dstProtoStroke->m_points.end(),
srcProtoStroke->m_points.rbegin(),
srcProtoStroke->m_points.rend());
}
}
srcProtoStroke->m_points.clear();
srcProtoStroke->m_startJunction = 0;
srcProtoStroke->m_endJunction = 0;
//refresh currJunction
currJunction->m_protoStrokes.erase(it_candidate);
//refresh nextJunction
if (nextJunction) {
it = std::find(
nextJunction->m_protoStrokes.begin(),
nextJunction->m_protoStrokes.end(),
srcProtoStroke);
assert(it != nextJunction->m_protoStrokes.end());
nextJunction->m_protoStrokes.erase(it);
nextJunction->m_protoStrokes.push_back(dstProtoStroke);
}
if (k == 0) {
dstProtoStroke->m_startJunction = nextJunction;
if (candidate_k == 0)
dstProtoStroke->m_startDirection = srcProtoStroke->m_endDirection;
else
dstProtoStroke->m_startDirection = srcProtoStroke->m_startDirection;
} else {
dstProtoStroke->m_endJunction = nextJunction;
if (candidate_k == 0)
dstProtoStroke->m_endDirection = srcProtoStroke->m_endDirection;
else
dstProtoStroke->m_endDirection = srcProtoStroke->m_startDirection;
}
if (!nextJunction)
return false;
return true;
}
//---------------------------------------------------------
void CenterLineVectorizer::joinProtoStrokes(ProtoStroke *const
dstProtoStroke)
{
//std::deque<TThickPoint> &dstPoints = dstProtoStroke->m_points;
for (int k = 0; k < 2; k++) {
for (;;) {
Junction *currJunction;
if (k == 0 && !dstProtoStroke->m_startJunction)
break;
else if (k == 0)
currJunction = dstProtoStroke->m_startJunction;
else if (!dstProtoStroke->m_endJunction)
break;
else
currJunction = dstProtoStroke->m_endJunction;
if (!linkNextProtoStroke(dstProtoStroke, currJunction, k))
break;
}
}
std::vector<ProtoStroke *>::iterator it;
if (dstProtoStroke->m_startJunction) {
it = std::find(
dstProtoStroke->m_startJunction->m_protoStrokes.begin(),
dstProtoStroke->m_startJunction->m_protoStrokes.end(),
dstProtoStroke);
if (it != dstProtoStroke->m_startJunction->m_protoStrokes.end())
dstProtoStroke->m_startJunction->m_protoStrokes.erase(it);
dstProtoStroke->m_startJunction = 0;
}
if (dstProtoStroke->m_endJunction) {
it = std::find(
dstProtoStroke->m_endJunction->m_protoStrokes.begin(),
dstProtoStroke->m_endJunction->m_protoStrokes.end(),
dstProtoStroke);
if (it != dstProtoStroke->m_endJunction->m_protoStrokes.end())
dstProtoStroke->m_endJunction->m_protoStrokes.erase(it);
dstProtoStroke->m_endJunction = 0;
}
}
//---------------------------------------------------------
bool y_intersect(const double y0, const TPointD p1, const TPointD p2,
double &x0)
{
if ((y0 < p1.y && y0 < p2.y) ||
(y0 > p1.y && y0 > p2.y))
return false;
x0 = (p1.x * (p2.y - y0) + p2.x * (y0 - p1.y)) / (p2.y - p1.y);
return true;
}
bool isContained(TThickPoint point, std::deque<Node *> &polygon)
{
std::deque<Node *>::iterator it_b = polygon.begin();
std::deque<Node *>::iterator it_e = polygon.end();
std::deque<Node *>::iterator it;
int intersectionsNumber = 0;
for (it = it_b; it < it_e; ++it) {
double x;
TPointD p1, p2;
p1 = convert((*it)->m_pixel->m_pos);
if ((it + 1) == it_e)
p2 = convert((*it_b)->m_pixel->m_pos);
else
p2 = convert((*(it + 1))->m_pixel->m_pos);
if (point.y == p1.y || point.y == p2.y || p1.y == p2.y)
continue;
if (y_intersect(point.y, p1, p2, x) && x >= point.x)
++intersectionsNumber;
}
return (intersectionsNumber % 2 == 0) ? false : true;
}
//---------------------------------------------------------
Junction *CenterLineVectorizer::mergeJunctions(const std::list<JunctionMerge> &junctions)
{
Junction *newJunction = new Junction();
std::list<JunctionMerge>::const_iterator it_junction;
std::deque<Node *>::iterator it_startNode, it_endNode;
for (it_junction = junctions.begin(); it_junction != junctions.end();
++it_junction) {
newJunction->m_center += it_junction->m_junction->m_center;
std::deque<Node *>::iterator it_node;
if (it_junction->m_startNode == 0 && it_junction->m_endNode == 0) {
for (it_node = it_junction->m_junction->m_nodes.begin();
it_node != it_junction->m_junction->m_nodes.end(); ++it_node) {
(*it_node)->m_junction = newJunction;
newJunction->m_nodes.push_back(*it_node);
}
} else {
// if( isContained(it_junction->m_junction->m_center, newJunction->m_nodes) ) continue;
/* if( it_junction->m_junction->m_nodes.size() < 3)
{
std::vector<ProtoStroke*>::iterator it_protoStroke;
bool ignoreJunction = false;
for(it_protoStroke = it_junction->m_junction->m_protoStrokes.begin();
it_protoStroke!=it_junction->m_junction->m_protoStrokes.end();
++it_protoStroke)
{
if( (*it_protoStroke)->m_startJunction == newJunction ||
(*it_protoStroke)->m_endJunction == newJunction )
{
ignoreJunction = true;
break;
}
}
if(ignoreJunction) continue;
}
*/
it_startNode = std::find(newJunction->m_nodes.begin(),
newJunction->m_nodes.end(),
it_junction->m_startNode);
assert(it_startNode != newJunction->m_nodes.end());
it_endNode = std::find(it_junction->m_junction->m_nodes.begin(),
it_junction->m_junction->m_nodes.end(),
it_junction->m_endNode);
assert(it_endNode != it_junction->m_junction->m_nodes.end());
for (it_node = it_junction->m_junction->m_nodes.begin();
it_node != it_junction->m_junction->m_nodes.end(); ++it_node) {
(*it_node)->m_junction = newJunction;
}
if (it_junction->m_isNext) {
++it_startNode;
newJunction->m_nodes.insert(it_startNode,
it_junction->m_junction->m_nodes.begin(), it_endNode);
it_startNode = std::find(newJunction->m_nodes.begin(),
newJunction->m_nodes.end(),
it_junction->m_startNode);
assert(it_startNode != newJunction->m_nodes.end());
++it_startNode;
newJunction->m_nodes.insert(it_startNode, it_endNode,
it_junction->m_junction->m_nodes.end());
} else {
++it_endNode;
newJunction->m_nodes.insert(it_startNode,
it_junction->m_junction->m_nodes.begin(), it_endNode);
it_startNode = std::find(newJunction->m_nodes.begin(),
newJunction->m_nodes.end(),
it_junction->m_startNode);
assert(it_startNode != newJunction->m_nodes.end());
newJunction->m_nodes.insert(it_startNode, it_endNode,
it_junction->m_junction->m_nodes.end());
}
}
std::vector<ProtoStroke *>::iterator it_protoStroke;
for (it_protoStroke = it_junction->m_junction->m_protoStrokes.begin();
it_protoStroke != it_junction->m_junction->m_protoStrokes.end();
++it_protoStroke) {
if ((*it_protoStroke)->m_startJunction == it_junction->m_junction) {
(*it_protoStroke)->m_startJunction = newJunction;
newJunction->m_protoStrokes.push_back(*it_protoStroke);
}
if ((*it_protoStroke)->m_endJunction == it_junction->m_junction) {
(*it_protoStroke)->m_endJunction = newJunction;
newJunction->m_protoStrokes.push_back(*it_protoStroke);
}
}
std::vector<JunctionLink>::iterator it_links;
for (it_links = m_links.begin(); it_links != m_links.end(); ++it_links) {
if (it_links->m_first == it_junction->m_junction)
it_links->m_first =
newJunction;
if (it_links->m_second == it_junction->m_junction)
it_links->m_second =
newJunction;
}
//erase old junction
std::vector<Junction *>::iterator it;
it = std::find(
m_junctions.begin(),
m_junctions.end(),
it_junction->m_junction);
assert(it != m_junctions.end());
delete it_junction->m_junction;
m_junctions.erase(it);
}
double size = junctions.size();
newJunction->m_center = newJunction->m_center * (1 / size);
std::vector<ProtoStroke *>::iterator it_protoStroke;
for (it_protoStroke = newJunction->m_protoStrokes.begin();
it_protoStroke != newJunction->m_protoStrokes.end();
++it_protoStroke) {
if ((*it_protoStroke)->m_points.size() < 6 &&
(*it_protoStroke)->m_startJunction == newJunction &&
(*it_protoStroke)->m_endJunction == newJunction) {
(*it_protoStroke)->m_points.clear();
(*it_protoStroke)->m_startJunction = (*it_protoStroke)->m_endJunction =
0;
ProtoStroke *protoStroke = *it_protoStroke;
for (;;) {
std::vector<ProtoStroke *>::iterator it;
it = std::find(newJunction->m_protoStrokes.begin(),
newJunction->m_protoStrokes.end(),
protoStroke);
if (it == newJunction->m_protoStrokes.end())
break;
newJunction->m_protoStrokes.erase(it);
}
if (newJunction->m_protoStrokes.empty())
break;
it_protoStroke = newJunction->m_protoStrokes.begin();
}
}
return newJunction;
}
//---------------------------------------------------------
void CenterLineVectorizer::joinJunctions()
{
for (int i = 0; i < (int)m_junctions.size(); i++) {
Junction *currJunction = m_junctions[i];
// if(currJunction->m_nodes.size() <= 2) continue;
std::list<JunctionMerge> joinJunctions;
joinJunctions.push_back(JunctionMerge(currJunction));
// std::sort(currJunction->m_nodes.begin(), currJunction->m_nodes.end());
std::deque<Node *>::iterator it;
for (it = currJunction->m_nodes.begin(); it != currJunction->m_nodes.end();
it++) {
Node *currNode = *it;
Node *prevNode = *it;
Node *nextNode = *it;
std::vector<JunctionLink>::iterator it_link;
int j;
for (j = 0; true; ++j) {
prevNode = prevNode->m_prev;
prevNode->m_visited = true;
if (prevNode->m_junction != 0 && prevNode->m_junction != currJunction) {
//double junctionMaxDist = 3.5*currJunction->m_center.thick;
it_link = std::find(m_links.begin(), m_links.end(),
JunctionLink(currJunction, prevNode->m_junction));
/* if( j >= 1*SEARCH_WINDOW &&
norm(currJunction->m_center - prevNode->m_junction->m_center) >=
junctionMaxDist)
{
assert(false);
if(it_link == m_links.end())
m_links.push_back(JunctionLink(currJunction, prevNode->m_junction));
else
++(it_link->m_order);
}
else*/ if (it_link == m_links.end() &&
std::find(joinJunctions.begin(), joinJunctions.end(),
JunctionMerge(prevNode->m_junction)) == joinJunctions.end()) {
joinJunctions.push_back(JunctionMerge(prevNode->m_junction, currNode,
prevNode, false));
}
}
if (prevNode->m_visited)
break;
}
for (j = 0; true; ++j) {
nextNode = nextNode->m_next;
prevNode->m_visited = true;
if (nextNode->m_junction != 0 && nextNode->m_junction != currJunction) {
//double junctionMaxDist = 3.5*currJunction->m_center.thick;
it_link = std::find(m_links.begin(), m_links.end(),
JunctionLink(currJunction, nextNode->m_junction));
/* if( j >= 1*SEARCH_WINDOW &&
norm(currJunction->m_center - nextNode->m_junction->m_center) >=
junctionMaxDist )
{
assert(false);
if(it_link == m_links.end())
m_links.push_back(JunctionLink(currJunction, nextNode->m_junction));
else
++(it_link->m_order);
}
else*/ if (it_link == m_links.end() &&
std::find(joinJunctions.begin(), joinJunctions.end(),
JunctionMerge(nextNode->m_junction)) == joinJunctions.end()) {
joinJunctions.push_back(JunctionMerge(nextNode->m_junction, currNode,
nextNode, true));
}
}
if (nextNode->m_visited)
break;
}
}
if (joinJunctions.size() > 1) {
//erase duplicate junctions
// joinJunctions.sort();
// std::sort(joinJunctions.begin(), joinJunctions.end());
// std::list<JunctionMerge>::iterator it_newEnd;
// it_newEnd = std::unique(joinJunctions.begin(), joinJunctions.end());
// assert(it_newEnd == joinJunctions.end());
// joinJunctions.erase(it_newEnd, joinJunctions.end());
Junction *newJunction = mergeJunctions(joinJunctions);
assert(newJunction);
m_junctions.push_back(newJunction);
}
joinJunctions.clear();
}
}
//---------------------------------------------------------
/*
void CenterLineVectorizer::resolveUnvisitedNode(Node *node)
{
assert(node->m_visited == false);
assert(node->m_junction == 0);
JunctionLink link(0,0);
Node* currNode = node;
for(int i=0; i<4*SEARCH_WINDOW; i++)
{
currNode = currNode->m_next;
assert(currNode);
if(currNode->m_junction)
{
link.m_first = currNode->m_junction;
break;
}
if(currNode->m_visited) break;
}
if(!link.m_first) return;
int steps = 0;
for(i=0; i<4*SEARCH_WINDOW; i++)
{
currNode = currNode->m_prev;
assert(currNode);
if(currNode->m_junction)
{
link.m_second = currNode->m_junction;
break;
}
if(currNode->m_visited) break;
currNode->m_visited = true;
++steps;
}
if( (link.m_first) && (link.m_second) && (link.m_first != link.m_second)
&& steps >= 2*SEARCH_WINDOW && norm(link.m_first->m_center -
link.m_second->m_center) > 2.5 &&
std::find(m_links.begin(), m_links.end(), link) == m_links.end() &&
std::find(m_links.begin(), m_links.end(), JunctionLink(link.m_second,
link.m_first) ) == m_links.end() )
{
m_links.push_back(link);
}
else
{
for(int i=0; i<4*SEARCH_WINDOW; i++)
{
currNode = currNode->m_next;
assert(currNode);
if(currNode->m_junction) break;
currNode->m_visited = false;
}
}
}
*/
//---------------------------------------------------------
void CenterLineVectorizer::createJunctionPolygon(Junction *junction)
{
//int size = junction->m_nodes.size();
// std::sort(junction->m_nodes.begin(), junction->m_nodes.end(), CompareJunctionNodes(junction->m_center));
// std::reverse(junction->m_nodes.begin(), junction->m_nodes.end()); std::deque<Node*>::iterator it, it_temp;
std::deque<Node *>::iterator it, it_temp;
for (it = junction->m_nodes.begin(); it != junction->m_nodes.end(); it++) {
int step = 0;
Node *currNode;
Node *otherNode;
if (it + 1 == junction->m_nodes.end())
otherNode = *junction->m_nodes.begin();
else
otherNode = *(it + 1);
/* currNode = (*it)->m_prev;
if(!currNode->m_visited)
{
step=0;
while(!currNode->m_visited && currNode->m_junction != junction)
{
it = junction->m_nodes.insert(it+1, currNode);
currNode->m_visited = true;
currNode = currNode->m_prev;
++step;
}
if(currNode->m_junction != junction)
for(int i=0; i<step; ++i)
{
currNode = currNode->m_next;
currNode->m_visited = false;
it = junction->m_nodes.erase(it);
--it;
}
else
{
if(currNode != otherNode)
{
it_temp = std::find(junction->m_nodes.begin(), junction->m_nodes.end(),
currNode);
if(it+1 == junction->m_nodes.end())
std::swap(*junction->m_nodes.begin(), *it_temp);
else
std::swap(*(it+1), *it_temp);
}
continue;
}
}
*/
currNode = (*it)->m_next;
if (!currNode->m_visited) {
step = 0;
while (!currNode->m_visited && currNode->m_junction != junction) {
it = junction->m_nodes.insert(it + 1, currNode);
currNode->m_visited = true;
currNode = currNode->m_next;
++step;
}
if (currNode->m_junction != junction) //|| currNode != otherNode)
for (int i = 0; i < step; ++i) {
currNode = currNode->m_prev;
currNode->m_visited = false;
it = junction->m_nodes.erase(it);
--it;
}
else {
// assert(*(it+1) == otherNode || (it+1 == junction->m_nodes.end() && *junction->m_nodes.begin() == otherNode) );
if (currNode != otherNode) {
Node tempNode = *otherNode;
*otherNode = *currNode;
*currNode = tempNode;
// it_temp = std::find(junction->m_nodes.begin(), junction->m_nodes.end(), currNode);
// assert(it_temp != junction->m_nodes.end());
// if(it+1 == junction->m_nodes.end())
// std::swap(*junction->m_nodes.begin(), *it_temp);
// else
// std::swap(*(it+1), *it_temp);
}
continue;
}
}
}
}
//---------------------------------------------------------
void CenterLineVectorizer::handleLinks()
{
std::vector<JunctionLink>::iterator it_links;
for (it_links = m_links.begin(); it_links != m_links.end(); ++it_links) {
ProtoStroke linkingProtoStroke;
//initialize points
TThickPoint p1 = it_links->m_first->m_center;
TThickPoint p2 = it_links->m_second->m_center - p1;
linkingProtoStroke.m_points.push_back(TThickPoint(p1,
JUNCTION_THICKNESS_RATIO * p1.thick));
linkingProtoStroke.m_points.push_back(TThickPoint(p1 + 0.5 * p2,
JUNCTION_THICKNESS_RATIO * (p1.thick + 0.5 * p2.thick)));
linkingProtoStroke.m_points.push_back(TThickPoint(p1 + p2,
JUNCTION_THICKNESS_RATIO * (p1.thick + p2.thick)));
//initialize directions
setEndpointsDirections(linkingProtoStroke);
//initialize junctions
/* linkingProtoStroke.m_startJunction = it_links->first;
linkingProtoStroke.m_endJunction = it_links->second;*/
m_protoStrokes.push_back(linkingProtoStroke);
/* it_links->first->m_protoStrokes.push_back(&m_protoStrokes.back());
it_links->second->m_protoStrokes.push_back(&m_protoStrokes.back());*/
}
}
//---------------------------------------------------------
bool isFalseBranch(int k, ProtoStroke *protoStroke, int recursionOrder,
TThickPoint &edge)
{
if (recursionOrder > 3)
return false;
++recursionOrder;
if (k == 0) {
if (protoStroke->m_points.front().thick > 3.0)
return false;
if (protoStroke->m_points.size() <= 20) {
if (protoStroke->m_endJunction) {
if (protoStroke->m_endJunction->m_protoStrokes.size() == 1) {
edge = protoStroke->m_points.back();
protoStroke->m_endJunction->m_protoStrokes.clear();
protoStroke->m_points.clear();
protoStroke->m_startJunction = 0;
protoStroke->m_endJunction = 0;
return true;
} else if (protoStroke->m_endJunction->m_protoStrokes.size() == 2) {
ProtoStroke *nextProtoStroke;
int next_k;
if (protoStroke->m_endJunction->m_protoStrokes[0] == protoStroke)
nextProtoStroke = protoStroke->m_endJunction->m_protoStrokes[1];
else if (protoStroke->m_endJunction->m_protoStrokes[1] == protoStroke)
nextProtoStroke = protoStroke->m_endJunction->m_protoStrokes[0];
if (nextProtoStroke->m_startJunction == protoStroke->m_endJunction)
next_k = 0;
else if (nextProtoStroke->m_endJunction == protoStroke->m_endJunction)
next_k = 1;
if (isFalseBranch(next_k, nextProtoStroke, recursionOrder, edge)) {
protoStroke->m_endJunction->m_protoStrokes.clear();
protoStroke->m_points.clear();
protoStroke->m_startJunction = 0;
protoStroke->m_endJunction = 0;
return true;
} else
return false;
} else
return false;
}
edge = protoStroke->m_points.back();
protoStroke->m_points.clear();
protoStroke->m_startJunction = 0;
protoStroke->m_endJunction = 0;
return true;
}
} else if (k == 1) {
if (protoStroke->m_points.back().thick > 3.0)
return false;
if (protoStroke->m_points.size() <= 20) {
if (protoStroke->m_startJunction) {
if (protoStroke->m_startJunction->m_protoStrokes.size() == 1) {
edge = protoStroke->m_points.front();
protoStroke->m_startJunction->m_protoStrokes.clear();
protoStroke->m_points.clear();
protoStroke->m_startJunction = 0;
protoStroke->m_endJunction = 0;
return true;
} else if (protoStroke->m_startJunction->m_protoStrokes.size() == 2) {
ProtoStroke *nextProtoStroke;
int next_k;
if (protoStroke->m_startJunction->m_protoStrokes[0] == protoStroke)
nextProtoStroke = protoStroke->m_startJunction->m_protoStrokes[1];
else if (protoStroke->m_startJunction->m_protoStrokes[1] == protoStroke)
nextProtoStroke = protoStroke->m_startJunction->m_protoStrokes[0];
if (nextProtoStroke->m_startJunction == protoStroke->m_startJunction)
next_k = 0;
else if (nextProtoStroke->m_endJunction == protoStroke->m_startJunction)
next_k = 1;
if (isFalseBranch(next_k, nextProtoStroke, recursionOrder, edge)) {
protoStroke->m_startJunction->m_protoStrokes.clear();
protoStroke->m_points.clear();
protoStroke->m_startJunction = 0;
protoStroke->m_endJunction = 0;
return true;
} else
return false;
} else
return false;
}
edge = protoStroke->m_points.front();
protoStroke->m_points.clear();
protoStroke->m_startJunction = 0;
protoStroke->m_endJunction = 0;
return true;
}
}
return false;
}
//---------------------------------------------------------
void CenterLineVectorizer::handleJunctions()
{
std::vector<Junction *>::iterator it_junction = m_junctions.begin();
for (it_junction = m_junctions.begin(); it_junction < m_junctions.end();
it_junction++) {
Junction *currJunction = *it_junction;
if (currJunction->m_protoStrokes.empty()) {
std::deque<Node *>::iterator it_node;
for (it_node = currJunction->m_nodes.begin();
it_node != currJunction->m_nodes.end(); ++it_node) {
(*it_node)->m_junction = 0;
(*it_node)->m_visited = false;
}
delete currJunction;
it_junction = m_junctions.erase(it_junction);
--it_junction;
continue;
}
std::vector<ProtoStroke *>::iterator it;
//set polygon center
/* double size = currJunction->m_nodes.size();
std::deque<Node*>::iterator it_node;
for(it_node = currJunction->m_nodes.begin();
it_node!=currJunction->m_nodes.end(); it_node++)
{
currJunction->m_center += convert( (*it_node)->m_pixel->m_pos );
}
currJunction->m_center = currJunction->m_center * (1/size);
size = currJunction->m_protoStrokes.size();
if(size == 0)
{
currJunction->m_center.thick = THICKNESS_LIMIT;
continue;
}
*/
double size = currJunction->m_protoStrokes.size();
for (it = currJunction->m_protoStrokes.begin();
it != currJunction->m_protoStrokes.end(); it++) {
if (((*it))->m_startJunction == currJunction && (*it)->m_endJunction == currJunction) {
currJunction->m_center += 0.5 * (*it)->m_points.front();
currJunction->m_center += 0.5 * (*it)->m_points.back();
} else if (((*it))->m_startJunction == currJunction) {
currJunction->m_center += (*it)->m_points.front();
} else if ((*it)->m_endJunction == currJunction) {
currJunction->m_center += (*it)->m_points.back();
}
}
currJunction->m_center = currJunction->m_center * (1 / size);
}
#ifdef DEBUG
int j = 0;
for (; j < (int)m_nodes.size(); j++) {
Node *node = m_nodes[j];
if (!node->m_visited && node->m_pixel) {
m_unvisitedNodes.push_back(convert(node->m_pixel->m_pos));
// resolveUnvisitedNode(node);
}
}
for (j = 0; j < (int)m_nodes.size(); j++) {
Node *node = m_nodes[j];
// assert(node->m_visited || !node->m_pixel);
if (node->m_pixel == 0 || node->m_flag)
continue;
outputNodes(node);
}
#endif
joinJunctions();
// return;
for (it_junction = m_junctions.begin(); it_junction < m_junctions.end();
it_junction++) {
Junction *currJunction = *it_junction;
if (currJunction->m_center.thick < 2 * THICKNESS_LIMIT)
currJunction->m_center.thick = 2 * THICKNESS_LIMIT;
std::vector<ProtoStroke *>::iterator it, it_next;
createJunctionPolygon(currJunction);
currJunction->m_junctionOrder = currJunction->m_protoStrokes.size();
if (currJunction->m_protoStrokes.size() == 3) {
std::vector<ProtoStroke *>::iterator it_e =
currJunction->m_protoStrokes.end();
std::vector<ProtoStroke *>::iterator it_candidate1 = it_e, it_candidate2 =
it_e;
int candidate1_k, candidate2_k;
double candidateProbability = JOIN_LIMIT;
int k, next_k;
for (it = currJunction->m_protoStrokes.begin(); it != it_e; it++) {
if (((*it))->m_startJunction == currJunction)
k = 0;
else if ((*it)->m_endJunction == currJunction)
k = 1;
else
assert(false);
if (isFalseBranch(k, *it, 0, currJunction->m_center)) {
currJunction->m_protoStrokes.erase(it);
currJunction->m_locked = true;
break;
}
it_next = it;
it_next++;
for (; it_next != it_e; it_next++) {
double probability;
if (((*it_next))->m_startJunction == currJunction)
next_k = 0;
else if ((*it_next)->m_endJunction == currJunction)
next_k = 1;
else
assert(false);
if (k == 0) {
if (next_k == 0)
probability = 1 - norm2((*it)->m_startDirection +
(*it_next)->m_startDirection);
else
probability = 1 - norm2((*it)->m_startDirection +
(*it_next)->m_endDirection);
} else {
if (next_k == 0)
probability = 1 - norm2((*it)->m_endDirection +
(*it_next)->m_startDirection);
else
probability = 1 - norm2((*it)->m_endDirection +
(*it_next)->m_endDirection);
}
if (probability > candidateProbability ||
(*it)->m_points.size() < 3) {
candidateProbability = probability;
it_candidate1 = it;
it_candidate2 = it_next;
candidate1_k = k;
candidate2_k = next_k;
}
}
}
if (currJunction->m_protoStrokes.size() == 3 && it_candidate1 != it_e &&
it_candidate2 != it_e) {
TThickPoint p1 = (candidate1_k == 0) ? (*it_candidate1)->m_points.front()
: (*it_candidate1)->m_points.back();
TThickPoint p2 = (candidate2_k == 0) ? (*it_candidate2)->m_points.front()
: (*it_candidate2)->m_points.back();
currJunction->m_center = 0.5 * (p1 + p2);
}
}
if (false || currJunction->m_protoStrokes.size() == 2) {
TPointD a1, a2, b1, b2;
if (currJunction->m_protoStrokes[0]->m_startJunction == currJunction) {
a1 = currJunction->m_protoStrokes[0]->m_points.front();
a2 = currJunction->m_protoStrokes[0]->m_startDirection - a1;
} else {
assert(currJunction->m_protoStrokes[0]->m_endJunction == currJunction);
a1 = currJunction->m_protoStrokes[0]->m_points.back();
a2 = currJunction->m_protoStrokes[0]->m_endDirection - a1;
}
if (currJunction->m_protoStrokes[1]->m_startJunction == currJunction) {
b1 = currJunction->m_protoStrokes[1]->m_points.front();
b2 = currJunction->m_protoStrokes[1]->m_startDirection - b1;
} else {
assert(currJunction->m_protoStrokes[1]->m_endJunction == currJunction);
b1 = currJunction->m_protoStrokes[1]->m_points.back();
b2 = currJunction->m_protoStrokes[1]->m_endDirection - b1;
}
/* TPointD intersection;
RectIntersectionResult res;
res = rectsIntersect(a1, a2, b1, b2, intersection);
// assert(res == intersected);
if( norm(intersection - currJunction->m_center) < 5 && res ==
intersected)
{
currJunction->m_center.x = intersection.x;
currJunction->m_center.y = intersection.y;
}
*/ }
if (true || currJunction->m_nodes.size() <= 12 ||
currJunction->isConvex()) {
TThickPoint junctionPoint(currJunction->m_center);
for (it = currJunction->m_protoStrokes.begin();
it != currJunction->m_protoStrokes.end(); it++) {
assert((*it)->m_startJunction == currJunction || (*it)->m_endJunction == currJunction);
if ((*it)->m_startJunction == currJunction) {
TPointD deltaPoint = (*it)->m_points.front() - junctionPoint;
double deltaThick = (*it)->m_points.front().thick -
junctionPoint.thick;
if (norm2(deltaPoint) > 0.2) {
if (norm2(deltaPoint) > 2) {
(*it)->m_points.push_front(
TThickPoint(junctionPoint + 0.7 * deltaPoint, junctionPoint.thick +
0.7 * deltaThick));
(*it)->m_points.push_front(
TThickPoint(junctionPoint + 0.4 * deltaPoint, junctionPoint.thick +
0.4 * deltaThick));
}
(*it)->m_points.push_front(
TThickPoint(junctionPoint + 0.0 * deltaPoint, junctionPoint.thick +
0.0 * deltaThick));
}
}
if ((*it)->m_endJunction == currJunction) {
TPointD deltaPoint = (*it)->m_points.back() - junctionPoint;
double deltaThick = (*it)->m_points.back().thick - junctionPoint.thick;
if (norm2(deltaPoint) > 0.2) {
if (norm2(deltaPoint) > 2) {
(*it)->m_points.push_back(
TThickPoint(junctionPoint + 0.7 * deltaPoint, junctionPoint.thick +
0.7 * deltaThick));
(*it)->m_points.push_back(
TThickPoint(junctionPoint + 0.4 * deltaPoint, junctionPoint.thick +
0.4 * deltaThick));
}
(*it)->m_points.push_back(
TThickPoint(junctionPoint + 0.0 * deltaPoint, junctionPoint.thick +
0.0 * deltaThick));
}
}
}
} else {
ProtoRegion region(currJunction->isConvex());
region.m_center = currJunction->m_center;
std::deque<Node *>::iterator it_nodes;
for (it_nodes = currJunction->m_nodes.begin();
it_nodes != currJunction->m_nodes.end(); it_nodes++)
region.m_points.push_back(
TThickPoint(convert((*it_nodes)->m_pixel->m_pos), 0.0));
region.m_points.push_back(
TThickPoint(convert((*currJunction->m_nodes.begin())->m_pixel->m_pos), 0.0));
m_protoRegions.push_back(region);
for (it = currJunction->m_protoStrokes.begin();
it != currJunction->m_protoStrokes.end(); it++) {
if ((*it)->m_startJunction == currJunction && (*it)->m_endJunction == currJunction) {
if ((*it)->m_points.size() < 10)
(*it)->m_points.clear();
}
if ((*it)->m_startJunction == currJunction) {
(*it)->m_startJunction = 0;
}
if ((*it)->m_endJunction == currJunction) {
(*it)->m_endJunction = 0;
}
}
currJunction->m_protoStrokes.clear();
}
}
//handleLinks();
}
//---------------------------------------------------------
void CenterLineVectorizer::createStrokes()
{
std::list<ProtoStroke>::iterator it_centerlines = m_protoStrokes.begin();
for (; it_centerlines != m_protoStrokes.end(); it_centerlines++) {
if (!it_centerlines->m_points.empty()) {
joinProtoStrokes(&(*it_centerlines));
if (it_centerlines->m_points.size() <= 1)
continue;
std::vector<TThickPoint> points;
std::deque<TThickPoint>::iterator it;
if (m_configuration.m_smoothness > 0) // gmt: prima era true
{
// gmt, 30-3-2006:
/*
it = it_centerlines->m_points.begin()+1;
for(;;)
{
if( it >= it_centerlines->m_points.end()-(m_configuration.m_smoothness+1)) break;
for(int j=0; j<m_configuration.m_smoothness;j++)
it = it_centerlines->m_points.erase(it);
++it;
}
*/
// gmt. credo che l'idea sia di lasciare un punto e
// toglierne m_configuration.m_smoothness e cosi' via fino alla fine
// n.b. ho modificato il comportamento sugli eventuali ultimi punti
// (<m_configuration.m_smoothness) che prima venivano lasciati e adesso
// vengono tolti
std::deque<TThickPoint> &points = it_centerlines->m_points;
it = points.begin();
for (;;) {
if (it == points.end())
break;
++it;
int maxD = std::distance(it, points.end());
int d = tmin(maxD, m_configuration.m_smoothness);
if (d == 0)
break;
it = points.erase(it, it + d);
}
}
it = it_centerlines->m_points.begin();
points.push_back(*it);
assert(it->thick >= THICKNESS_LIMIT);
TThickPoint old = *it;
for (it++; it != it_centerlines->m_points.end(); ++it) {
assert(it->thick >= THICKNESS_LIMIT);
TThickPoint point(0.5 * (*it + old), 0.5 * (it->thick + old.thick));
points.push_back(point);
old = *it;
}
points.push_back(it_centerlines->m_points.back());
int n = points.size();
if (n > 5) {
double *rr = new double[n];
int i;
for (i = 0; i < n; i++)
rr[i] = points[i].thick;
for (i = 2; i < n - 2; i++)
points[i].thick = 0.8 * (1 / 5.0) *
(/*rr[i-4]+rr[i-3]*/ +rr[i - 2] + rr[i - 1] + rr[i] + rr[i + 1] + rr[i + 2] /*+rr[i+3]+rr[i+4]*/);
points[0].thick = points[1].thick = points[2].thick; //=points[3].thick;//=points[4].thick;
points[n - 1].thick = points[n - 2].thick = points[n - 3].thick; //=points[n-4].thick;//=points[n-5].thick;
delete[] rr;
}
TStroke *stroke = TStroke::interpolate(points, m_configuration.m_interpolationError);
stroke->setStyle(m_configuration.m_strokeStyleId); // FirstUserStyle+2);
m_vimage->addStroke(stroke);
}
}
}
//---------------------------------------------------------
void CenterLineVectorizer::createRegions()
{
std::list<ProtoRegion>::iterator it_regions;
for (it_regions = m_protoRegions.begin(); it_regions != m_protoRegions.end(); it_regions++) {
assert(it_regions->m_points.size() > 4);
TStroke *stroke = TStroke::interpolate(it_regions->m_points, 0.1);
stroke->setSelfLoop();
stroke->setStyle(m_configuration.m_strokeStyleId);
m_vimage->addStroke(stroke);
/*
if(it_regions->m_isConvex)
m_vimage->fill(it_regions->m_center, TPalette::DefaultStrokeStyle);
else
{
TPointD internalPoint;
internalPoint = rotate90(it_regions->m_points[1] -
it_regions->m_points[0]);
assert(norm2(internalPoint) != 0);
normalize(internalPoint);
internalPoint = internalPoint*0.001 + 0.5*(it_regions->m_points[1] +
it_regions->m_points[0]);
m_vimage->fill(internalPoint, TPalette::DefaultStrokeStyle);
}*/
}
}
//---------------------------------------------------------
void CenterLineVectorizer::vectorize()
{
int j = 0;
for (j = 0; j < (int)m_nodes.size(); j++) {
Node *node = m_nodes[j];
if (node->m_pixel == 0 || node->m_visited)
continue;
traceLine(node->m_pixel);
}
handleJunctions();
createStrokes();
createRegions();
}
//---------------------------------------------------------
#ifdef DEBUG
void printTime(TStopWatch &sw, string name)
{
ostringstream ss;
ss << name << " : ";
sw.print(ss);
ss << '\n' << '\0';
string s = ss.str();
ss.freeze(false);
TSystem::outputDebug(s);
}
#endif
//---------------------------------------------------------
#ifdef DEBUG
void CenterLineVectorizer::outputInks()
{
for (int i = 0; i < m_dataRaster->getLx() * m_dataRaster->getLy(); i++) {
DataPixel *pix = m_dataRaster->pixels() + i;
if (pix->m_ink)
getOutPix(pix) = TPixel32::Black;
else
getOutPix(pix) = TPixel32::White;
}
}
#endif
//---------------------------------------------------------
TVectorImageP centerlineVectorize(const TImageP &image, const VectorizerConfiguration &c, TPalette *palette)
{
CenterLineVectorizer vectorizer(c, palette);
TRasterImageP ri = image;
TToonzImageP vi = image;
if (ri)
vectorizer.makeDataRaster(ri->getRaster());
else
vectorizer.makeDataRaster(vi->getRaster());
for (int i = 0; i < (int)vectorizer.m_dataRasterArray.size(); i++) {
vectorizer.m_dataRaster = vectorizer.m_dataRasterArray[i].second;
vectorizer.m_configuration.m_strokeStyleId = vectorizer.m_dataRasterArray[i].first;
vectorizer.init();
vectorizer.vectorize();
}
renormalizeImage(vectorizer.m_vimage.getPointer());
return vectorizer.m_vimage;
}
//=============================================
class OutlineVectorizer : public CenterLineVectorizer
{
public:
list<vector<TThickPoint>> m_protoOutlines;
void traceOutline(Node *initialNode);
OutlineVectorizer(const VectorizerConfiguration &configuration, TPalette *palette) : CenterLineVectorizer(configuration, palette) {}
~OutlineVectorizer();
void createOutlineStrokes();
private:
// not implemented
OutlineVectorizer(const OutlineVectorizer &);
OutlineVectorizer &operator=(const OutlineVectorizer &);
};
//---------------------------------------------------------
OutlineVectorizer::~OutlineVectorizer()
{
m_protoOutlines.clear();
}
//---------------------------------------------------------
void OutlineVectorizer::traceOutline(Node *initialNode)
{
Node *startNode = initialNode;
Node *node;
do {
if (!startNode)
break;
node = findOtherSide(startNode);
if (!node)
break;
double startDist2 = computeDistance2(startNode, node);
if (startDist2 > 0.1)
break;
startNode = startNode->m_next;
// assert(startNode != initialNode);
} while (startNode != initialNode);
if (!startNode)
return;
node = startNode;
std::vector<TThickPoint> points;
do {
node = node->m_next;
if (!node)
break;
node->m_visited = true;
points.push_back(TThickPoint(convert(node->m_pixel->m_pos), 0));
} while (node != startNode);
m_protoOutlines.push_back(points);
}
//---------------------------------------------------------
void OutlineVectorizer::createOutlineStrokes()
{
m_vimage->enableRegionComputing(true, false);
int j;
for (j = 0; j < (int)m_nodes.size(); j++) {
Node *node = m_nodes[j];
if (node->m_pixel == 0 || node->m_visited)
continue;
traceOutline(node);
}
#ifdef DEBUG
for (j = 0; j < (int)m_nodes.size(); j++) {
Node *node = m_nodes[j];
// assert(node->m_visited || !node->m_pixel);
if (node->m_pixel == 0 || node->m_flag)
continue;
outputNodes(node);
}
#endif
std::list<std::vector<TThickPoint>>::iterator it_outlines = m_protoOutlines.begin();
for (; it_outlines != m_protoOutlines.end(); it_outlines++) {
if (it_outlines->size() > 3) {
std::vector<TThickPoint> points;
std::vector<TThickPoint>::iterator it;
if (it_outlines->size() > 10) {
it = it_outlines->begin() + 1;
for (;;) {
if (it >= it_outlines->end() - (m_configuration.m_smoothness + 1))
break;
for (j = 0; j < m_configuration.m_smoothness; j++)
it = it_outlines->erase(it);
++it;
}
}
points.push_back(it_outlines->front());
it = it_outlines->begin();
TThickPoint old = *it;
++it;
for (; it != it_outlines->end(); ++it) {
TThickPoint point((1 / 2.0) * (*it + old));
points.push_back(point);
old = *it;
}
points.push_back(it_outlines->back());
points.push_back(it_outlines->front());
/*TPointD internalPoint;
internalPoint = rotate90(points[1] - points[0]);
assert(norm2(internalPoint) != 0);
normalize(internalPoint);
internalPoint = internalPoint*0.001 + points[0];
TPointD externalPoint;
externalPoint = rotate270(points[1] - points[0]);
assert(norm2(externalPoint) != 0);
normalize(externalPoint);
externalPoint = externalPoint*0.001 + points[0];*/
TStroke *stroke = TStroke::interpolate(points, m_configuration.m_interpolationError);
stroke->setStyle(m_configuration.m_strokeStyleId);
stroke->setSelfLoop();
m_vimage->addStroke(stroke);
// TStroke *stroke = TStroke::interpolate(points, m_configuration.interpolationError);
// stroke->setStyle(strokeStyleId);
// m_vimage->addStroke(stroke);//, TPalette::DefaultStrokeStyle, TPalette::DefaultFillStyle);
//internalPoints.push_back(internalPoint);
//m_vimage->fill(externalPoint, TPalette::DefaultFillStyle);
}
}
//m_vimage->autoFill(m_configuration.m_strokeStyleId);
//for (UINT i=0; i<internalPoints.size(); i++)
// m_vimage->fill(internalPoints[i],fillStyleId);
}
//---------------------------------------------------------
TVectorImageP outlineVectorize(const TImageP &image, const VectorizerConfiguration &configuration, TPalette *palette)
{
TVectorImageP out;
OutlineVectorizer vectorizer(configuration, palette);
TRasterImageP ri = image;
TToonzImageP vi = image;
if (ri)
vectorizer.makeDataRaster(ri->getRaster());
else
vectorizer.makeDataRaster(vi->getRaster());
int layersCount = vectorizer.m_dataRasterArray.size();
if (layersCount > 1) {
out = new TVectorImage();
out->setPalette(palette);
}
for (int i = 0; i < (int)layersCount; i++) {
vectorizer.m_dataRaster = vectorizer.m_dataRasterArray[i].second;
vectorizer.m_configuration.m_strokeStyleId = vectorizer.m_dataRasterArray[i].first;
vectorizer.m_protoOutlines.clear();
vectorizer.init();
vectorizer.createOutlineStrokes();
renormalizeImage(vectorizer.m_vimage.getPointer());
vectorizer.m_vimage->setPalette(palette);
if (layersCount > 1)
out->mergeImage(vectorizer.m_vimage, TAffine());
if (i != (int)layersCount - 1)
vectorizer.m_vimage = new TVectorImage();
}
return (layersCount == 1) ? vectorizer.m_vimage : out;
}
//---------------------------------------------------------
void applyFillColors(TRegion *r, const TRasterP &ras, TPalette *palette, const TPoint &offset, bool leaveUnpainted)
{
TPointD pd;
TRasterCM32P rt = (TRasterCM32P)ras;
TRaster32P rr = (TRaster32P)ras;
TRasterGR8P rgr = (TRasterGR8P)ras;
assert(rt || rr || rgr);
if (/*r->getStyle()==0 && */ r->getInternalPoint(pd)) {
TPoint p = convert(pd) + offset;
if (ras->getBounds().contains(p)) {
int styleId = 0;
if (rt) {
TPixelCM32 col = rt->pixels(p.y)[p.x];
int tone = col.getTone();
if (tone < 100) {
styleId = col.getInk();
if (styleId == 0 && !leaveUnpainted)
styleId = col.getPaint();
} else if (!leaveUnpainted || col.getPaint() == 0) {
styleId = col.getPaint();
if (styleId == 0)
styleId = col.getInk();
}
} else {
TPixel32 color;
if (rr)
color = rr->pixels(p.y)[p.x];
else {
int val = rgr->pixels(p.y)[p.x].value;
color = (val < 80) ? TPixel32::Black : TPixel32::White;
}
styleId = palette->getClosestStyle(color);
if (palette->getStyle(styleId)->getMainColor() != color)
styleId = palette->addStyle(color);
}
r->fill(pd, styleId);
}
}
for (int i = 0; i < (int)r->getSubregionCount(); i++)
applyFillColors(r->getSubregion(i), ras, palette, offset, leaveUnpainted);
}
//=========================================================
void applyFillColors(TVectorImageP vi, const TImageP &img, TPalette *palette, bool leaveUnpainted)
{
TToonzImageP ti = (TToonzImageP)img;
TRasterImageP ri = (TRasterImageP)img;
TRectD vb = vi->getBBox();
TRectD tb = img->getBBox();
TRasterP ras;
if (ti)
ras = ti->getRaster();
else if (ri)
ras = ri->getRaster();
else
assert(false);
vi->findRegions();
for (int i = 0; i < (int)vi->getRegionCount(); i++)
applyFillColors(vi->getRegion(i), ras, palette, convert(tb.getP00() - vb.getP00()), leaveUnpainted);
}
//=========================================================
TVectorImageP vectorize(const TImageP &img, const VectorizerConfiguration &c, TPalette *plt)
{
TVectorImageP vi = c.m_outline
? outlineVectorize(img, c, plt)
: centerlineVectorize(img, c, plt);
applyFillColors(vi, img, plt, c.m_leaveUnpainted);
//else if (c.m_outline)
// vi->autoFill(c.m_strokeStyleId);
TPointD center;
if (TToonzImageP ti = img)
center = ti->getRaster()->getCenterD();
else if (TRasterImageP ri = img)
center = ri->getRaster()->getCenterD();
TAffine aff = TTranslation(-center);
vi->transform(aff);
return vi;
}
//---------------------------------------------------------
Reference in a new issue View git blame Copy permalink