razzaline/tahoma2d
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
tahoma2d/toonz/sources/common/tvectorimage/tsweepboundary.cpp
Jeremy Bullock 175c6b7122 Clear out references to flash and linetest
2020-05-07 22:13:53 -06:00

1932 lines
67 KiB
C++
Raw Blame History

//#include "tgeometry.h"
#include <set>
#include <map>
#include "tgl.h"
#include "tstroke.h"
//#include "tstrokeoutline.h"
#include "tcurveutil.h"
//#include "drawutil.h"
#include "tvectorimage.h"
#ifdef _WIN32
#include <crtdbg.h>
#include <windows.h>
#endif
#include "tsweepboundary.h"
#include "tcurves.h"
// Some using declaration
using namespace std;
inline bool operator<(const TPointD &a, const TPointD &b) {
if (a.x < b.x)
return true;
else if (a.x > b.x)
return false;
else if (a.y < b.y)
return true;
else if (a.y > b.y)
return false;
else
return true;
}
namespace {
const double delta = 0.000001;
const double zero = delta;
const double one = 1 - delta;
const double thicknessLimit = 0.3;
const double nonSimpleLoopsMaxDistance = 0.5;
const int nonSimpleLoopsMaxSize = 5;
const int smallStrokeDim = nonSimpleLoopsMaxSize * 5;
bool isSmallStroke = false;
set<TPointD> simpleCrossing;
set<TPointD> nonSimpleCrossing;
class LinkedQuadratic final : public TQuadratic {
public:
LinkedQuadratic *prev, *next;
LinkedQuadratic() : TQuadratic(), prev(0), next(0){};
LinkedQuadratic(const TPointD &p0, const TPointD &p1, const TPointD &p2)
: TQuadratic(p0, p1, p2), prev(0), next(0) {}
LinkedQuadratic(TQuadratic &Quadratic)
: TQuadratic(Quadratic), prev(0), next(0) {}
};
typedef enum Direction {
inward = 0,
outward = 1,
deletedInward = 2,
deletedOutward = 3
} Direction;
/*
class CompareOutlines {
public:
bool operator()(const vector<TQuadratic*> &v1,
const vector<TQuadratic*> &v2)
{
if(v1.empty()) return false;
else if(v2.empty()) return true;
else return v1[0]->getBBox().y1 > v2[0]->getBBox().y1;
}
};
class CompareQuadratics {
public:
bool operator()(TQuadratic *const q1,
TQuadratic *const q2)
{
if (q1->getBBox().y1 > q2->getBBox().y1) return true;
else if (q1->getBBox().y1 < q2->getBBox().y1) return
false;
else if (q1->getBBox().x1 > q2->getBBox().x1) return
true;
else if (q1->getBBox().x1 < q2->getBBox().x1) return
false;
else return false;
}
};
*/
class CompareLinkedQuadratics {
public:
bool operator()(const LinkedQuadratic &q1, const LinkedQuadratic &q2) {
if (q1.getBBox().y1 > q2.getBBox().y1)
return true;
else if (q1.getBBox().y1 < q2.getBBox().y1)
return false;
else if (q1.getBBox().x1 > q2.getBBox().x1)
return true;
else if (q1.getBBox().x1 < q2.getBBox().x1)
return false;
else
return false;
}
};
class CompareBranches {
public:
bool operator()(const pair<LinkedQuadratic *, Direction> &b1,
const pair<LinkedQuadratic *, Direction> &b2) {
TPointD p1, p2;
if (b1.second == inward) {
p1 = b1.first->getP1() - b1.first->getP2();
} else //(b1.second == outward)
{
p1 = b1.first->getP1() - b1.first->getP0();
}
if (b2.second == inward) {
p2 = b2.first->getP1() - b2.first->getP2();
} else //(b1.second == outward)
{
p2 = b2.first->getP1() - b2.first->getP0();
}
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;
}
};
typedef list<LinkedQuadratic> LinkedQuadraticList;
typedef list<TQuadratic> QuadraticList;
} // namespace {
//---------------------------------------------------------------------------
static void splitCircularArcIntoQuadraticCurves(
const TPointD &Center, const TPointD &Pstart, const TPointD &Pend,
vector<TQuadratic *> &quadArray) {
// It splits a circular anticlockwise arc into a sequence of quadratic bezier
// curves
// Every quadratic curve can approximate an arc no longer than 45 degrees (or
// 60).
// It supposes that Pstart and Pend are onto the circumference (so that their
// lengths
// are equal to tha radius of the circumference), otherwise the resulting
// curves could
// be unpredictable.
// The last component in quadCurve[] is an ending void curve
/*
----------------------------------------------------------------------------------
*/
// If you want to split the arc into arcs no longer than 45 degrees (so that
// the whole
// curve will be splitted into 8 pieces) you have to set these constants as
// follows:
// cos_ang ==> cos_45 = 0.5 * sqrt(2);
// sin_ang ==> sin_45 = 0.5 * sqrt(2);
// tan_semiang ==> tan_22p5 = 0.4142135623730950488016887242097;
// N_QUAD = 8;
// If you want to split the arc into arcs no longer than 60 degrees (so that
// the whole
// curve will be splitted into 6 pieces) you have to set these constants as
// follows:
// cos_ang ==> cos_60 = 0.5;
// sin_ang ==> sin_60 = 0.5 * sqrt(3);
// tan_semiang ==> tan_30 = 0.57735026918962576450914878050196;
// N_QUAD = 6;
/*
----------------------------------------------------------------------------------
*/
// Defines some useful constant to split the arc into arcs no longer than
// 'ang' degrees
// (the whole circumference will be splitted into 360/ang quadratic curves).
const double cos_ang = 0.5 * sqrt(2.);
const double sin_ang = 0.5 * sqrt(2.);
const double tan_semiang = 0.4142135623730950488016887242097;
const int N_QUAD = 8; // it's 360/ang
// First of all, it computes the vectors from the center to the circumference,
// in Pstart and Pend, and their cross and dot products
TPointD Rstart = Pstart - Center; // its length is R (radius of the circle)
TPointD Rend = Pend - Center; // its length is R (radius of the circle)
double cross_prod = cross(Rstart, Rend); // it's Rstart x Rend
double dot_prod = Rstart * Rend;
const double sqr_radius = Rstart * Rstart;
TPointD aliasPstart = Pstart;
TQuadratic *quad;
while ((cross_prod <= 0) ||
(dot_prod <= cos_ang * sqr_radius)) // the circular arc is longer
// than a 'ang' degrees arc
{
if (quadArray.size() == (UINT)N_QUAD) // this is possible if Pstart or Pend
// is not onto the circumference
return;
TPointD Rstart_rot_ang(cos_ang * Rstart.x - sin_ang * Rstart.y,
sin_ang * Rstart.x + cos_ang * Rstart.y);
TPointD Rstart_rot_90(-Rstart.y, Rstart.x);
quad =
new TQuadratic(aliasPstart, aliasPstart + tan_semiang * Rstart_rot_90,
Center + Rstart_rot_ang);
quadArray.push_back(quad);
// quad->computeMinStepAtNormalSize ();
// And moves anticlockwise the starting point on the circumference by 'ang'
// degrees
Rstart = Rstart_rot_ang;
aliasPstart = quad->getP2();
cross_prod = cross(Rstart, Rend); // it's Rstart x Rend
dot_prod = Rstart * Rend;
// after the rotation of 'ang' degrees, the remaining part of the arc could
// be a 0 degree
// arc, so it must stop and exit from the function
if ((cross_prod <= 0) && (dot_prod > 0.95 * sqr_radius)) return;
}
if ((cross_prod > 0) && (dot_prod > 0)) // the last quadratic curve
// approximates an arc shorter than a
// 'ang' degrees arc
{
TPointD Rstart_rot_90(-Rstart.y, Rstart.x);
double deg_index = (sqr_radius - dot_prod) / (sqr_radius + dot_prod);
quad = new TQuadratic(aliasPstart,
(deg_index < 0)
? 0.5 * (aliasPstart + Pend)
: aliasPstart + sqrt(deg_index) * Rstart_rot_90,
Pend);
quadArray.push_back(quad);
} else // the last curve, already computed, is as long as a 'ang' degrees arc
quadArray.back()->setP2(Pend);
}
inline bool left(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;
}
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;
}
void computeStrokeBoundary(const TStroke &stroke,
LinkedQuadraticList &inputBoundaries,
unsigned int &chunkIndex);
void normalizeTThickQuadratic(const TThickQuadratic *&sourceThickQuadratic,
TThickQuadratic &tempThickQuadratic);
inline void normalizeTQuadratic(TQuadratic *&sourceQuadratic);
void getBoundaryPoints(const TPointD &P0, const TPointD &P1,
const TThickPoint &center, TPointD &fwdPoint,
TPointD &rwdPoint);
void getAverageBoundaryPoints(const TPointD &P0, const TThickPoint &center,
const TPointD &P2, TPointD &fwdPoint,
TPointD &rwdPoint);
void linkQuadraticList(LinkedQuadraticList &inputBoundaries);
void computeInputBoundaries(LinkedQuadraticList &inputBoundaries);
void processAdjacentQuadratics(LinkedQuadraticList &inputBoundaries);
void findIntersections(
LinkedQuadratic *quadratic, set<LinkedQuadratic *> &intersectionWindow,
map<LinkedQuadratic *, vector<double>> &intersectedQuadratics);
void refreshIntersectionWindow(LinkedQuadratic *quadratic,
set<LinkedQuadratic *> &intersectionWindow);
void segmentate(LinkedQuadraticList &inputBoundaries,
LinkedQuadratic *thickQuadratic, vector<double> &splitPoints);
void processIntersections(LinkedQuadraticList &intersectionBoundary);
bool processNonSimpleLoops(
TPointD &intersectionPoint,
vector<pair<LinkedQuadratic *, Direction>> &crossing);
bool deleteUnlinkedLoops(LinkedQuadraticList &inputBoundaries);
bool getOutputOutlines(LinkedQuadraticList &inputBoundaries,
vector<TStroke *> &sweepStrokes);
void removeFalseHoles(const vector<TStroke *> &strokes);
inline void TraceLinkedQuadraticList(LinkedQuadraticList &quadraticList) {
#ifdef _WIN32
_RPT0(_CRT_WARN, "\n__________________________________________________\n");
LinkedQuadraticList::iterator it = quadraticList.begin();
while (it != quadraticList.end()) {
_RPT4(_CRT_WARN, "\nP0( %f, %f) P2( %f, %f)", it->getP0().x,
it->getP0().y, it->getP2().x, it->getP2().y);
_RPT3(_CRT_WARN, " currAddress = %p, nextAddress = %p prevAddress = %p\n",
&(*it), it->next, it->prev);
++it;
}
#endif
}
inline void drawPointSquare(const TPointD &point, double R, double G,
double B) {
#define SQUARE_DIM 0.04
glBegin(GL_LINE_LOOP);
glColor3d(R, G, B);
glVertex2d(point.x + SQUARE_DIM, point.y + SQUARE_DIM);
glVertex2d(point.x + SQUARE_DIM, point.y - SQUARE_DIM);
glVertex2d(point.x - SQUARE_DIM, point.y - SQUARE_DIM);
glVertex2d(point.x - SQUARE_DIM, point.y + SQUARE_DIM);
glEnd();
}
inline void drawPointCross(const TPointD &point, double R, double G, double B) {
#define CROSS_DIM 0.04
glBegin(GL_LINES);
glColor3d(R, G, B);
glVertex2d(point.x - CROSS_DIM, point.y - CROSS_DIM);
glVertex2d(point.x + CROSS_DIM, point.y + CROSS_DIM);
glVertex2d(point.x + CROSS_DIM, point.y - CROSS_DIM);
glVertex2d(point.x - CROSS_DIM, point.y + CROSS_DIM);
glEnd();
}
//-------------------------------------------------------------------
static TStroke *getOutStroke(LinkedQuadraticList &inputBoundaries) {
vector<TPointD> aux;
LinkedQuadraticList::iterator it = inputBoundaries.begin();
aux.push_back(inputBoundaries.front().getP0());
for (; it != inputBoundaries.end(); ++it)
{
// if (tdistance2(aux.back(), it->getP2())>0.25)
{
aux.push_back(it->getP1());
aux.push_back(it->getP2());
}
// inputBoundaries.remove(*it);
}
return new TStroke(aux);
}
//-------------------------------------------------------------------
inline bool getOutputOutlines(LinkedQuadraticList &inputBoundaries,
vector<TStroke *> &sweepStrokes) {
// int count=0;
while (!inputBoundaries.empty()) {
vector<TPointD> v;
LinkedQuadraticList::iterator it = inputBoundaries.begin();
// std::advance(it, count+1);
LinkedQuadratic *first = &(*it);
LinkedQuadratic *toRemove, *current = first;
v.push_back(current->getP0());
do {
// if (tdistance2(v.back(), current->getP2())>0.25)
{
v.push_back(current->getP1());
v.push_back(current->getP2());
}
// count++;
// outputOutlines.back().m_quads.push_back(new TQuadratic(*current));
toRemove = current;
current = current->next;
inputBoundaries.remove(*toRemove);
// assert(current);
if (!current) {
inputBoundaries.clear();
// outputOutlines.pop_back();
return false;
}
} while (current != first && !inputBoundaries.empty());
sweepStrokes.push_back(new TStroke(v));
// sort(outputOutlines[count].begin(), outputOutlines[count].end(),
// CompareQuadratics());
}
inputBoundaries.clear();
return true;
}
//-------------------------------------------------------------------
static bool computeBoundaryStroke(const TStroke &_stroke,
vector<TStroke *> &sweepStrokes) {
// if(!outlines.empty()) return false;
TStroke *oriStroke = const_cast<TStroke *>(&_stroke);
TStroke *stroke = oriStroke;
for (int i = 0; i < stroke->getControlPointCount(); i++) {
TThickPoint p = stroke->getControlPoint(i);
// se ci sono punti a spessore nullo, viene male il boundary.
if (areAlmostEqual(p.thick, 0, 1e-8)) {
if (stroke == oriStroke) stroke = new TStroke(_stroke);
stroke->setControlPoint(i, TThickPoint(p.x, p.y, 0.0001));
}
}
unsigned int chunkIndex = 0;
while (chunkIndex < (UINT)stroke->getChunkCount()) {
LinkedQuadraticList tempBoundary;
LinkedQuadraticList inputBoundaries;
simpleCrossing.clear();
nonSimpleCrossing.clear();
isSmallStroke = false;
computeStrokeBoundary(*stroke, inputBoundaries, chunkIndex);
inputBoundaries.sort(CompareLinkedQuadratics());
computeInputBoundaries(inputBoundaries);
if (!deleteUnlinkedLoops(inputBoundaries)) return false;
if (!getOutputOutlines(inputBoundaries, sweepStrokes)) return false;
// TStroke *sout = getOutStroke(inputBoundaries);
// sweepStrokes.push_back(sout);
// if(!getOutputOutlines(inputBoundaries, outlines)) return false;
}
if (stroke != &_stroke) delete stroke;
return true;
}
//-------------------------------------------------------------------
inline void computeStrokeBoundary(const TStroke &stroke,
LinkedQuadraticList &inputBoundaries,
unsigned int &chunkIndex) {
unsigned int chunkCount = stroke.getChunkCount();
assert(chunkCount - chunkIndex > 0);
if ((int)(chunkCount - chunkIndex) <= smallStrokeDim) isSmallStroke = true;
unsigned int startIndex = chunkIndex;
const TThickQuadratic *thickQuadratic = 0, *nextThickQuadratic = 0;
TThickQuadratic tempThickQuadratic, tempNextThickQuadratic;
TPointD fwdP0, fwdP1, fwdP2;
TPointD rwdP0, rwdP1, rwdP2;
TPointD nextFwdP0, nextRwdP2;
thickQuadratic = stroke.getChunk(chunkIndex);
while (thickQuadratic->getP0() == thickQuadratic->getP2()) {
double thickness;
thickness = std::max({thickQuadratic->getThickP0().thick,
thickQuadratic->getThickP1().thick,
thickQuadratic->getThickP2().thick});
++chunkIndex;
if (chunkIndex == chunkCount) {
vector<TQuadratic *> quadArray;
double thickness = std::max({thickQuadratic->getThickP0().thick,
thickQuadratic->getThickP1().thick,
thickQuadratic->getThickP2().thick});
if (thickness < thicknessLimit) thickness = thicknessLimit;
TPointD center = thickQuadratic->getP0();
TPointD diameterStart = thickQuadratic->getP0();
diameterStart.y += thickness;
TPointD diameterEnd = thickQuadratic->getP0();
diameterEnd.y -= thickness;
splitCircularArcIntoQuadraticCurves(center, diameterStart, diameterEnd,
quadArray);
unsigned int i = 0;
for (; i < quadArray.size(); ++i) {
assert(!(quadArray[i]->getP0() == quadArray[i]->getP2()));
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
delete quadArray[i];
}
quadArray.clear();
splitCircularArcIntoQuadraticCurves(center, diameterEnd, diameterStart,
quadArray);
for (i = 0; i < quadArray.size(); ++i) {
assert(!(quadArray[i]->getP0() == quadArray[i]->getP2()));
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
delete quadArray[i];
}
quadArray.clear();
linkQuadraticList(inputBoundaries);
return;
}
thickQuadratic = stroke.getChunk(chunkIndex);
}
normalizeTThickQuadratic(thickQuadratic, tempThickQuadratic);
getBoundaryPoints(thickQuadratic->getP0(), thickQuadratic->getP1(),
thickQuadratic->getThickP0(), fwdP0, rwdP2);
if (!(rwdP2 == fwdP0)) {
// inputBoundaries.push_front(TQuadratic(rwdP2, (rwdP2+fwdP0)*0.5,
// fwdP0));
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves((rwdP2 + fwdP0) * 0.5, rwdP2, fwdP0,
quadArray);
for (unsigned int i = 0; i < quadArray.size(); ++i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
}
for (/*chunkIndex*/; chunkIndex < chunkCount; ++chunkIndex) {
thickQuadratic = stroke.getChunk(chunkIndex);
while (thickQuadratic->getP0() == thickQuadratic->getP2()) {
++chunkIndex;
if (chunkIndex == chunkCount) break;
thickQuadratic = stroke.getChunk(chunkIndex);
}
if (chunkIndex >= chunkCount - 1) {
chunkIndex = chunkCount;
break;
}
unsigned int nextChunkIndex = chunkIndex + 1;
nextThickQuadratic = stroke.getChunk(nextChunkIndex);
while (nextThickQuadratic->getP0() == nextThickQuadratic->getP2()) {
++nextChunkIndex;
if (nextChunkIndex == chunkCount) {
chunkIndex = chunkCount;
break;
}
nextThickQuadratic = stroke.getChunk(nextChunkIndex);
}
if (nextChunkIndex == chunkCount) {
chunkIndex = chunkCount;
break;
}
if (thickQuadratic->getP0() == nextThickQuadratic->getP2() &&
thickQuadratic->getP2() == nextThickQuadratic->getP0()) {
chunkIndex = nextChunkIndex;
continue;
}
if (chunkIndex == startIndex + 2 &&
norm(stroke.getChunk(startIndex)->getP0() -
stroke.getChunk(chunkCount - 1)->getP2()) <
stroke.getChunk(startIndex)->getThickP0().thick / 2) {
++chunkIndex;
break;
}
normalizeTThickQuadratic(thickQuadratic, tempThickQuadratic);
normalizeTThickQuadratic(nextThickQuadratic, tempNextThickQuadratic);
vector<DoublePair> intersections;
TQuadratic quadratic(thickQuadratic->getP0(), thickQuadratic->getP1(),
thickQuadratic->getP2());
TQuadratic nextQuadratic(nextThickQuadratic->getP0(),
nextThickQuadratic->getP1(),
nextThickQuadratic->getP2());
if (intersect(quadratic, nextQuadratic, intersections) > 1) {
double currSplit = 1, nextSplit = 0;
for (unsigned int i = 0; i < intersections.size(); ++i) {
if (currSplit > intersections[i].first)
currSplit = intersections[i].first;
if (nextSplit < intersections[i].second)
nextSplit = intersections[i].second;
}
if (currSplit < one && nextSplit > zero && currSplit > 0.5 &&
nextSplit < 0.5) {
TQuadratic firstSplit, secondSplit;
quadratic.split(currSplit, firstSplit, secondSplit);
const_cast<TThickQuadratic *>(thickQuadratic)
->setP1(firstSplit.getP1());
const_cast<TThickQuadratic *>(thickQuadratic)
->setP2(firstSplit.getP2());
nextQuadratic.split(nextSplit, firstSplit, secondSplit);
const_cast<TThickQuadratic *>(nextThickQuadratic)
->setP0(secondSplit.getP0());
const_cast<TThickQuadratic *>(nextThickQuadratic)
->setP1(secondSplit.getP1());
}
}
getAverageBoundaryPoints(thickQuadratic->getP0(),
thickQuadratic->getThickP1(),
thickQuadratic->getP2(), fwdP1, rwdP1);
getBoundaryPoints(thickQuadratic->getP1(), thickQuadratic->getP2(),
thickQuadratic->getThickP2(), fwdP2, rwdP0);
getBoundaryPoints(thickQuadratic->getP2(), nextThickQuadratic->getP1(),
thickQuadratic->getThickP2(), nextFwdP0, nextRwdP2);
TPointD v1 = thickQuadratic->getP2() - thickQuadratic->getP1();
TPointD v2 = nextThickQuadratic->getP1() - nextThickQuadratic->getP0();
if ((v1 * v2) / (norm(v1) * norm(v2)) < -0.95) {
++chunkIndex;
break;
}
if (nextFwdP0 == fwdP2 && nextRwdP2 == rwdP0) {
inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));
inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));
fwdP0 = fwdP2;
rwdP2 = rwdP0;
} else if (!(nextFwdP0 == fwdP2) && !(nextRwdP2 == rwdP0)) {
bool turnLeft, turnRight;
turnLeft = left(thickQuadratic->getP1(), thickQuadratic->getP2(),
nextThickQuadratic->getP1());
turnRight = right(thickQuadratic->getP1(), thickQuadratic->getP2(),
nextThickQuadratic->getP1());
if (turnLeft) {
double thickness = thickQuadratic->getThickP2().thick;
if (thickness < thicknessLimit) thickness = thicknessLimit;
TPointD temp;
if (rwdP0 + nextRwdP2 - 2 * thickQuadratic->getP2() != TPointD(0, 0)) {
temp = (normalize(rwdP0 + nextRwdP2 - 2 * thickQuadratic->getP2()) *
thickness) +
thickQuadratic->getP2();
} else
temp = TPointD(0, 0);
inputBoundaries.push_front(LinkedQuadratic(temp, rwdP1, rwdP2));
inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,
nextFwdP0, quadArray);
for (unsigned int i = 0; i < quadArray.size(); ++i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
fwdP0 = nextFwdP0;
rwdP2 = temp;
} else if (turnRight) {
double thickness = thickQuadratic->getThickP2().thick;
if (thickness < thicknessLimit) thickness = thicknessLimit;
TPointD temp;
if (fwdP2 + nextFwdP0 - 2 * thickQuadratic->getP2() != TPointD(0, 0)) {
temp = (normalize(fwdP2 + nextFwdP0 - 2 * thickQuadratic->getP2()) *
thickness) +
thickQuadratic->getP2();
} else
temp = TPointD(0, 0);
inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));
inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, temp));
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), nextRwdP2,
rwdP0, quadArray);
for (int i = quadArray.size() - 1; i >= 0; --i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_front(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
fwdP0 = temp;
rwdP2 = nextRwdP2;
} else if (nextFwdP0 == rwdP0 && nextRwdP2 == fwdP2) {
++chunkIndex;
break;
// assert(collinear(thickQuadratic->getP0(),
// thickQuadratic->getP2(),
// nextThickQuadratic->getP2()));
if (!collinear(thickQuadratic->getP0(), thickQuadratic->getP2(),
nextThickQuadratic->getP2())) {
inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));
inputBoundaries.push_front(
LinkedQuadratic(thickQuadratic->getP2(), rwdP1, rwdP2));
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,
nextFwdP0, quadArray);
for (unsigned int i = 0; i < quadArray.size(); ++i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
fwdP0 = nextFwdP0;
rwdP2 = thickQuadratic->getP2();
} else if (left(thickQuadratic->getP0(), thickQuadratic->getP1(),
nextThickQuadratic->getP2())) {
inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,
nextFwdP0, quadArray);
for (unsigned int i = 0; i < quadArray.size(); ++i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
fwdP0 = nextFwdP0;
rwdP2 = rwdP0;
} else if (right(thickQuadratic->getP0(), thickQuadratic->getP1(),
nextThickQuadratic->getP2())) {
inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves(thickQuadratic->getP2(), fwdP2,
nextFwdP0, quadArray);
for (int i = quadArray.size() - 1; i >= 0; --i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_front(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
fwdP0 = fwdP2;
rwdP2 = nextRwdP2;
} else {
// inputBoundaries.push_back(TQuadratic(fwdP0,
// fwdP1, fwdP2));
// inputBoundaries.push_front(TQuadratic(rwdP0,
// rwdP1, rwdP2));
// fwdP0 = nextFwdP0;
// rwdP2 = nextRwdP2;
++chunkIndex;
break;
}
} else
assert(false);
} else
assert(false);
}
normalizeTThickQuadratic(thickQuadratic, tempThickQuadratic);
// if( stroke->getChunk(0)->getP0() ==
// stroke->getChunk(chunkCount-1)->getP2() )
/* if( norm(stroke->getChunk(0)->getP0() - stroke->getChunk(chunkCount-1)->getP2()) <
stroke->getChunk(0)->getThickP0().thick/2)
{
getAverageBoundaryPoints(thickQuadratic->getP0(),
thickQuadratic->getThickP1(),
thickQuadratic->getP2(),
fwdP1,
rwdP1);
getBoundaryPoints(thickQuadratic->getP1(),
thickQuadratic->getP2(),
thickQuadratic->getThickPoint(one),
fwdP2,
rwdP0);
inputBoundaries.push_front(TQuadratic(rwdP0, rwdP1, rwdP2));
inputBoundaries.push_back(TQuadratic(fwdP0, fwdP1, fwdP2));
inputBoundaries.push_back(TQuadratic(fwdP2, (fwdP2+rwdP0)*0.5, rwdP0));
}
else
*/ {
getAverageBoundaryPoints(thickQuadratic->getP0(),
thickQuadratic->getThickP1(),
thickQuadratic->getP2(), fwdP1, rwdP1);
getBoundaryPoints(thickQuadratic->getP1(), thickQuadratic->getP2(),
thickQuadratic->getThickP2(), fwdP2, rwdP0);
inputBoundaries.push_front(LinkedQuadratic(rwdP0, rwdP1, rwdP2));
inputBoundaries.push_back(LinkedQuadratic(fwdP0, fwdP1, fwdP2));
if (!(fwdP2 == rwdP0)) {
vector<TQuadratic *> quadArray;
splitCircularArcIntoQuadraticCurves((fwdP2 + rwdP0) * 0.5, fwdP2, rwdP0,
quadArray);
for (unsigned int i = 0; i < quadArray.size(); ++i) {
if (!(quadArray[i]->getP0() == quadArray[i]->getP2())) {
normalizeTQuadratic(quadArray[i]);
inputBoundaries.push_back(*quadArray[i]);
}
delete quadArray[i];
}
quadArray.clear();
}
}
linkQuadraticList(inputBoundaries);
}
//-------------------------------------------------------------------
inline void normalizeTThickQuadratic(
const TThickQuadratic *&sourceThickQuadratic,
TThickQuadratic &tempThickQuadratic) {
assert(!(sourceThickQuadratic->getP0() == sourceThickQuadratic->getP2()));
if (sourceThickQuadratic->getP0() == sourceThickQuadratic->getP1() ||
sourceThickQuadratic->getP1() == sourceThickQuadratic->getP2() ||
collinear(sourceThickQuadratic->getP0(), sourceThickQuadratic->getP1(),
sourceThickQuadratic->getP2())) {
tempThickQuadratic = *sourceThickQuadratic;
TThickPoint middleThickPoint(
(sourceThickQuadratic->getP0() + sourceThickQuadratic->getP2()) * 0.5);
middleThickPoint.thick = tempThickQuadratic.getThickP1().thick;
tempThickQuadratic.setThickP1(middleThickPoint);
sourceThickQuadratic = &tempThickQuadratic;
}
}
inline void normalizeTQuadratic(TQuadratic *&sourceQuadratic) {
assert(!(sourceQuadratic->getP0() == sourceQuadratic->getP2()));
if (sourceQuadratic->getP0() == sourceQuadratic->getP1() ||
sourceQuadratic->getP1() == sourceQuadratic->getP2() ||
collinear(sourceQuadratic->getP0(), sourceQuadratic->getP1(),
sourceQuadratic->getP2())) {
TPointD middleThickPoint(
(sourceQuadratic->getP0() + sourceQuadratic->getP2()) * 0.5);
sourceQuadratic->setP1(middleThickPoint);
}
}
//-------------------------------------------------------------------
inline void getBoundaryPoints(const TPointD &P0, const TPointD &P1,
const TThickPoint &center, TPointD &fwdPoint,
TPointD &rwdPoint) {
double thickness = center.thick;
if (thickness < thicknessLimit) thickness = thicknessLimit;
// if(P1.y == P0.y)
if (fabs(P1.y - P0.y) <= 1e-12) {
if (P1.x - P0.x > 0) {
fwdPoint.x = center.x;
fwdPoint.y = center.y - thickness;
rwdPoint.x = center.x;
rwdPoint.y = center.y + thickness;
} else if (P1.x - P0.x < 0) {
fwdPoint.x = center.x;
fwdPoint.y = center.y + thickness;
rwdPoint.x = center.x;
rwdPoint.y = center.y - thickness;
} else
assert(false);
} else {
double m = -(P1.x - P0.x) / (P1.y - P0.y);
fwdPoint.x = center.x + (thickness) / sqrt(1 + m * m);
fwdPoint.y = center.y + m * (fwdPoint.x - center.x);
rwdPoint.x = center.x - (thickness) / sqrt(1 + m * m);
rwdPoint.y = center.y + m * (rwdPoint.x - center.x);
assert(!collinear(P0, P1, rwdPoint));
if (left(P0, P1, rwdPoint))
return;
else {
TPointD temp = fwdPoint;
fwdPoint = rwdPoint;
rwdPoint = temp;
}
}
}
//-------------------------------------------------------------------
inline void getAverageBoundaryPoints(const TPointD &P0,
const TThickPoint &center,
const TPointD &P2, TPointD &fwdPoint,
TPointD &rwdPoint) {
TPointD fwdP0, fwdP2;
TPointD rwdP0, rwdP2;
getBoundaryPoints(P0, center, center, fwdP0, rwdP0);
getBoundaryPoints(center, P2, center, fwdP2, rwdP2);
double thickness = center.thick;
if (thickness < thicknessLimit) thickness = thicknessLimit;
if (fwdP0.x + fwdP2.x == rwdP0.x + rwdP2.x) {
if ((fwdP0.y + fwdP2.y) - (rwdP0.y + rwdP2.y) > 0) {
fwdPoint.x = center.x;
fwdPoint.y = center.y + thickness;
rwdPoint.x = center.x;
rwdPoint.y = center.y - thickness;
} else if ((fwdP0.y + fwdP2.y) - (rwdP0.y + rwdP2.y) < 0) {
fwdPoint.x = center.x;
fwdPoint.y = center.y - thickness;
rwdPoint.x = center.x;
rwdPoint.y = center.y + thickness;
} else
assert(false);
} else {
double m = ((fwdP0.y + fwdP2.y) - (rwdP0.y + rwdP2.y)) /
((fwdP0.x + fwdP2.x) - (rwdP0.x + rwdP2.x));
fwdPoint.x = center.x + (thickness) / sqrt(1 + m * m);
fwdPoint.y = center.y + m * (fwdPoint.x - center.x);
rwdPoint.x = center.x - (thickness) / sqrt(1 + m * m);
rwdPoint.y = center.y + m * (rwdPoint.x - center.x);
if (right(P0, center, rwdPoint)) {
TPointD temp = fwdPoint;
fwdPoint = rwdPoint;
rwdPoint = temp;
}
}
}
//-------------------------------------------------------------------
inline void linkQuadraticList(LinkedQuadraticList &inputBoundaries) {
LinkedQuadraticList::iterator it_curr, it_prev, it_next, it_last;
it_last = inputBoundaries.end();
it_last--;
it_curr = inputBoundaries.begin();
it_next = it_curr;
it_next++;
it_curr->prev = &(*it_last);
it_curr->next = &(*it_next);
it_curr++;
it_prev = inputBoundaries.begin();
it_next++;
while (it_curr != it_last) {
it_curr->prev = &(*it_prev);
it_curr->next = &(*it_next);
it_curr++;
it_prev++;
it_next++;
}
it_curr->prev = &(*it_prev);
it_curr->next = &(*inputBoundaries.begin());
}
//-------------------------------------------------------------------
inline void computeInputBoundaries(LinkedQuadraticList &inputBoundaries) {
set<LinkedQuadratic *> intersectionWindow;
map<LinkedQuadratic *, vector<double>> intersectedQuadratics;
LinkedQuadraticList intersectionBoundary;
// detect adjacent quadratics intersections
processAdjacentQuadratics(inputBoundaries);
// detect Intersections
LinkedQuadraticList::iterator it;
it = inputBoundaries.begin();
while (it != inputBoundaries.end()) {
assert(!(it->getP0() == it->getP2()));
refreshIntersectionWindow(&*it, intersectionWindow);
findIntersections(&*it, intersectionWindow, intersectedQuadratics);
intersectionWindow.insert(&*it);
++it;
}
/* map<LinkedQuadratic*, vector<double> >::iterator it1 =
intersectedQuadratics.begin();
while(it1 != intersectedQuadratics.end())
{
_RPT2( _CRT_WARN,
"\nP0( %f, %f )\n",
it1->first->getP0().x,
it1->first->getP0().y);
_RPT2( _CRT_WARN,
"\nP1( %f, %f )\n",
it1->first->getP1().x,
it1->first->getP1().y);
_RPT2( _CRT_WARN,
"\nP2( %f, %f )\n",
it1->first->getP2().x,
it1->first->getP2().y);
++it1;
}*/
// segmentate curves
map<LinkedQuadratic *, vector<double>>::iterator it_intersectedQuadratics =
intersectedQuadratics.begin();
while (it_intersectedQuadratics != intersectedQuadratics.end()) {
segmentate(intersectionBoundary, it_intersectedQuadratics->first,
it_intersectedQuadratics->second);
inputBoundaries.remove(*it_intersectedQuadratics->first);
++it_intersectedQuadratics;
}
// process intersections
processIntersections(intersectionBoundary);
inputBoundaries.sort(CompareLinkedQuadratics());
intersectionBoundary.sort(CompareLinkedQuadratics());
inputBoundaries.merge(intersectionBoundary, CompareLinkedQuadratics());
}
//-------------------------------------------------------------------
inline void processAdjacentQuadratics(LinkedQuadraticList &inputBoundaries) {
LinkedQuadratic *start = &inputBoundaries.front();
LinkedQuadratic *curr = start;
do {
vector<DoublePair> intersections;
LinkedQuadratic *next, *temp;
next = curr->next;
// assert(curr->getP2() == next->getP0());
if (curr->getP0() == curr->getP2()) {
(curr->prev)->next = curr->next;
(curr->next)->prev = curr->prev;
temp = curr->prev;
inputBoundaries.remove(*curr);
curr = temp;
} else if (curr->getP0() == next->getP2()) {
(curr->prev)->next = next->next;
(next->next)->prev = curr->prev;
temp = curr->prev;
inputBoundaries.remove(*curr);
inputBoundaries.remove(*next);
curr = temp;
} else if ((curr->getP0() == next->getP0()) &&
(curr->getP1() == next->getP1()) &&
(curr->getP2() == next->getP2())) {
assert(false);
(curr)->next = next->next;
(next->next)->prev = curr;
inputBoundaries.remove(*next);
} else if (intersect(*curr, *next, intersections) > 1) {
double currSplit = 1, nextSplit = 0;
for (unsigned int i = 0; i < intersections.size(); ++i) {
if (currSplit > intersections[i].first)
currSplit = intersections[i].first;
if (nextSplit < intersections[i].second)
nextSplit = intersections[i].second;
}
if (currSplit < one && nextSplit > zero) {
TQuadratic firstSplit, secondSplit;
curr->split(currSplit, firstSplit, secondSplit);
curr->setP1(firstSplit.getP1());
curr->setP2(firstSplit.getP2());
next->split(nextSplit, firstSplit, secondSplit);
next->setP0(secondSplit.getP0());
next->setP1(secondSplit.getP1());
}
}
intersections.clear();
curr = curr->next;
} while (curr != start);
}
//-------------------------------------------------------------------
inline void findIntersections(
LinkedQuadratic *quadratic, set<LinkedQuadratic *> &intersectionWindow,
map<LinkedQuadratic *, vector<double>> &intersectedQuadratics) {
set<LinkedQuadratic *>::iterator it = intersectionWindow.begin();
while (it != intersectionWindow.end()) {
vector<DoublePair> intersections;
if ((quadratic->getP0() == (*it)->getP2()) &&
(quadratic->getP1() == (*it)->getP1()) &&
(quadratic->getP2() == (*it)->getP0()))
assert(false);
else if ((quadratic->getP0() == (*it)->getP0()) &&
(quadratic->getP1() == (*it)->getP1()) &&
(quadratic->getP2() == (*it)->getP2()))
assert(false);
else if (quadratic->prev == *it) {
} else if (quadratic->next == *it) {
} else if (intersect(*quadratic, *(*it), intersections)) {
for (unsigned int i = 0; i < intersections.size(); ++i) {
intersectedQuadratics[quadratic].push_back(intersections[i].first);
intersectedQuadratics[*it].push_back(intersections[i].second);
}
}
intersections.clear();
++it;
}
}
inline void refreshIntersectionWindow(
LinkedQuadratic *quadratic, set<LinkedQuadratic *> &intersectionWindow) {
set<LinkedQuadratic *>::iterator it = intersectionWindow.begin();
while (it != intersectionWindow.end()) {
if ((*it)->getBBox().y0 > quadratic->getBBox().y1) {
set<LinkedQuadratic *>::iterator erase_it;
erase_it = it;
++it;
intersectionWindow.erase(erase_it);
} else
++it;
}
}
//-------------------------------------------------------------------
inline void segmentate(LinkedQuadraticList &intersectionBoundary,
LinkedQuadratic *quadratic,
vector<double> &splitPoints) {
for (unsigned int k = 0; k < splitPoints.size(); k++) {
/* _RPT1( _CRT_WARN,
"\n%f\n",
splitPoints[k]);*/
if (splitPoints[k] > 1) {
splitPoints[k] = 1;
} else if (splitPoints[k] < 0) {
splitPoints[k] = 0;
}
}
sort(splitPoints.begin(), splitPoints.end());
vector<double>::iterator it_duplicates =
unique(splitPoints.begin(), splitPoints.end());
splitPoints.erase(it_duplicates, splitPoints.end());
vector<TQuadratic *> segments;
split<TQuadratic>(*quadratic, splitPoints, segments);
LinkedQuadratic *prevQuadratic = quadratic->prev;
vector<TQuadratic *>::iterator it = segments.begin();
while (it != segments.end()) {
if (!((*it)->getP0() == (*it)->getP2())) {
TQuadratic quad = *(*it);
normalizeTQuadratic(*it);
quad = *(*it);
intersectionBoundary.push_back(*(*it));
prevQuadratic->next = &intersectionBoundary.back();
intersectionBoundary.back().prev = prevQuadratic;
prevQuadratic = &intersectionBoundary.back();
}
delete (*it);
++it;
}
prevQuadratic->next = quadratic->next;
if (quadratic->next) quadratic->next->prev = prevQuadratic;
}
//-------------------------------------------------------------------
inline void processIntersections(LinkedQuadraticList &intersectionBoundary) {
vector<pair<LinkedQuadratic *, Direction>> crossing;
LinkedQuadraticList::iterator it1, it2;
it1 = intersectionBoundary.begin();
while (it1 != intersectionBoundary.end()) {
TPointD intersectionPoint = it1->getP0();
crossing.push_back(pair<LinkedQuadratic *, Direction>(&(*it1), outward));
it2 = intersectionBoundary.begin();
while (it2 != intersectionBoundary.end()) {
if (it1 != it2) {
if (it2->getP0() == intersectionPoint) {
crossing.push_back(
pair<LinkedQuadratic *, Direction>(&(*it2), outward));
}
if (it2->getP2() == intersectionPoint) {
crossing.push_back(
pair<LinkedQuadratic *, Direction>(&(*it2), inward));
}
}
++it2;
}
unsigned int branchNum = crossing.size();
if (branchNum > 4) {
if (crossing[0].second == inward)
nonSimpleCrossing.insert(crossing[0].first->getP2());
else if (crossing[0].second == outward)
nonSimpleCrossing.insert(crossing[0].first->getP0());
else
assert(false);
} else if (branchNum > 2 && branchNum <= 4) {
if (!isSmallStroke) processNonSimpleLoops(intersectionPoint, crossing);
assert(crossing.size() != 1);
if (crossing[0].second == inward)
simpleCrossing.insert(crossing[0].first->getP2());
else if (crossing[0].second == outward)
simpleCrossing.insert(crossing[0].first->getP0());
else
assert(false);
if (crossing.size() > 2) {
sort(crossing.begin(), crossing.end(), CompareBranches());
/* _RPT0( _CRT_WARN,
"\n__________________________________________________\n");
for(unsigned int j=0;j<crossing.size();++j)
{
if(crossing[j].second == inward)
_RPT2( _CRT_WARN,
"\ninward P( %f, %f )\n",
crossing[j].first->getP1().x -
crossing[j].first->getP2().x,
crossing[j].first->getP1().y -
crossing[j].first->getP2().y);
else if(crossing[j].second == outward)
_RPT2( _CRT_WARN,
"\noutward P( %f, %f )\n",
crossing[j].first->getP1().x -
crossing[j].first->getP0().x,
crossing[j].first->getP1().y -
crossing[j].first->getP0().y);
else assert(false);
}*/
vector<pair<LinkedQuadratic *, Direction>>::iterator it, it_prev,
it_next, it_nextnext, it_prevprev;
it = crossing.begin();
while (it != crossing.end()) {
if (it->second == outward) {
it_next = it + 1;
if (it_next == crossing.end()) it_next = crossing.begin();
while (((it->first)->getP0() == (it_next->first)->getP2() &&
(it->first)->getP2() == (it_next->first)->getP0() &&
(it->first)->getP1() == (it_next->first)->getP1()) ||
((it->first)->getP0() == (it_next->first)->getP0() &&
(it->first)->getP2() == (it_next->first)->getP2() &&
(it->first)->getP1() == (it_next->first)->getP1())) {
it_next = it_next + 1;
if (it_next == crossing.end()) it_next = crossing.begin();
}
it_nextnext = it_next + 1;
if (it_nextnext == crossing.end()) it_nextnext = crossing.begin();
if (((it_nextnext->first)->getP0() == (it_next->first)->getP2() &&
(it_nextnext->first)->getP2() == (it_next->first)->getP0() &&
(it_nextnext->first)->getP1() == (it_next->first)->getP1()) ||
((it_nextnext->first)->getP0() == (it_next->first)->getP0() &&
(it_nextnext->first)->getP2() == (it_next->first)->getP2() &&
(it_nextnext->first)->getP1() == (it_next->first)->getP1())) {
if (it_nextnext->second == outward ||
it_nextnext->second == deletedOutward) {
it->first->prev = 0;
it->second = deletedOutward;
}
}
if (it_next->second == outward ||
it_next->second == deletedOutward) {
it->first->prev = 0;
it->second = deletedOutward;
}
} else //(it->second == inward)
{
if (it == crossing.begin())
it_prev = crossing.end() - 1;
else
it_prev = it - 1;
while (((it->first)->getP0() == (it_prev->first)->getP2() &&
(it->first)->getP2() == (it_prev->first)->getP0() &&
(it->first)->getP1() == (it_prev->first)->getP1()) ||
((it->first)->getP0() == (it_prev->first)->getP0() &&
(it->first)->getP2() == (it_prev->first)->getP2() &&
(it->first)->getP1() == (it_prev->first)->getP1())) {
if (it_prev == crossing.begin())
it_prev = crossing.end() - 1;
else
it_prev = it_prev - 1;
}
if (it_prev == crossing.begin())
it_prevprev = crossing.end() - 1;
else
it_prevprev = it_prev - 1;
if (((it_prevprev->first)->getP0() == (it_prev->first)->getP2() &&
(it_prevprev->first)->getP2() == (it_prev->first)->getP0() &&
(it_prevprev->first)->getP1() == (it_prev->first)->getP1()) ||
((it_prevprev->first)->getP0() == (it_prev->first)->getP0() &&
(it_prevprev->first)->getP2() == (it_prev->first)->getP2() &&
(it_prevprev->first)->getP1() == (it_prev->first)->getP1())) {
if (it_prevprev->second == inward ||
it_prevprev->second == deletedInward) {
it->first->next = 0;
it->second = deletedInward;
}
}
if (it_prev->second == inward || it_prev->second == deletedInward) {
it->first->next = 0;
it->second = deletedInward;
}
}
++it;
}
it = crossing.begin();
while (it != crossing.end()) {
if (it->second == deletedOutward || it->second == deletedInward)
it = crossing.erase(it);
else
++it;
}
}
assert(crossing.size() > 0 && crossing.size() <= 4);
if (crossing.size() == 0) {
} else if (crossing.size() == 2) {
if (crossing[0].second == inward) {
assert(crossing[1].second == outward);
crossing[0].first->next = crossing[1].first;
crossing[1].first->prev = crossing[0].first;
} else // if(crossing[0].second == outward)
{
assert(crossing[1].second == inward);
crossing[0].first->prev = crossing[1].first;
crossing[1].first->next = crossing[0].first;
}
}
}
crossing.clear();
++it1;
}
}
//-------------------------------------------------------------------
bool processNonSimpleLoops(
TPointD &intersectionPoint,
vector<pair<LinkedQuadratic *, Direction>> &crossing) {
vector<pair<LinkedQuadratic *, Direction>>::iterator it, last;
it = crossing.begin();
while (it != crossing.end()) {
if (it->second == outward || it->second == deletedOutward) {
LinkedQuadratic *loopStart = it->first;
LinkedQuadratic *loopCurr = loopStart;
for (int i = 0; i < nonSimpleLoopsMaxSize; ++i) {
if (loopCurr->getP2() == intersectionPoint) {
loopStart->prev = 0;
crossing.erase(it);
loopCurr->next = 0;
last = remove(crossing.begin(), crossing.end(),
pair<LinkedQuadratic *, Direction>(loopCurr, inward));
crossing.erase(last, crossing.end());
return true;
break;
}
if (!loopCurr->next) break;
double distance = norm2(loopCurr->getP0() - loopCurr->next->getP2());
if (distance > nonSimpleLoopsMaxDistance) break;
loopCurr = loopCurr->next;
}
}
++it;
}
return false;
}
//-------------------------------------------------------------------
inline bool deleteUnlinkedLoops(LinkedQuadraticList &inputBoundaries) {
LinkedQuadratic *current, *temp;
LinkedQuadraticList::iterator it = inputBoundaries.begin();
while (it != inputBoundaries.end()) {
// bool isNonSimpleBranch;
int count;
if (it->prev == 0) {
// if( nonSimpleCrossing.find(it->getP0()) !=
// nonSimpleCrossing.end() )
// isNonSimpleBranch = true;
// else isNonSimpleBranch = false;
count = inputBoundaries.size();
current = &(*it);
while (current != 0) {
assert(count > 0);
if (count == 0) return false;
if (nonSimpleCrossing.find(current->getP2()) != nonSimpleCrossing.end())
// ||
// simpleCrossing.find(current->getP2())
//!= simpleCrossing.end() )
{
if (current->next) current->next->prev = 0;
it = inputBoundaries.begin();
break;
}
if (&(*it) == current) ++it;
temp = current->next;
inputBoundaries.remove(*current);
if (temp) {
assert(temp->next != current);
if (temp->next == current) {
temp->next = 0;
it = inputBoundaries.begin();
break;
}
}
current = temp;
--count;
}
} else if (it->next == 0) {
// if( nonSimpleCrossing.find(it->getP2()) !=
// nonSimpleCrossing.end() )
// isNonSimpleBranch = true;
// else isNonSimpleBranch = false;
count = inputBoundaries.size();
current = &(*it);
while (current != 0) {
assert(count > 0);
if (count == 0) return false;
if (nonSimpleCrossing.find(current->getP0()) != nonSimpleCrossing.end())
// ||
// simpleCrossing.find(current->getP0())
//!= simpleCrossing.end() )
{
if (current->prev) current->prev->next = 0;
it = inputBoundaries.begin();
break;
}
if (&(*it) == current) ++it;
temp = current->prev;
inputBoundaries.remove(*current);
if (temp) {
assert(temp->prev != current);
if (temp->prev == current) {
temp->prev = 0;
it = inputBoundaries.begin();
break;
}
}
current = temp;
--count;
}
} else
++it;
}
return true;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
#ifdef LEVO
namespace {
void computeIntersections(IntersectionData &intData,
const vector<TStroke *> &strokeArray);
//-------------------------------------------------------------------
void addBranch(IntersectionData &intData, list<IntersectedStroke> &strokeList,
const vector<TStroke *> &s, int ii, double w) {
list<IntersectedStroke>::iterator it;
TPointD tan1, tan2;
double crossVal;
IntersectedStroke item(intData.m_intList.end(), strokeList.end());
item.m_edge.m_s = s[ii];
item.m_edge.m_index = ii;
item.m_edge.m_w0 = w;
tan1 = item.m_edge.m_s->getSpeed(w);
tan2 = ((strokeList.back().m_gettingOut) ? 1 : -1) *
strokeList.back().m_edge.m_s->getSpeed(strokeList.back().m_edge.m_w0);
if (strokeList.size() == 2) // potrebbero essere orientati male; due branch
// possono stare come vogliono, ma col terzo no.
{
TPointD aux = ((strokeList.begin()->m_gettingOut) ? 1 : -1) *
strokeList.begin()->m_edge.m_s->getSpeed(
strokeList.begin()->m_edge.m_w0);
if (cross(aux, tan2) > 0) {
std::reverse(strokeList.begin(), strokeList.end());
tan2 =
((strokeList.back().m_gettingOut) ? 1 : -1) *
strokeList.back().m_edge.m_s->getSpeed(strokeList.back().m_edge.m_w0);
}
}
double lastCross = cross(tan1, tan2);
// UINT size = strokeList.size();
UINT added = 0;
bool endPoint = (w == 0.0 || w == 1.0);
for (it = strokeList.begin(); it != strokeList.end(); it++) {
tan2 = (((*it).m_gettingOut) ? 1 : -1) *
(*it).m_edge.m_s->getSpeed((*it).m_edge.m_w0);
crossVal = cross(tan1, tan2);
if (lastCross > 0 && crossVal < 0 && w != 1.0) {
assert(added != 0x1);
item.m_gettingOut = true;
strokeList.insert(it, item);
added |= 0x1;
if (endPoint || added == 0x3) return;
} else if (lastCross < 0 && crossVal > 0 && w != 0.0) {
assert(added != 0x2);
item.m_gettingOut = false;
strokeList.insert(it, item);
added |= 0x2;
if (endPoint || added == 0x3) return;
}
lastCross = crossVal;
}
if (endPoint) {
item.m_gettingOut = (w == 0.0);
strokeList.push_back(item);
} else {
item.m_gettingOut = (crossVal >= 0);
strokeList.push_back(item);
item.m_gettingOut = !item.m_gettingOut;
strokeList.push_back(item);
}
}
//-----------------------------------------------------------------------------
void addBranches(IntersectionData &intData, Intersection &intersection,
const vector<TStroke *> &s, int ii, int jj,
DoublePair intersectionPair) {
bool foundS1 = false, foundS2 = false;
list<IntersectedStroke>::iterator it;
assert(!intersection.m_strokeList.empty());
for (it = intersection.m_strokeList.begin();
it != intersection.m_strokeList.end(); it++) {
if ((ii >= 0 && (*it).m_edge.m_s == s[ii])) foundS1 = true;
if ((jj >= 0 && (*it).m_edge.m_s == s[jj])) foundS2 = true;
}
if (foundS1 && foundS2) return;
if (!foundS1) {
int size = intersection.m_strokeList.size();
addBranch(intData, intersection.m_strokeList, s, ii,
intersectionPair.first);
assert(intersection.m_strokeList.size() - size > 0);
}
if (!foundS2) {
int size = intersection.m_strokeList.size();
addBranch(intData, intersection.m_strokeList, s, jj,
intersectionPair.second);
// intersection.m_numInter+=intersection.m_strokeList.size()-size;
assert(intersection.m_strokeList.size() - size > 0);
}
}
//-----------------------------------------------------------------------------
#ifdef IS_DOTNET
#define NULL_ITER list<IntersectedStroke>::iterator()
#else
#define NULL_ITER 0
#endif
//-----------------------------------------------------------------------------
Intersection makeIntersection(IntersectionData &intData,
const vector<TStroke *> &s, int ii, int jj,
DoublePair inter) {
Intersection interList;
IntersectedStroke item1(intData.m_intList.end(), NULL_ITER),
item2(intData.m_intList.end(), NULL_ITER);
interList.m_intersection = s[ii]->getPoint(inter.first);
item1.m_edge.m_w0 = inter.first;
item2.m_edge.m_w0 = inter.second;
item1.m_edge.m_s = s[ii];
item1.m_edge.m_index = ii;
item2.m_edge.m_s = s[jj];
item2.m_edge.m_index = jj;
bool reversed = false;
if (cross(item1.m_edge.m_s->getSpeed(inter.first),
item2.m_edge.m_s->getSpeed(inter.second)) > 0)
reversed = true; // std::reverse(interList.m_strokeList.begin(),
// interList.m_strokeList.end());
if (item1.m_edge.m_w0 != 1.0) {
item1.m_gettingOut = true;
interList.m_strokeList.push_back(item1);
}
if (item2.m_edge.m_w0 != (reversed ? 0.0 : 1.0)) {
item2.m_gettingOut = !reversed;
interList.m_strokeList.push_back(item2);
}
if (item1.m_edge.m_w0 != 0.0) {
item1.m_gettingOut = false;
interList.m_strokeList.push_back(item1);
}
if (item2.m_edge.m_w0 != (reversed ? 1.0 : 0.0)) {
item2.m_gettingOut = reversed;
interList.m_strokeList.push_back(item2);
}
return interList;
}
//-----------------------------------------------------------------------------
void addIntersection(IntersectionData &intData, const vector<TStroke *> &s,
int ii, int jj, DoublePair intersection) {
list<Intersection>::iterator it;
TPointD p;
if (areAlmostEqual(intersection.first, 0.0, 1e-9))
intersection.first = 0.0;
else if (areAlmostEqual(intersection.first, 1.0, 1e-9))
intersection.first = 1.0;
if (areAlmostEqual(intersection.second, 0.0, 1e-9))
intersection.second = 0.0;
else if (areAlmostEqual(intersection.second, 1.0, 1e-9))
intersection.second = 1.0;
p = s[ii]->getPoint(intersection.first);
for (it = intData.m_intList.begin(); it != intData.m_intList.end(); it++)
if (areAlmostEqual((*it).m_intersection,
p)) // devono essere rigorosamente uguali, altrimenti
// il calcolo dell'ordine dei rami con le tangenti sballa
{
if ((*it).m_intersection == p)
addBranches(intData, *it, s, ii, jj, intersection);
return;
}
intData.m_intList.push_back(
makeIntersection(intData, s, ii, jj, intersection));
}
//-----------------------------------------------------------------------------
void findNearestIntersection(list<Intersection> &interList) {
list<Intersection>::iterator i1;
list<IntersectedStroke>::iterator i2;
for (i1 = interList.begin(); i1 != interList.end(); i1++) {
for (i2 = (*i1).m_strokeList.begin(); i2 != (*i1).m_strokeList.end();
i2++) {
if ((*i2).m_nextIntersection != interList.end()) // already set
continue;
int versus = (i2->m_gettingOut) ? 1 : -1;
double minDelta = (std::numeric_limits<double>::max)();
list<Intersection>::iterator it1, it1Res;
list<IntersectedStroke>::iterator it2, it2Res;
for (it1 = i1; it1 != interList.end(); ++it1) {
if (it1 == i1)
it2 = i2, it2++;
else
it2 = (*it1).m_strokeList.begin();
for (; it2 != (*it1).m_strokeList.end(); ++it2) {
if ((*it2).m_edge.m_index == i2->m_edge.m_index &&
(*it2).m_gettingOut == !i2->m_gettingOut) {
double delta = versus * (it2->m_edge.m_w0 - i2->m_edge.m_w0);
if (delta > 0 && delta < minDelta) {
it1Res = it1;
it2Res = it2;
minDelta = delta;
}
}
}
}
if (minDelta != (std::numeric_limits<double>::max)()) {
(*it2Res).m_nextIntersection = i1;
(*it2Res).m_nextStroke = i2;
(*it2Res).m_edge.m_w1 = i2->m_edge.m_w0;
(*i2).m_nextIntersection = it1Res;
(*i2).m_nextStroke = it2Res;
(*i2).m_edge.m_w1 = it2Res->m_edge.m_w0;
i1->m_numInter++;
it1Res->m_numInter++;
}
}
}
}
//-----------------------------------------------------------------------------
int myIntersect(const TStroke *s1, const TStroke *s2,
std::vector<DoublePair> &intersections) {
int k = 0;
assert(s1 != s2);
intersections.clear();
for (int i = 0; i < s1->getChunkCount(); i++)
for (int j = 0; j < s2->getChunkCount(); j++) {
const TQuadratic *q1 = s1->getChunk(i);
const TQuadratic *q2 = s2->getChunk(j);
if (!q1->getBBox().overlaps(q2->getBBox())) continue;
if (intersect(*q1, *q2, intersections) > k)
while (k < (int)intersections.size()) {
intersections[k].first =
getWfromChunkAndT(s1, i, intersections[k].first);
intersections[k].second =
getWfromChunkAndT(s2, j, intersections[k].second);
k++;
}
}
return k;
}
//-----------------------------------------------------------------------------
void computeIntersections(IntersectionData &intData,
const vector<TStroke *> &strokeArray) {
int i, j;
assert(intData.m_intersectedStrokeArray.empty());
list<Intersection>::iterator it1;
list<IntersectedStroke>::iterator it2;
for (i = 0; i < (int)strokeArray.size(); i++) {
TStroke *s1 = strokeArray[i];
addIntersection(intData, strokeArray, i, i,
DoublePair(0, 1)); // le stroke sono sicuramente selfloop!
for (j = i + 1; j < (int)strokeArray.size(); j++) {
TStroke *s2 = strokeArray[j];
vector<DoublePair> intersections;
if (s1->getBBox().overlaps(s2->getBBox()) &&
myIntersect(s1, s2, intersections))
for (int k = 0; k < (int)intersections.size(); k++)
addIntersection(intData, strokeArray, i, j, intersections[k]);
}
}
// la struttura delle intersezioni viene poi visitata per trovare
// i link tra un'intersezione e la successiva
findNearestIntersection(intData.m_intList);
// for (it1=intData.m_intList.begin(); it1!=intData.m_intList.end();) //la
// faccio qui, e non nella eraseIntersection. vedi commento li'.
// eraseDeadIntersections(intData.m_intList);
// for (it1=intData.m_intList.begin(); it1!=intData.m_intList.end(); it1++)
// markDeadIntersections(intData.m_intList, it1);
// checkInterList(intData.m_intList);
}
//-----------------------------------------------------------------------------
TRegion *findRegion(list<Intersection> &intList,
list<Intersection>::iterator it1,
list<IntersectedStroke>::iterator it2);
bool isValidArea(const TRegion &r);
//-----------------------------------------------------------------------------
} // namespace
#endif
//-----------------------------------------------------------------------------
bool computeSweepBoundary(const vector<TStroke *> &strokes,
vector<vector<TQuadratic *>> &outlines) {
if (strokes.empty()) return false;
// if(!outlines.empty()) return false;
vector<TStroke *> sweepStrokes;
UINT i = 0;
for (i = 0; i < strokes.size(); i++)
computeBoundaryStroke(*strokes[i], sweepStrokes);
/*if (Count)
return true;
Count++;*/
// ofstream of("c:\\temp\\boh.txt");
for (i = 0; i < sweepStrokes.size(); i++) {
// of<<"****sweepstroke #"<<i<<"*****"<<endl;
outlines.push_back(vector<TQuadratic *>());
vector<TQuadratic *> &q = outlines.back();
for (int j = 0; j < sweepStrokes[i]->getChunkCount(); j++) {
const TThickQuadratic *q0 = sweepStrokes[i]->getChunk(j);
// of<<"q"<<j<<": "<<q0->getP0().x<<", "<<q0->getP0().y<<endl;
// of<<" "<< q0->getP1().x<<", "<<q0->getP1().y<<endl;
// of<<" "<< q0->getP2().x<<", "<<q0->getP2().y<<endl;
q.push_back(new TQuadratic(*q0));
}
}
// return true;
// computeRegions(sweepStrokes, outlines);
clearPointerContainer(sweepStrokes);
return true;
}
//-----------------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
#ifdef LEVO
namespace {
TRegion *findRegion(list<Intersection> &intList,
list<Intersection>::iterator it1,
list<IntersectedStroke>::iterator it2) {
TRegion *r = new TRegion();
// int currStyle=0;
list<IntersectedStroke>::iterator itStart = it2;
list<Intersection>::iterator nextIt1;
list<IntersectedStroke>::iterator nextIt2;
while (!(*it2).m_visited) {
(*it2).m_visited = true;
if ((*it2).m_edge.m_w0 >= (*it2).m_edge.m_w1) {
delete r;
return 0;
}
do {
it2++;
if (it2 == ((*it1).m_strokeList.end())) // la lista e' circolare
it2 = (*it1).m_strokeList.begin();
} while (it2->m_nextIntersection == intList.end());
nextIt1 = (*it2).m_nextIntersection;
nextIt2 = (*it2).m_nextStroke;
r->addEdge(&(*it2).m_edge);
if (nextIt2 == itStart) return r;
it1 = nextIt1;
it2 = nextIt2;
}
delete r;
return 0;
}
//-----------------------------------------------------------------------------
bool isValidArea(const TRegion &r) {
int size = r.getEdgeCount();
if (size == 0) return false;
for (int i = 0; i < size; i++) {
TEdge *e = r.getEdge(i);
if (e->m_w0 < e->m_w1) return false;
}
return true;
}
}
#endif
Reference in a new issue View git blame Copy permalink