35e409e926
Found via `codespell -q 3 -S *.ts,thirdparty, -L appy,ba,inbetween,inout,pevent,possibile,upto`
993 lines
33 KiB
C++
993 lines
33 KiB
C++
|
|
|
|
#include "tregion.h"
|
|
#include "tregionoutline.h"
|
|
#include "tellipticbrushP.h"
|
|
|
|
#include "tstrokeoutline.h"
|
|
|
|
using namespace tellipticbrush;
|
|
|
|
#define USE_LENGTH
|
|
//#define DEBUG_DRAW_TANGENTS
|
|
|
|
//********************************************************************************
|
|
// EXPLANATION
|
|
//********************************************************************************
|
|
|
|
/*! \file tellipticbrush.cpp
|
|
\brief This code performs the outlinization of a \a brush stroke with respect to
|
|
a
|
|
secondary \a path stroke. This is used to draw Adobe Illustrator-like
|
|
vectors whose brush is itself a custom vector (and by extension, a
|
|
complex
|
|
vector image).
|
|
|
|
Generalization: Introduce a repeat % and a superposition % in the
|
|
algorithm
|
|
*/
|
|
|
|
/* TECHNICAL:
|
|
|
|
We have two strokes: one is the 'guideline', the other is the 'brush', and the
|
|
purpose of this algorithm is that of bending the brush to follow the
|
|
guideline.
|
|
|
|
The brush is supposed to be lying horizontally, inside a rectangle
|
|
corresponding
|
|
to the bounding box of the image containing the brush.
|
|
The line segment connecting the midpoints of the vertical image bbox edges
|
|
maps
|
|
to the guideline's centerline.
|
|
Such mapping makes [bbox.x0, bbox.x1] -> [0, 1] in a linear fashion, where the
|
|
image interval represents the parametric space of the guideline.
|
|
|
|
Each vertical scanline of the bbox is further mapped to the segment extruding
|
|
from
|
|
the guideline's centerline along its normal (multiplied in length by the
|
|
guideline's thickness).
|
|
*/
|
|
|
|
//********************************************************************************
|
|
// Geometric helpers
|
|
//********************************************************************************
|
|
|
|
namespace {
|
|
|
|
double getX(const TThickPoint &P0, const TThickPoint &P1, const TThickPoint &P2,
|
|
double t) {
|
|
double one_t = 1.0 - t;
|
|
return P0.x * sq(one_t) + 2.0 * P1.x * t * one_t + P2.x * sq(t);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
TPointD normal(const TPointD &p, bool left) {
|
|
TPointD n(-p.y, p.x);
|
|
return (1.0 / norm(n)) * (left ? n : -n);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
TPointD normal(const TPointD &p) {
|
|
return (1.0 / norm(p)) * TPointD(-p.y, p.x);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void getHRange(const TThickQuadratic &ttq, double &x0, double &x1) {
|
|
const TPointD &P0 = ttq.getP0();
|
|
const TPointD &P1 = ttq.getP1();
|
|
const TPointD &P2 = ttq.getP2();
|
|
|
|
// Get the horizontal range of the chunk
|
|
x0 = std::min({x0, P0.x, P2.x}), x1 = std::max({x1, P0.x, P2.x});
|
|
|
|
double t = (P0.x - P1.x) / (P0.x + P2.x - 2.0 * P1.x);
|
|
if (t > 0.0 && t < 1.0) {
|
|
double x = getX(P0, P1, P2, t);
|
|
x0 = std::min(x0, x), x1 = std::max(x1, x);
|
|
}
|
|
}
|
|
|
|
void getHRange(const TThickQuadratic &ttq, double t0, double t1, double &x0,
|
|
double &x1) {
|
|
const TPointD &P0 = ttq.getP0();
|
|
const TPointD &P1 = ttq.getP1();
|
|
const TPointD &P2 = ttq.getP2();
|
|
|
|
double x0_ = getX(P0, P1, P2, t0);
|
|
double x1_ = getX(P0, P1, P2, t1);
|
|
|
|
// Get the horizontal range of the chunk
|
|
x0 = std::min({x0, x0_, x1_}), x1 = std::max({x1, x0_, x1_});
|
|
|
|
double t = (P0.x - P1.x) / (P0.x + P2.x - 2.0 * P1.x);
|
|
if (t > t0 && t < t1) {
|
|
double x = getX(P0, P1, P2, t);
|
|
x0 = std::min(x0, x), x1 = std::max(x1, x);
|
|
}
|
|
}
|
|
|
|
void getHRange(const TStroke &stroke, double &x0, double &x1) {
|
|
int i, nChunks = stroke.getChunkCount();
|
|
for (i = 0; i < nChunks; ++i) getHRange(*stroke.getChunk(i), x0, x1);
|
|
}
|
|
|
|
//********************************************************************************
|
|
// Outlinization Data
|
|
//********************************************************************************
|
|
|
|
struct StrokeOutlinizationData final
|
|
: public tellipticbrush::OutlinizationData {
|
|
double m_x0, m_x1, m_xRange;
|
|
double m_y0, m_yScale;
|
|
|
|
public:
|
|
StrokeOutlinizationData() : OutlinizationData() {}
|
|
|
|
StrokeOutlinizationData(const TStroke &stroke, const TRectD &strokeBox,
|
|
const TOutlineUtil::OutlineParameter &options)
|
|
: OutlinizationData(options)
|
|
, m_x0(strokeBox.x0)
|
|
, m_x1(strokeBox.x1)
|
|
, m_xRange(m_x1 - m_x0)
|
|
, m_y0(0.5 * (strokeBox.y0 + strokeBox.y1))
|
|
, m_yScale(1.0 / (strokeBox.y1 - strokeBox.y0)) {}
|
|
|
|
void buildPoint(const CenterlinePoint &p, bool isNextD, CenterlinePoint &ref,
|
|
bool isRefNextD, CenterlinePoint &out);
|
|
int buildPoints(const CenterlinePoint &p, CenterlinePoint &ref,
|
|
CenterlinePoint *out);
|
|
int buildPoints(const TStroke &stroke, const TStroke &path,
|
|
CenterlinePoint &cp, CenterlinePoint *out);
|
|
|
|
bool getChunkAndT_param(const TStroke &path, double x, int &chunk, double &t);
|
|
bool getChunkAndT_length(const TStroke &path, double x, int &chunk,
|
|
double &t);
|
|
|
|
double toW(double x);
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
double StrokeOutlinizationData::toW(double x) {
|
|
return tcrop((x - m_x0) / m_xRange, 0.0, 1.0);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
bool StrokeOutlinizationData::getChunkAndT_param(const TStroke &path, double x,
|
|
int &chunk, double &t) {
|
|
double w = toW(x);
|
|
return !path.getChunkAndT(w, chunk, t);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
bool StrokeOutlinizationData::getChunkAndT_length(const TStroke &path, double x,
|
|
int &chunk, double &t) {
|
|
double s = toW(x) * path.getLength();
|
|
return !path.getChunkAndTAtLength(s, chunk, t);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void StrokeOutlinizationData::buildPoint(const CenterlinePoint &p, bool pNextD,
|
|
CenterlinePoint &ref, bool refNextD,
|
|
CenterlinePoint &out) {
|
|
TThickPoint &refD = refNextD ? ref.m_nextD : ref.m_prevD;
|
|
|
|
const TThickPoint *pD;
|
|
TThickPoint *outD;
|
|
bool *outHasD;
|
|
if (pNextD) {
|
|
pD = &p.m_nextD;
|
|
outD = &out.m_nextD;
|
|
outHasD = &out.m_hasNextD;
|
|
} else {
|
|
pD = &p.m_prevD;
|
|
outD = &out.m_prevD;
|
|
outHasD = &out.m_hasPrevD;
|
|
}
|
|
|
|
// Build position
|
|
refD = (1.0 / norm(refD)) * refD;
|
|
TPointD normalDirection(-refD.y, refD.x);
|
|
|
|
double yPercentage = (p.m_p.y - m_y0) * m_yScale;
|
|
double yRelative = yPercentage * ref.m_p.thick;
|
|
double yFactor = ref.m_p.thick * m_yScale;
|
|
|
|
out.m_p = TThickPoint(ref.m_p.x + yRelative * normalDirection.x,
|
|
ref.m_p.y + yRelative * normalDirection.y,
|
|
p.m_p.thick * yFactor);
|
|
|
|
// Build direction
|
|
double stretchedDY = pD->x * yPercentage * refD.thick + pD->y * yFactor;
|
|
|
|
*outD = TThickPoint(refD.x * pD->x - refD.y * stretchedDY,
|
|
refD.y * pD->x + refD.x * stretchedDY,
|
|
pD->thick * (1.0 + refD.thick));
|
|
|
|
bool covered = (sq(outD->x) + sq(outD->y) < sq(outD->thick) + tolPar);
|
|
out.m_covered = out.m_covered && covered;
|
|
|
|
*outHasD = *outHasD && !covered;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
/* EXPLANATION:
|
|
|
|
\ _ \ The path stroke with centerline point C has 2 outward
|
|
\ \ \ directions (prevD and nextD), which may be different.
|
|
\ |* \ Therefore, there may also be 2 different envelope
|
|
directions
|
|
\ * . \ from C (the *s in the drawing).
|
|
C . | When the brush stroke 'hits' one envelope direction, it
|
|
/ * . / transfers on the other e.d., and continues on that side.
|
|
/ _ / * /
|
|
/ / /
|
|
| /
|
|
*/
|
|
|
|
//! Build points resulting from the association between p (must have pos and
|
|
//! dirs
|
|
//! already built) and ref, returning the number of output points stored in
|
|
//! out[] (at max 2).
|
|
int StrokeOutlinizationData::buildPoints(const CenterlinePoint &p,
|
|
CenterlinePoint &ref,
|
|
CenterlinePoint *out) {
|
|
out[0] = out[1] = p;
|
|
out[0].m_covered = out[1].m_covered = true; // Coverage is rebuilt
|
|
|
|
bool refSymmetric =
|
|
ref.m_hasPrevD && ref.m_hasNextD && ref.m_nextD == ref.m_prevD;
|
|
bool pSymmetric = p.m_hasPrevD && p.m_hasNextD && p.m_nextD == p.m_prevD;
|
|
|
|
// Build prev
|
|
bool prevSideIsNext =
|
|
(p.m_prevD.x < 0) ? true : (p.m_prevD.x > 0) ? false : ref.m_hasNextD;
|
|
bool hasPrev =
|
|
p.m_hasPrevD && (prevSideIsNext ? ref.m_hasNextD : ref.m_hasPrevD);
|
|
int prevIdx = hasPrev ? 0 : -1;
|
|
|
|
if (hasPrev) {
|
|
CenterlinePoint &outPoint = out[prevIdx];
|
|
buildPoint(p, false, ref, prevSideIsNext, outPoint);
|
|
}
|
|
|
|
if (refSymmetric && pSymmetric) {
|
|
// Copy prev to next
|
|
if (hasPrev) {
|
|
CenterlinePoint &outPoint = out[prevIdx];
|
|
|
|
outPoint.m_hasNextD = outPoint.m_hasPrevD;
|
|
outPoint.m_nextD = outPoint.m_prevD;
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Build next
|
|
bool nextSideIsNext =
|
|
(p.m_nextD.x > 0) ? true : (p.m_nextD.x < 0) ? false : ref.m_hasNextD;
|
|
bool hasNext =
|
|
p.m_hasNextD && (nextSideIsNext ? ref.m_hasNextD : ref.m_hasPrevD);
|
|
int nextIdx =
|
|
hasNext ? hasPrev ? ((int)prevSideIsNext != nextSideIsNext) : 0 : -1;
|
|
|
|
if (hasNext) {
|
|
CenterlinePoint &outPoint = out[nextIdx];
|
|
buildPoint(p, true, ref, nextSideIsNext, outPoint);
|
|
}
|
|
|
|
// Fill in unbuilt directions if necessary
|
|
if (hasPrev && hasNext && prevIdx != nextIdx) {
|
|
CenterlinePoint &outPrev = out[prevIdx];
|
|
CenterlinePoint &outNext = out[nextIdx];
|
|
|
|
if (dist(outPrev.m_p, outNext.m_p) > 1e-4) {
|
|
// If there are 2 full output points, make their unbuilt directions match
|
|
outPrev.m_nextD = outNext.m_prevD = 0.5 * (outNext.m_p - outPrev.m_p);
|
|
bool covered = (sq(outPrev.m_nextD.x) + sq(outPrev.m_nextD.y) <
|
|
sq(outPrev.m_nextD.thick) + tolPar);
|
|
|
|
outPrev.m_hasNextD = outNext.m_hasPrevD = !covered;
|
|
outPrev.m_covered = outPrev.m_covered && covered;
|
|
outNext.m_covered = outNext.m_covered && covered;
|
|
} else {
|
|
// Merge the 2 existing ones
|
|
nextIdx = prevIdx;
|
|
|
|
outPrev.m_nextD = outNext.m_nextD;
|
|
outPrev.m_hasNextD = outNext.m_hasPrevD;
|
|
outPrev.m_covered = outPrev.m_covered && outNext.m_covered;
|
|
}
|
|
}
|
|
|
|
return std::max(prevIdx, nextIdx) + 1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
int StrokeOutlinizationData::buildPoints(const TStroke &stroke,
|
|
const TStroke &path,
|
|
CenterlinePoint &cp,
|
|
CenterlinePoint *out) {
|
|
const TThickQuadratic &ttq = *stroke.getChunk(cp.m_chunkIdx);
|
|
|
|
const TThickPoint &P0 = ttq.getP0();
|
|
const TThickPoint &P1 = ttq.getP1();
|
|
const TThickPoint &P2 = ttq.getP2();
|
|
|
|
double x = getX(P0, P1, P2, cp.m_t);
|
|
|
|
double pathT;
|
|
int pathChunk;
|
|
#ifdef USE_LENGTH
|
|
bool ok = getChunkAndT_length(path, x, pathChunk, pathT);
|
|
#else
|
|
bool ok = getChunkAndT_param(path, x, pathChunk, pathT);
|
|
#endif
|
|
assert(ok);
|
|
|
|
CenterlinePoint pathCp(pathChunk, pathT);
|
|
|
|
cp.buildPos(stroke);
|
|
cp.buildDirs(stroke);
|
|
pathCp.buildPos(path);
|
|
pathCp.buildDirs(path);
|
|
|
|
return buildPoints(cp, pathCp, out);
|
|
}
|
|
|
|
//********************************************************************************
|
|
// Path-Altered Brush Linearizator (base class)
|
|
//********************************************************************************
|
|
|
|
class ReferenceLinearizator : public tellipticbrush::StrokeLinearizator {
|
|
protected:
|
|
const TStroke *m_path;
|
|
StrokeOutlinizationData m_data;
|
|
|
|
public:
|
|
ReferenceLinearizator(const TStroke *stroke, const TStroke *path,
|
|
const StrokeOutlinizationData &data);
|
|
|
|
virtual void linearize(std::vector<CenterlinePoint> &cPoints, int chunk,
|
|
double t1) = 0;
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
ReferenceLinearizator::ReferenceLinearizator(
|
|
const TStroke *stroke, const TStroke *path,
|
|
const StrokeOutlinizationData &data)
|
|
: StrokeLinearizator(stroke), m_path(path), m_data(data) {}
|
|
|
|
//********************************************************************************
|
|
// Brush Linearizator on Path inter-chunk points
|
|
//********************************************************************************
|
|
|
|
class ReferenceChunksLinearizator final : public ReferenceLinearizator {
|
|
double m_w0, m_w1;
|
|
|
|
public:
|
|
ReferenceChunksLinearizator(const TStroke *stroke, const TStroke *path,
|
|
const StrokeOutlinizationData &data)
|
|
: ReferenceLinearizator(stroke, path, data) {}
|
|
|
|
void linearize(std::vector<CenterlinePoint> &cPoints, int chunk) override;
|
|
void linearize(std::vector<CenterlinePoint> &cPoints, int chunk,
|
|
double t1) override;
|
|
|
|
void addCenterlinePoints(std::vector<CenterlinePoint> &cPoints,
|
|
int brushChunk, double x0, double x1);
|
|
void addCenterlinePoints(std::vector<CenterlinePoint> &cPoints,
|
|
int strokeChunk, double strokeT, int refChunk);
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void ReferenceChunksLinearizator::linearize(
|
|
std::vector<CenterlinePoint> &cPoints, int chunk) {
|
|
// Get the stroke chunk
|
|
const TThickQuadratic &ttq = *this->m_stroke->getChunk(chunk);
|
|
|
|
// Get the chunk's horizontal range
|
|
double x0 = (std::numeric_limits<double>::max)(), x1 = -x0;
|
|
getHRange(ttq, x0, x1);
|
|
|
|
// Now, we have to add all points corresponding to the intersections between
|
|
// the relative
|
|
// vertical projection of path's chunk endpoints, and the stroke
|
|
addCenterlinePoints(cPoints, chunk, x0, x1);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void ReferenceChunksLinearizator::linearize(
|
|
std::vector<CenterlinePoint> &cPoints, int chunk, double t1) {
|
|
if (cPoints.empty()) return;
|
|
|
|
// Get the stroke chunk
|
|
const TThickQuadratic &ttq = *this->m_stroke->getChunk(chunk);
|
|
|
|
// Get the chunk's horizontal range
|
|
double x0 = (std::numeric_limits<double>::max)(), x1 = -x0;
|
|
getHRange(ttq, cPoints[0].m_t, t1, x0, x1);
|
|
|
|
// Now, we have to add all points corresponding to the intersections between
|
|
// the relative
|
|
// vertical projection of path's chunk endpoints, and the stroke
|
|
|
|
addCenterlinePoints(cPoints, chunk, x0, x1);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void ReferenceChunksLinearizator::addCenterlinePoints(
|
|
std::vector<CenterlinePoint> &cPoints, int chunk, double x0, double x1) {
|
|
const TThickQuadratic &ttq = *this->m_stroke->getChunk(chunk);
|
|
const TStroke &path = *this->m_path;
|
|
|
|
int chunk0, chunk1;
|
|
double t0, t1;
|
|
|
|
#ifdef USE_LENGTH
|
|
bool ok0 = m_data.getChunkAndT_length(path, x0, chunk0, t0);
|
|
bool ok1 = m_data.getChunkAndT_length(path, x1, chunk1, t1);
|
|
#else
|
|
bool ok0 = m_data.getChunkAndT_param(path, x0, chunk0, t0);
|
|
bool ok1 = m_data.getChunkAndT_param(path, x1, chunk1, t1);
|
|
#endif
|
|
|
|
assert(ok0 && ok1);
|
|
|
|
const TPointD &P0 = ttq.getP0();
|
|
const TPointD &P1 = ttq.getP1();
|
|
const TPointD &P2 = ttq.getP2();
|
|
|
|
double A = P0.x + P2.x - 2.0 * P1.x;
|
|
double B = P1.x - P0.x;
|
|
double delta_ = sq(B) - P0.x * A; // actual delta = delta_ + x * A;
|
|
|
|
int i, initialSize = cPoints.size();
|
|
for (i = chunk0; i < chunk1; ++i) {
|
|
#ifdef USE_LENGTH
|
|
double s = std::min(path.getLength(i, 1.0) / path.getLength(), 1.0);
|
|
double x = m_data.m_x0 + m_data.m_xRange * s;
|
|
#else
|
|
double w = path.getW(i, 1.0);
|
|
double x = m_data.m_x0 + m_data.m_xRange * w;
|
|
#endif
|
|
|
|
double delta = delta_ + x * A;
|
|
if (delta < 0) continue;
|
|
|
|
// Add first solution
|
|
double t = (sqrt(delta) - B) / A;
|
|
if (t > 0.0 && t < 1.0) // 0 and 1 are dealt outside
|
|
addCenterlinePoints(cPoints, chunk, t, i);
|
|
|
|
if (delta < tolPar) continue;
|
|
|
|
// Add second solution
|
|
t = -(sqrt(delta) + B) / A;
|
|
if (t > 0.0 && t < 1.0) addCenterlinePoints(cPoints, chunk, t, i);
|
|
}
|
|
|
|
// As points may be mixed (by parameter), sort them.
|
|
std::sort(cPoints.begin() + initialSize, cPoints.end());
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void ReferenceChunksLinearizator::addCenterlinePoints(
|
|
std::vector<CenterlinePoint> &cPoints, int strokeChunk, double strokeT,
|
|
int refChunk) {
|
|
CenterlinePoint p(strokeChunk, strokeT);
|
|
CenterlinePoint ref(refChunk, 1.0);
|
|
|
|
CenterlinePoint newPoints[2];
|
|
|
|
p.buildPos(*m_stroke);
|
|
p.buildDirs(*m_stroke);
|
|
ref.buildPos(*m_path);
|
|
ref.buildDirs(*m_path);
|
|
|
|
int i, count = m_data.buildPoints(p, ref, newPoints);
|
|
for (i = 0; i < count; ++i) cPoints.push_back(newPoints[i]);
|
|
}
|
|
|
|
//********************************************************************************
|
|
// Recursive (regular) Reference Stroke Linearizator
|
|
//********************************************************************************
|
|
|
|
class RecursiveReferenceLinearizator final : public ReferenceLinearizator {
|
|
public:
|
|
typedef void (RecursiveReferenceLinearizator::*SubdivisorFuncPtr)(
|
|
std::vector<CenterlinePoint> &cPoints, CenterlinePoint &cp0,
|
|
CenterlinePoint &cp1);
|
|
|
|
SubdivisorFuncPtr m_subdivisor;
|
|
|
|
public:
|
|
void linearize(std::vector<CenterlinePoint> &cPoints, int chunk) override;
|
|
void linearize(std::vector<CenterlinePoint> &cPoints, int chunk,
|
|
double t1) override;
|
|
|
|
void subdivide(std::vector<CenterlinePoint> &cPoints, CenterlinePoint &cp0,
|
|
CenterlinePoint &cp1);
|
|
void subdivideCenterline(std::vector<CenterlinePoint> &cPoints,
|
|
CenterlinePoint &cp0, CenterlinePoint &cp1);
|
|
|
|
public:
|
|
RecursiveReferenceLinearizator(const TStroke *stroke, const TStroke *path,
|
|
const StrokeOutlinizationData &data)
|
|
: ReferenceLinearizator(stroke, path, data)
|
|
, m_subdivisor(&RecursiveReferenceLinearizator::subdivide) {}
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void RecursiveReferenceLinearizator::linearize(
|
|
std::vector<CenterlinePoint> &cPoints, int chunk) {
|
|
linearize(cPoints, chunk, 1.0);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void RecursiveReferenceLinearizator::linearize(
|
|
std::vector<CenterlinePoint> &cPoints, int chunk, double t1) {
|
|
if (cPoints.empty()) return;
|
|
|
|
const TStroke &stroke = *this->m_stroke;
|
|
const TThickQuadratic &ttq = *stroke.getChunk(chunk);
|
|
|
|
const TStroke &path = *this->m_path;
|
|
|
|
// Sort the interval (SHOULD BE DONE OUTSIDE?)
|
|
std::stable_sort(cPoints.begin(), cPoints.end());
|
|
|
|
std::vector<CenterlinePoint> addedPoints;
|
|
|
|
unsigned int i, size_1 = cPoints.size() - 1;
|
|
for (i = 0; i < size_1; ++i) {
|
|
CenterlinePoint &cp1 = cPoints[i], cp2 = cPoints[i + 1];
|
|
if (cp2.m_t - cp1.m_t > 1e-4)
|
|
(this->*m_subdivisor)(addedPoints, cPoints[i], cPoints[i + 1]);
|
|
}
|
|
|
|
if (cPoints[size_1].m_t < t1) {
|
|
double t, x = (t1 == 1.0) ? ttq.getP2().x
|
|
: getX(ttq.getP0(), ttq.getP1(), ttq.getP2(), t1);
|
|
int refChunk;
|
|
|
|
#ifdef USE_LENGTH
|
|
bool ok = m_data.getChunkAndT_length(path, x, refChunk, t);
|
|
#else
|
|
bool ok = m_data.getChunkAndT_param(path, x, refChunk, t);
|
|
#endif
|
|
|
|
CenterlinePoint strokeCpEnd(chunk, t1);
|
|
CenterlinePoint refCp(refChunk, t);
|
|
CenterlinePoint newPoints[2];
|
|
|
|
strokeCpEnd.buildPos(*m_stroke);
|
|
strokeCpEnd.buildDirs(*m_stroke);
|
|
refCp.buildPos(*m_path);
|
|
refCp.buildDirs(*m_path);
|
|
|
|
int count = m_data.buildPoints(strokeCpEnd, refCp, newPoints);
|
|
if (count == 1) // Otherwise, this is either impossible, or already covered
|
|
(this->*m_subdivisor)(addedPoints, cPoints[size_1], newPoints[0]);
|
|
}
|
|
|
|
cPoints.insert(cPoints.end(), addedPoints.begin(), addedPoints.end());
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void RecursiveReferenceLinearizator::subdivide(
|
|
std::vector<CenterlinePoint> &cPoints, CenterlinePoint &cp0,
|
|
CenterlinePoint &cp1) {
|
|
if (!(cp0.m_hasNextD && cp1.m_hasPrevD)) return;
|
|
|
|
const TStroke &stroke = *this->m_stroke;
|
|
const TThickQuadratic &ttq = *stroke.getChunk(cp0.m_chunkIdx);
|
|
|
|
const TStroke &path = *this->m_path;
|
|
|
|
// Build the distance of next from the outline of cp's 'envelope extension'
|
|
|
|
TPointD envDirL0, envDirR0, envDirL1, envDirR1;
|
|
buildEnvelopeDirections(cp0.m_p, cp0.m_nextD, envDirL0, envDirR0);
|
|
buildEnvelopeDirections(cp1.m_p, cp1.m_prevD, envDirL1, envDirR1);
|
|
|
|
TPointD diff(convert(cp1.m_p) - convert(cp0.m_p));
|
|
double d = std::max(fabs(envDirL0 * (diff + cp1.m_p.thick * envDirL1 -
|
|
cp0.m_p.thick * envDirL0)),
|
|
fabs(envDirR0 * (diff + cp1.m_p.thick * envDirR1 -
|
|
cp0.m_p.thick * envDirR0)));
|
|
|
|
if (d > m_data.m_pixSize && cp1.m_t - cp0.m_t > 1e-4) {
|
|
CenterlinePoint strokeMidPoint(cp0.m_chunkIdx, 0.5 * (cp0.m_t + cp1.m_t));
|
|
CenterlinePoint newPoints[2];
|
|
|
|
int count = m_data.buildPoints(*this->m_stroke, *this->m_path,
|
|
strokeMidPoint, newPoints);
|
|
if (count == 1) // Otherwise, this is either impossible, or already covered
|
|
{
|
|
subdivide(cPoints, cp0,
|
|
newPoints[0]); // should I use strokeMidPoint(Prev) here ?
|
|
subdivide(cPoints, newPoints[0], cp1);
|
|
|
|
cPoints.push_back(newPoints[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void RecursiveReferenceLinearizator::subdivideCenterline(
|
|
std::vector<CenterlinePoint> &cPoints, CenterlinePoint &cp0,
|
|
CenterlinePoint &cp1) {
|
|
if (cp0.m_covered || !cp0.m_hasNextD) return;
|
|
|
|
// Build the distance of next from cp's 'direction extension'
|
|
TPointD dir((1.0 / norm(cp0.m_nextD)) * cp0.m_nextD);
|
|
TPointD diff(convert(cp1.m_p) - convert(cp0.m_p));
|
|
|
|
double d = fabs(dir.x * diff.y - dir.y * diff.x);
|
|
|
|
if (d > m_data.m_pixSize && cp1.m_t - cp0.m_t > 1e-4) {
|
|
CenterlinePoint strokeMidPoint(cp0.m_chunkIdx, 0.5 * (cp0.m_t + cp1.m_t));
|
|
CenterlinePoint newPoints[2];
|
|
|
|
int count = m_data.buildPoints(*this->m_stroke, *this->m_path,
|
|
strokeMidPoint, newPoints);
|
|
if (count == 1) // Otherwise, this is either impossible, or already covered
|
|
{
|
|
subdivide(cPoints, cp0,
|
|
newPoints[0]); // should I use strokeMidPoint(Prev) here ?
|
|
subdivide(cPoints, newPoints[0], cp1);
|
|
|
|
cPoints.push_back(newPoints[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//********************************************************************************
|
|
// Make Outline Implementation (stroke version)
|
|
//********************************************************************************
|
|
|
|
//********************************************************************************
|
|
// Make Outline Implementation (stroke version)
|
|
//********************************************************************************
|
|
|
|
/*
|
|
Quick container to store all the linearization features to be supported.
|
|
\note The set should be appropriately ordered so that linearizator dependence
|
|
can be supported (linearizators may work depending on knowledge of the other
|
|
linearized points)
|
|
*/
|
|
struct LinearizatorsSet {
|
|
static const int nLinearizators = 2;
|
|
|
|
ReferenceChunksLinearizator m_refChunksLinearizator;
|
|
RecursiveReferenceLinearizator m_recursiveRefLinearizator;
|
|
|
|
ReferenceLinearizator *m_linearizatorPtrs[nLinearizators];
|
|
|
|
public:
|
|
LinearizatorsSet(const TStroke &stroke, const TStroke &path,
|
|
const StrokeOutlinizationData &data)
|
|
: m_refChunksLinearizator(&stroke, &path, data)
|
|
, m_recursiveRefLinearizator(&stroke, &path, data) {
|
|
m_linearizatorPtrs[0] = &m_refChunksLinearizator;
|
|
m_linearizatorPtrs[1] = &m_recursiveRefLinearizator;
|
|
}
|
|
|
|
ReferenceLinearizator *operator[](int i) { return m_linearizatorPtrs[i]; }
|
|
const int size() const { return nLinearizators; }
|
|
};
|
|
|
|
} // namespace
|
|
|
|
//============================================================================================
|
|
|
|
void TOutlineUtil::makeOutline(const TStroke &path, const TStroke &stroke,
|
|
const TRectD &strokeBox, TStrokeOutline &outline,
|
|
const TOutlineUtil::OutlineParameter &options) {
|
|
// Build outlinization data
|
|
StrokeOutlinizationData data(stroke, strokeBox, options);
|
|
|
|
// Build a set of linearizators for the specified stroke
|
|
LinearizatorsSet linearizators(stroke, path, data);
|
|
CenterlinePoint newPoints[2];
|
|
|
|
std::vector<CenterlinePoint> cPoints, chunkPoints;
|
|
int i, chunksCount = stroke.getChunkCount();
|
|
for (i = 0; i < chunksCount; ++i) {
|
|
chunkPoints.clear();
|
|
|
|
CenterlinePoint cp(i, 0.0);
|
|
int j, count = data.buildPoints(stroke, path, cp, newPoints);
|
|
for (j = 0; j < count; ++j) chunkPoints.push_back(newPoints[j]);
|
|
|
|
int linearsCount = linearizators.size();
|
|
for (j = 0; j < linearsCount; ++j) {
|
|
StrokeLinearizator *linearizator = linearizators[j];
|
|
linearizator->linearize(chunkPoints, i);
|
|
}
|
|
|
|
// These points are just PUSH_BACK'd to the vector. A sorting must be
|
|
// performed
|
|
// before storing them in the overall centerline points vector
|
|
std::stable_sort(chunkPoints.begin(), chunkPoints.end());
|
|
|
|
cPoints.insert(cPoints.end(), chunkPoints.begin(), chunkPoints.end());
|
|
}
|
|
|
|
// Build the final point.
|
|
CenterlinePoint cPoint(chunksCount - 1, 1.0);
|
|
|
|
int count = data.buildPoints(stroke, path, cPoint, newPoints);
|
|
for (i = 0; i < count; ++i) cPoints.push_back(newPoints[i]);
|
|
|
|
// If no centerline point was built, no outline point can, too.
|
|
// This specifically happens when the supplied path is a point.
|
|
if (cPoints.empty()) return;
|
|
|
|
// In the selfLoop case, use its info to modify the initial point.
|
|
if (stroke.isSelfLoop()) {
|
|
CenterlinePoint &lastCp = cPoints[cPoints.size() - 1];
|
|
|
|
cPoints[0].m_prevD = cPoint.m_prevD;
|
|
cPoints[0].m_hasPrevD = true;
|
|
lastCp.m_nextD = cPoint.m_prevD;
|
|
lastCp.m_hasNextD = true;
|
|
}
|
|
|
|
#ifdef DEBUG_DRAW_TANGENTS
|
|
{
|
|
// Debug - draw centerline directions (derivatives)
|
|
glBegin(GL_LINES);
|
|
glColor3d(1.0, 0.0, 0.0);
|
|
|
|
unsigned int i, size = cPoints.size();
|
|
for (i = 0; i < size; ++i) {
|
|
glVertex2d(cPoints[i].m_p.x, cPoints[i].m_p.y);
|
|
glVertex2d(
|
|
cPoints[i].m_p.x + cPoints[i].m_nextD.x * cPoints[i].m_p.thick,
|
|
cPoints[i].m_p.y + cPoints[i].m_nextD.y * cPoints[i].m_p.thick);
|
|
}
|
|
|
|
glEnd();
|
|
}
|
|
#endif
|
|
|
|
// Now, build the outline associated to the linearized centerline
|
|
buildOutline(stroke, cPoints, outline, data);
|
|
}
|
|
|
|
//============================================================================================
|
|
|
|
/*
|
|
TRectD TOutlineUtil::computeBBox(const TStroke &stroke, const TStroke& path)
|
|
{
|
|
typedef TStroke::OutlineOptions OOpts;
|
|
|
|
//First, calculate the usual stroke bbox
|
|
TRectD roundBBox(::computeBBox(stroke));
|
|
const OOpts& oOptions(stroke.outlineOptions());
|
|
|
|
if(oOptions.m_capStyle != OOpts::PROJECTING_CAP && oOptions.m_joinStyle !=
|
|
OOpts::MITER_JOIN)
|
|
return roundBBox;
|
|
|
|
//Build interesting centerline points (in this case, junction points)
|
|
std::vector<CenterlinePoint> cPoints;
|
|
int i, chunksCount = stroke.getChunkCount();
|
|
for(i=0; i<chunksCount; ++i)
|
|
{
|
|
CenterlinePoint cPoint(i, 0.0);
|
|
|
|
cPoint.buildPos(stroke);
|
|
cPoint.buildDirs(stroke);
|
|
cPoints.push_back(cPoint);
|
|
}
|
|
|
|
//Build the final point.
|
|
CenterlinePoint cPoint(chunksCount-1, 1.0);
|
|
|
|
cPoint.buildPos(stroke);
|
|
cPoint.buildDirs(stroke);
|
|
|
|
//In the selfLoop case, use its info to modify the initial point.
|
|
if(stroke.isSelfLoop())
|
|
{
|
|
cPoints[0].m_prevD = cPoint.m_prevD;
|
|
cPoints[0].m_hasPrevD = true;
|
|
cPoint.m_nextD = cPoint.m_prevD;
|
|
cPoint.m_hasNextD = true;
|
|
}
|
|
|
|
cPoints.push_back(cPoint);
|
|
|
|
//Now, add the associated 'extending' outline points
|
|
OutlineBuilder outBuilder(OutlinizationData(), stroke);
|
|
TRectD extensionBBox(
|
|
(std::numeric_limits<double>::max)(),
|
|
(std::numeric_limits<double>::max)(),
|
|
-(std::numeric_limits<double>::max)(),
|
|
-(std::numeric_limits<double>::max)()
|
|
);
|
|
|
|
unsigned int j, cPointsCount = cPoints.size();
|
|
for(j=0; ; ++j)
|
|
{
|
|
//Search the next uncovered point
|
|
for(; j < cPointsCount && cPoints[j].m_covered; ++j)
|
|
;
|
|
|
|
if(j >= cPointsCount)
|
|
break;
|
|
|
|
//Build the associated outline points
|
|
outBuilder.buildOutlineExtensions(extensionBBox, cPoints[j]);
|
|
}
|
|
|
|
//Finally, merge the 2 bboxes
|
|
return roundBBox + extensionBBox;
|
|
}
|
|
*/
|
|
|
|
//============================================================================================
|
|
|
|
namespace {
|
|
|
|
void makeCenterline(const TStroke &path, const TEdge &edge,
|
|
const TRectD ®ionBox, std::vector<T3DPointD> &outline) {
|
|
int initialOutlineSize = outline.size();
|
|
|
|
static const TOutlineUtil::OutlineParameter options;
|
|
const TStroke &stroke = *edge.m_s;
|
|
|
|
double w0 = edge.m_w0, w1 = edge.m_w1;
|
|
bool reversed = w1 < w0;
|
|
if (reversed) w0 = edge.m_w1, w1 = edge.m_w0;
|
|
|
|
// Build outlinization data
|
|
StrokeOutlinizationData data(stroke, regionBox, options);
|
|
|
|
// Build a set of linearizators for the specified stroke
|
|
LinearizatorsSet linearizators(stroke, path, data);
|
|
CenterlinePoint newPoints[2];
|
|
|
|
linearizators.m_recursiveRefLinearizator.m_subdivisor =
|
|
&RecursiveReferenceLinearizator::subdivideCenterline;
|
|
|
|
std::vector<CenterlinePoint> chunkPoints;
|
|
|
|
int i, chunk0, chunk1;
|
|
double t0, t1;
|
|
|
|
bool ok0 = !edge.m_s->getChunkAndT(w0, chunk0, t0);
|
|
bool ok1 = !edge.m_s->getChunkAndT(w1, chunk1, t1);
|
|
|
|
assert(ok0 && ok1);
|
|
|
|
double tStart = t0;
|
|
for (i = chunk0; i < chunk1; ++i, tStart = 0.0) {
|
|
chunkPoints.clear();
|
|
|
|
CenterlinePoint cp(i, tStart);
|
|
int j, count = data.buildPoints(stroke, path, cp, newPoints);
|
|
for (j = 0; j < count; ++j) chunkPoints.push_back(newPoints[j]);
|
|
|
|
int linearsCount = linearizators.size();
|
|
for (j = 0; j < linearsCount; ++j) {
|
|
ReferenceLinearizator *linearizator = linearizators[j];
|
|
linearizator->linearize(chunkPoints, i, 1.0);
|
|
}
|
|
|
|
// These points are just PUSH_BACK'd to the vector. A sorting must be
|
|
// performed
|
|
// before storing them in the overall centerline points vector
|
|
std::stable_sort(chunkPoints.begin(), chunkPoints.end());
|
|
|
|
int size = chunkPoints.size();
|
|
outline.reserve(outline.size() + size);
|
|
|
|
for (j = 0; j < size; ++j) {
|
|
const TPointD &point = chunkPoints[j].m_p;
|
|
outline.push_back(T3DPointD(point.x, point.y, 0.0));
|
|
}
|
|
}
|
|
|
|
// The last one with t1 as endpoint
|
|
{
|
|
chunkPoints.clear();
|
|
|
|
CenterlinePoint cp(chunk1, tStart);
|
|
int j, count = data.buildPoints(stroke, path, cp, newPoints);
|
|
for (j = 0; j < count; ++j) chunkPoints.push_back(newPoints[j]);
|
|
|
|
int linearsCount = linearizators.size();
|
|
for (j = 0; j < linearsCount; ++j) {
|
|
ReferenceLinearizator *linearizator = linearizators[j];
|
|
linearizator->linearize(chunkPoints, chunk1, t1);
|
|
}
|
|
|
|
std::stable_sort(chunkPoints.begin(), chunkPoints.end());
|
|
|
|
int size = chunkPoints.size();
|
|
outline.reserve(outline.size() + size);
|
|
|
|
for (j = 0; j < size; ++j) {
|
|
const TPointD &point = chunkPoints[j].m_p;
|
|
outline.push_back(T3DPointD(point.x, point.y, 0.0));
|
|
}
|
|
}
|
|
|
|
// Finally, add the endpoint
|
|
CenterlinePoint cp(chunk1, t1);
|
|
int j, count = data.buildPoints(stroke, path, cp, newPoints);
|
|
for (j = 0; j < count; ++j) {
|
|
const TPointD &point = newPoints[j].m_p;
|
|
outline.push_back(T3DPointD(point.x, point.y, 0.0));
|
|
}
|
|
|
|
// Eventually, reverse the output
|
|
if (reversed)
|
|
std::reverse(outline.begin() + initialOutlineSize, outline.end());
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void makeOutlineRaw(const TStroke &path, const TRegion ®ion,
|
|
const TRectD ®ionBox, std::vector<T3DPointD> &outline) {
|
|
// Deal with each edge independently
|
|
int e, edgesCount = region.getEdgeCount();
|
|
for (e = 0; e < edgesCount; ++e)
|
|
makeCenterline(path, *region.getEdge(e), regionBox, outline);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void TOutlineUtil::makeOutline(const TStroke &path, const TRegion ®ion,
|
|
const TRectD ®ionBox,
|
|
TRegionOutline &outline) {
|
|
outline.m_doAntialiasing = true;
|
|
|
|
// Build the external boundary
|
|
{
|
|
outline.m_exterior.resize(1);
|
|
outline.m_exterior[0].clear();
|
|
|
|
makeOutlineRaw(path, region, regionBox, outline.m_exterior[0]);
|
|
}
|
|
|
|
// Build internal boundaries
|
|
{
|
|
outline.m_interior.clear();
|
|
|
|
int i, subRegionNumber = region.getSubregionCount();
|
|
outline.m_interior.resize(subRegionNumber);
|
|
|
|
for (i = 0; i < subRegionNumber; i++)
|
|
makeOutlineRaw(path, *region.getSubregion(i), regionBox,
|
|
outline.m_interior[i]);
|
|
}
|
|
|
|
outline.m_bbox = region.getBBox();
|
|
}
|