35e409e926
Found via `codespell -q 3 -S *.ts,thirdparty, -L appy,ba,inbetween,inout,pevent,possibile,upto`
3789 lines
113 KiB
C++
3789 lines
113 KiB
C++
|
|
|
|
#include "tmathutil.h"
|
|
#include "tstrokeutil.h"
|
|
#include "tstrokeoutline.h"
|
|
#include "tcurves.h"
|
|
#include "tbezier.h"
|
|
#include "tzerofinder.h"
|
|
#include "tcurveutil.h"
|
|
#include "cornerdetector.h"
|
|
|
|
#include <limits>
|
|
|
|
#include "tstroke.h"
|
|
|
|
//=============================================================================
|
|
|
|
#define USE_NEW_3D_ERROR_COMPUTE 1
|
|
|
|
//=============================================================================
|
|
|
|
// Some using declaration
|
|
|
|
using namespace TConsts;
|
|
using namespace std;
|
|
|
|
// Some useful typedefs
|
|
|
|
typedef std::vector<double> DoubleArray;
|
|
typedef DoubleArray::iterator DoubleIt;
|
|
typedef std::vector<TThickQuadratic *> QuadStrokeChunkArray;
|
|
|
|
static int numSaved = 0;
|
|
|
|
namespace {
|
|
//---------------------------------------------------------------------------
|
|
|
|
void extractStrokeControlPoints(const QuadStrokeChunkArray &curves,
|
|
vector<TThickPoint> &ctrlPnts) {
|
|
const TThickQuadratic *prev = curves[0];
|
|
assert(prev);
|
|
const TThickQuadratic *curr;
|
|
|
|
ctrlPnts.push_back(prev->getThickP0());
|
|
ctrlPnts.push_back(prev->getThickP1());
|
|
|
|
for (UINT i = 1; i < curves.size(); ++i) {
|
|
curr = curves[i];
|
|
assert(curr);
|
|
TThickPoint middlePnt = (prev->getThickP2() + curr->getThickP0()) * 0.5;
|
|
ctrlPnts.push_back(middlePnt);
|
|
ctrlPnts.push_back(curr->getThickP1());
|
|
prev = curr;
|
|
}
|
|
|
|
ctrlPnts.push_back(prev->getThickP2());
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline TThickPoint adapter(const TThickPoint &tp) { return tp; }
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline TThickPoint adapter(const TPointD &p) { return TThickPoint(p); }
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void buildChunksFromControlPoints(QuadStrokeChunkArray &tq,
|
|
const vector<T> &v) {
|
|
TThickQuadratic *chunk;
|
|
T temp;
|
|
switch (v.size()) {
|
|
case 0:
|
|
tq.push_back(new TThickQuadratic);
|
|
break;
|
|
case 1:
|
|
temp = adapter(v.front());
|
|
chunk = new TThickQuadratic(temp, temp, temp);
|
|
tq.push_back(chunk);
|
|
break;
|
|
case 2: {
|
|
TThickSegment s(adapter(v.front()), adapter(v.back()));
|
|
chunk = new TThickQuadratic(s.getThickP0(), s.getThickPoint(0.5),
|
|
s.getThickP1());
|
|
tq.push_back(chunk);
|
|
} break;
|
|
default:
|
|
assert(v.size() & 1); // v.size() == 2 * chunk + 1
|
|
for (UINT i = 0; i < v.size() - 1; i += 2) {
|
|
chunk = new TThickQuadratic(adapter(v[i]), adapter(v[i + 1]),
|
|
adapter(v[i + 2]));
|
|
tq.push_back(chunk);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
// WARNING duplicata in tellipticbrush
|
|
// dovrebbe essere eliminata da tellipticbrush perche' qui
|
|
// viene usata per eliminare le strokes a thickness negativa
|
|
// evitandone la gestione in tellip...
|
|
inline bool pairValuesAreEqual(const DoublePair &p) {
|
|
return p.first == p.second;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
// WARNING duplicata in tellipticbrush
|
|
// dovrebbe essere eliminata da tellipticbrush perche' qui
|
|
// viene usata per eliminare le strokes a thickness negativa
|
|
// evitandone la gestione in tellip...
|
|
void analyzeSolution(const vector<double> &coeff,
|
|
vector<DoublePair> &interval) {
|
|
// risolve la disequazione coeff[2]*t^2 + coeff[1]*t + coeff[0] >= 0 in [0,
|
|
// 1] ritornando le soluzioni
|
|
// come sotto-intervalli chiusi di [0, 1] (gli intervalli degeneri [s, s]
|
|
// isolati vengono eliminati)
|
|
vector<double> sol;
|
|
// int numberOfIntervalSolution = 0;
|
|
|
|
rootFinding(coeff, sol);
|
|
|
|
if (isAlmostZero(coeff[2])) {
|
|
// disequazione di 1^ grado
|
|
if (isAlmostZero(coeff[1])) {
|
|
if (coeff[0] >= 0) interval.push_back(DoublePair(0.0, 1.0));
|
|
return;
|
|
}
|
|
|
|
double singleSol = -coeff[0] / coeff[1];
|
|
|
|
if (coeff[1] > 0) {
|
|
if (singleSol < 1)
|
|
interval.push_back(DoublePair(std::max(0.0, singleSol), 1.0));
|
|
} else {
|
|
if (singleSol > 0)
|
|
interval.push_back(DoublePair(0.0, std::min(1.0, singleSol)));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// disequazione di 2^ grado effettivo
|
|
// double delta = sq(coeff[1]) - 4*coeff[2]*coeff[0];
|
|
|
|
sort(sol.begin(), sol.end());
|
|
|
|
if (coeff[2] > 0) {
|
|
switch (sol.size()) {
|
|
case 0:
|
|
interval.push_back(DoublePair(0.0, 1.0));
|
|
break;
|
|
|
|
case 1:
|
|
interval.push_back(DoublePair(0.0, 1.0));
|
|
break;
|
|
|
|
case 2:
|
|
interval.push_back(DoublePair(0.0, std::min(std::max(sol[0], 0.0), 1.0)));
|
|
interval.push_back(DoublePair(std::max(std::min(sol[1], 1.0), 0.0), 1.0));
|
|
break;
|
|
}
|
|
} else if (coeff[2] < 0 && sol.size() == 2)
|
|
interval.push_back(DoublePair(std::min(std::max(sol[0], 0.0), 1.0),
|
|
std::max(std::min(sol[1], 1.0), 0.0)));
|
|
|
|
// eat not valid interval
|
|
std::vector<DoublePair>::iterator it =
|
|
std::remove_if(interval.begin(), interval.end(), pairValuesAreEqual);
|
|
|
|
interval.erase(it, interval.end());
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void floorNegativeThickness(TThickQuadratic *quad) {
|
|
assert(quad);
|
|
double val = quad->getThickP0().thick;
|
|
|
|
if (val < 0 && isAlmostZero(val))
|
|
quad->setThickP0(TThickPoint(quad->getP0(), 0.0));
|
|
|
|
val = quad->getThickP1().thick;
|
|
if (val < 0 && isAlmostZero(val))
|
|
quad->setThickP1(TThickPoint(quad->getP1(), 0.0));
|
|
|
|
val = quad->getThickP2().thick;
|
|
if (val < 0 && isAlmostZero(val))
|
|
quad->setThickP2(TThickPoint(quad->getP2(), 0.0));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
// potrebbe essere realizzata come unary function da usare in una transform
|
|
void roundNegativeThickess(QuadStrokeChunkArray &v) {
|
|
QuadStrokeChunkArray protoStroke, tempVectTQ;
|
|
|
|
TThickQuadratic *tempTQ = 0, *tempTQ_1 = 0;
|
|
|
|
int chunkCount = v.size();
|
|
|
|
vector<double> coeff;
|
|
double alpha, beta, gamma;
|
|
|
|
vector<DoublePair> positiveIntervals;
|
|
|
|
for (int i = 0; i < chunkCount; ++i) {
|
|
const TThickQuadratic &ttq = *v[i];
|
|
|
|
alpha = ttq.getThickP0().thick - 2 * ttq.getThickP1().thick +
|
|
ttq.getThickP2().thick;
|
|
beta = 2.0 * (ttq.getThickP1().thick - ttq.getThickP0().thick);
|
|
gamma = ttq.getThickP0().thick;
|
|
|
|
coeff.push_back(gamma);
|
|
coeff.push_back(beta);
|
|
coeff.push_back(alpha);
|
|
|
|
// return sotto-intervalli non degeneri di [0, 1] in cui coeff[2]*t^2 +
|
|
// coeff[1]*t + coeff[0] >= 0
|
|
analyzeSolution(coeff, positiveIntervals);
|
|
|
|
// il caso isAlmostZero(r(t)) per t in [0, 1] e' gestito direttamente da
|
|
// computeOutline
|
|
switch (positiveIntervals.size()) {
|
|
case 0: // r(t) <= 0 per t in [0, 1]
|
|
tempTQ = new TThickQuadratic(ttq);
|
|
tempTQ->setThickP0(TThickPoint(tempTQ->getP0(), 0.0));
|
|
tempTQ->setThickP1(TThickPoint(tempTQ->getP1(), 0.0));
|
|
tempTQ->setThickP2(TThickPoint(tempTQ->getP2(), 0.0));
|
|
protoStroke.push_back(tempTQ);
|
|
break;
|
|
case 1:
|
|
if (positiveIntervals[0].first == 0.0 &&
|
|
positiveIntervals[0].second == 1.0)
|
|
protoStroke.push_back(new TThickQuadratic(ttq));
|
|
else if (positiveIntervals[0].first == 0.0) {
|
|
tempTQ = new TThickQuadratic;
|
|
tempTQ_1 = new TThickQuadratic;
|
|
ttq.split(positiveIntervals[0].first, *tempTQ, *tempTQ_1);
|
|
tempTQ_1->setThickP0(TThickPoint(tempTQ_1->getP0(), 0.0));
|
|
tempTQ_1->setThickP1(TThickPoint(tempTQ_1->getP1(), 0.0));
|
|
tempTQ_1->setThickP2(TThickPoint(tempTQ_1->getP2(), 0.0));
|
|
|
|
floorNegativeThickness(tempTQ);
|
|
protoStroke.push_back(tempTQ);
|
|
protoStroke.push_back(tempTQ_1);
|
|
} else if (positiveIntervals[0].second == 1.0) {
|
|
tempTQ = new TThickQuadratic;
|
|
tempTQ_1 = new TThickQuadratic;
|
|
ttq.split(positiveIntervals[0].first, *tempTQ, *tempTQ_1);
|
|
tempTQ->setThickP0(TThickPoint(tempTQ->getP0(), 0.0));
|
|
tempTQ->setThickP1(TThickPoint(tempTQ->getP1(), 0.0));
|
|
tempTQ->setThickP2(TThickPoint(tempTQ->getP2(), 0.0));
|
|
|
|
protoStroke.push_back(tempTQ);
|
|
floorNegativeThickness(tempTQ_1);
|
|
protoStroke.push_back(tempTQ_1);
|
|
} else {
|
|
coeff.clear();
|
|
coeff.push_back(positiveIntervals[0].first);
|
|
coeff.push_back(positiveIntervals[0].second);
|
|
split<TThickQuadratic>(ttq, coeff, tempVectTQ);
|
|
assert(tempVectTQ.size() == 3);
|
|
|
|
tempVectTQ[0]->setThickP0(TThickPoint(tempVectTQ[0]->getP0(), 0.0));
|
|
tempVectTQ[0]->setThickP1(TThickPoint(tempVectTQ[0]->getP1(), 0.0));
|
|
tempVectTQ[0]->setThickP2(TThickPoint(tempVectTQ[0]->getP2(), 0.0));
|
|
|
|
// controllo che i valori prossimi a zero siano in ogni caso positivi
|
|
floorNegativeThickness(tempVectTQ[1]);
|
|
|
|
tempVectTQ[2]->setThickP0(TThickPoint(tempVectTQ[2]->getP0(), 0.0));
|
|
tempVectTQ[2]->setThickP1(TThickPoint(tempVectTQ[2]->getP1(), 0.0));
|
|
tempVectTQ[2]->setThickP2(TThickPoint(tempVectTQ[2]->getP2(), 0.0));
|
|
|
|
copy(tempVectTQ.begin(), tempVectTQ.end(), back_inserter(protoStroke));
|
|
tempVectTQ
|
|
.clear(); // non serve una clearPointerArray perchè il possesso
|
|
// va alla protoStroke
|
|
}
|
|
break;
|
|
case 2:
|
|
assert(positiveIntervals[0].first == 0.0);
|
|
assert(positiveIntervals[1].second == 1.0);
|
|
|
|
coeff.clear();
|
|
coeff.push_back(positiveIntervals[0].second);
|
|
coeff.push_back(positiveIntervals[1].first);
|
|
split<TThickQuadratic>(ttq, coeff, tempVectTQ);
|
|
assert(tempVectTQ.size() == 3);
|
|
|
|
floorNegativeThickness(tempVectTQ[0]);
|
|
|
|
tempVectTQ[1]->setThickP0(TThickPoint(tempVectTQ[1]->getP0(), 0.0));
|
|
tempVectTQ[1]->setThickP1(TThickPoint(tempVectTQ[1]->getP1(), 0.0));
|
|
tempVectTQ[1]->setThickP2(TThickPoint(tempVectTQ[1]->getP2(), 0.0));
|
|
|
|
floorNegativeThickness(tempVectTQ[2]);
|
|
|
|
copy(tempVectTQ.begin(), tempVectTQ.end(), back_inserter(protoStroke));
|
|
tempVectTQ.clear(); // non serve una clearPointerArray perchè il possesso
|
|
|
|
break;
|
|
}
|
|
|
|
positiveIntervals.clear();
|
|
coeff.clear();
|
|
}
|
|
|
|
swap(protoStroke, v);
|
|
clearPointerContainer(protoStroke);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Some usefuf constant
|
|
// used in printContainer to set number of row to print
|
|
const int MAX_ROW = 10;
|
|
|
|
inline void changeTQDirection(TThickQuadratic *tq) {
|
|
TThickPoint p = tq->getThickP2();
|
|
tq->setThickP2(tq->getThickP0());
|
|
tq->setThickP0(p);
|
|
}
|
|
|
|
/*
|
|
//---------------------------------------------------------------------------
|
|
|
|
double getTQDistance2(const TThickQuadratic& tq,
|
|
const TPointD& p,
|
|
double maxDistance2,
|
|
double& currT)
|
|
{
|
|
TRectD rect = tq.getBBox();
|
|
if (!rect.contains(p))
|
|
{
|
|
double dist21 = tdistance2(p, rect.getP00());
|
|
double dist22 = tdistance2(p, rect.getP01());
|
|
double dist23 = tdistance2(p, rect.getP10());
|
|
double dist24 = tdistance2(p, rect.getP11());
|
|
|
|
if (std::min(dist21, dist22, dist23, dist24)>=maxDistance2)
|
|
return maxDistance2;
|
|
}
|
|
currT = tq.getT(p);
|
|
double dist2 = tdistance2(tq.getPoint(currT), p);
|
|
return (dist2<maxDistance2)?dist2:maxDistance2;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
template <class K, class T>
|
|
void clearMap(std::map<K,T>& v)
|
|
{
|
|
typedef std::map<K,T>::iterator TypeIt;
|
|
|
|
TypeIt it = v.begin();
|
|
|
|
for( ;it!=v.end(); ++it)
|
|
delete it->second;
|
|
|
|
v.clear();
|
|
}
|
|
*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*
|
|
Local binary function to find approx values in a vector.
|
|
*/
|
|
bool bfAreAlmostEqual(double x, double y) {
|
|
double x_y = (x > y) ? x - y : y - x;
|
|
return x_y < TConsts::epsilon;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*
|
|
Sends values of a container in standard input.
|
|
*/
|
|
template <class T>
|
|
void printContainer(const T &c, int maxRow = MAX_ROW) {
|
|
/* DA DECOMMENTARE SE NECESSARIO!!!!!
|
|
//(commentato per non avere dipendenze da tsystem.lib 7/1/2004)
|
|
if (maxRow <=0 ) maxRow = MAX_ROW;
|
|
|
|
typename T::const_iterator cit;
|
|
cit = c.begin();
|
|
stringstream oss1;
|
|
oss1<<'['<<c.size()<<']'<<"=\n";
|
|
TSystem::outputDebug( oss1.str() );
|
|
|
|
int counter = 0;
|
|
for( ; cit != c.end(); ++cit)
|
|
{
|
|
stringstream oss;
|
|
if( ++counter == maxRow-1)
|
|
{
|
|
oss<<'\n';
|
|
counter = 0;
|
|
}
|
|
oss<<(*cit)<<'\n'<<'\0';
|
|
TSystem::outputDebug( oss.str() );
|
|
}
|
|
*/
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
void printContainer(ostream &os, const T &c, int maxRow = MAX_ROW) {
|
|
if (maxRow <= 0) maxRow = MAX_ROW;
|
|
typename T::const_iterator cit;
|
|
cit = c.begin();
|
|
os << '[' << c.size() << ']' << "=\n";
|
|
int counter = 0;
|
|
for (; cit != c.end(); ++cit) {
|
|
if (++counter == maxRow - 1) {
|
|
os << '\n';
|
|
counter = 0;
|
|
}
|
|
os << (*cit) << ' ';
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
void printContainerOfPointer(ostream &os, const T &c, int maxRow = MAX_ROW) {
|
|
if (maxRow <= 0) maxRow = MAX_ROW;
|
|
typename T::const_iterator cit;
|
|
cit = c.begin();
|
|
os << '[' << c.size() << ']' << " - ";
|
|
int counter = 0;
|
|
for (; cit != c.end(); ++cit) {
|
|
if (++counter == maxRow - 1) {
|
|
os << '\n';
|
|
counter = 0;
|
|
}
|
|
os << **cit << ' ';
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*
|
|
Compute a proportion of type x:a=b:c
|
|
*/
|
|
template <class T>
|
|
T proportion(T a, T b, T c) {
|
|
assert(c != T(0));
|
|
return a * b / c;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*
|
|
Compute a proportion of type x-off:a-off=b:c
|
|
*/
|
|
template <class T>
|
|
T proportion(T a, T b, T c, T offset) {
|
|
assert(c != T(0));
|
|
return (a - offset) * b / c + offset;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*!
|
|
backinserter
|
|
*/
|
|
template <typename type_, typename container_>
|
|
class TBackInserterPointer {
|
|
container_ &m_c;
|
|
|
|
public:
|
|
explicit TBackInserterPointer(container_ &c) : m_c(c){};
|
|
|
|
TBackInserterPointer &operator=(const type_ *value) {
|
|
m_c.push_back(new type_(*value));
|
|
return *this;
|
|
}
|
|
|
|
TBackInserterPointer &operator=(const type_ &value) {
|
|
m_c.push_back(new type_(value));
|
|
return *this;
|
|
};
|
|
#ifdef MACOSX
|
|
typedef type_ value_type;
|
|
typedef type_ &reference;
|
|
typedef type_ *pointer;
|
|
typedef output_iterator_tag iterator_category;
|
|
typedef ptrdiff_t difference_type;
|
|
#endif
|
|
/* SIC */
|
|
TBackInserterPointer &operator*() { return *this; }
|
|
TBackInserterPointer &operator++() { return *this; }
|
|
TBackInserterPointer operator++(int val) { return *this; }
|
|
};
|
|
|
|
typedef TBackInserterPointer<TThickQuadratic, QuadStrokeChunkArray>
|
|
TThickQuadraticArrayInsertIterator;
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*!
|
|
simple adapter for find zero algorithm
|
|
*/
|
|
struct computeOffset_ {
|
|
TQuadraticLengthEvaluator m_lengthEval;
|
|
double m_offset;
|
|
|
|
computeOffset_(const TThickQuadratic *ttq, double offset)
|
|
: m_lengthEval(*ttq), m_offset(offset) {}
|
|
|
|
double operator()(double par) {
|
|
return m_lengthEval.getLengthAt(par) - m_offset;
|
|
}
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*!
|
|
simple adapter for find zero algorithm
|
|
*/
|
|
struct computeSpeed_ {
|
|
const TThickQuadratic *ref_;
|
|
|
|
computeSpeed_(const TThickQuadratic *ref) : ref_(ref) {}
|
|
|
|
double operator()(double par) { return norm(ref_->getSpeed(par)); }
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
} // end of unnamed namespace
|
|
|
|
//=============================================================================
|
|
|
|
const BYTE TStroke::c_selected_flag = 0x1;
|
|
const BYTE TStroke::c_changed_region_flag = 0x2;
|
|
const BYTE TStroke::c_dirty_flag = 0x4;
|
|
|
|
//=============================================================================
|
|
//
|
|
// TStroke::Imp
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct TStroke::Imp {
|
|
// Geometry-related infos
|
|
|
|
BYTE m_flag;
|
|
|
|
//! This flag checks if changes occurs and if it is neccessary to update
|
|
//! length.
|
|
bool m_isValidLength;
|
|
|
|
//! This flag checks if changes occurs and if it is neccessary to update
|
|
//! outline.
|
|
bool m_isOutlineValid;
|
|
|
|
//! Control calculus of cache vector.
|
|
bool m_areDisabledComputeOfCaches;
|
|
|
|
//! Bounding Box of a stroke
|
|
TRectD m_bBox;
|
|
|
|
//! This vector contains length computed for each control point of stroke.
|
|
DoubleArray m_partialLengthArray;
|
|
|
|
//! This vector contains parameter computed for each control point of stroke.
|
|
DoubleArray m_parameterValueAtControlPoint;
|
|
|
|
//! This vector contains outline of stroke.
|
|
QuadStrokeChunkArray m_centerLineArray;
|
|
|
|
bool m_selfLoop;
|
|
|
|
int m_negativeThicknessPoints;
|
|
double m_averageThickness;
|
|
double m_maxThickness;
|
|
|
|
//-------------------------------
|
|
|
|
// Not-geometrical vars (style infos)
|
|
|
|
int m_id;
|
|
|
|
int m_styleId;
|
|
TStrokeProp *m_prop;
|
|
|
|
TStroke::OutlineOptions m_outlineOptions;
|
|
|
|
//-------------------------------
|
|
|
|
Imp();
|
|
|
|
Imp(const vector<TPointD> &v);
|
|
|
|
Imp(const vector<TThickPoint> &v);
|
|
|
|
~Imp() {
|
|
delete m_prop;
|
|
clearPointerContainer(m_centerLineArray);
|
|
// delete m_style;
|
|
}
|
|
|
|
void init();
|
|
|
|
// void computeOutlines( double pixelSize );
|
|
|
|
inline double getW(int index) {
|
|
return ((int)m_parameterValueAtControlPoint.size() > index)
|
|
? m_parameterValueAtControlPoint[index]
|
|
: m_parameterValueAtControlPoint.back();
|
|
}
|
|
|
|
TRectD computeCenterlineBBox();
|
|
/*!
|
|
It computes the bounding box of the subStroke in the parameter range w0-w1.
|
|
*/
|
|
|
|
void computeMaxThickness();
|
|
|
|
TRectD computeSubBBox(double w0, double w1) const;
|
|
|
|
inline QuadStrokeChunkArray &getTQArray() { return m_centerLineArray; }
|
|
|
|
/*!
|
|
Swaps the geometrical infos only
|
|
*/
|
|
void swapGeometry(TStroke::Imp &other) throw();
|
|
|
|
//! compute cache vector
|
|
void computeCacheVector();
|
|
|
|
/*!
|
|
Set value in m_parameterValueAtControlPoint
|
|
*/
|
|
void computeParameterInControlPoint();
|
|
|
|
/*!
|
|
Update parameter in m_parameterValueAtControlPoint
|
|
after insert of control point in stroke.
|
|
*/
|
|
void updateParameterValue(double w, UINT chunk, TThickQuadratic *tq1,
|
|
TThickQuadratic *tq2);
|
|
|
|
/*!
|
|
From parameter w retrieves chunk and its parameter ( t in [0,1] ).
|
|
Return
|
|
true -> error (parameter w out of range, etc)
|
|
false -> ok
|
|
*/
|
|
bool retrieveChunkAndItsParamameter(double w, int &chunk, double &t);
|
|
|
|
/*!
|
|
From length s retrieves chunk and its parameter ( t in [0,1] ).
|
|
Return
|
|
true -> error (parameter w out of range, etc)
|
|
false -> ok
|
|
*/
|
|
bool retrieveChunkAndItsParamameterAtLength(double s, int &chunk, double &t);
|
|
|
|
/*!
|
|
Retrieve chunk which contains the n-th control point of stroke.
|
|
If control point is between two chunks return the left point.
|
|
*/
|
|
int retrieveChunkFromControlPointIndex(int n) {
|
|
assert(0 <= n && n < getControlPointCount());
|
|
|
|
if (n & 1) ++n;
|
|
|
|
n >>= 1;
|
|
|
|
return n ? n - 1 : n;
|
|
};
|
|
|
|
/*!
|
|
Retrieve range for a chunk.
|
|
*/
|
|
DoublePair retrieveParametersFromChunk(UINT chunk) {
|
|
DoublePair outPar;
|
|
|
|
int nFirst, nSecond;
|
|
|
|
nFirst = chunk * 2;
|
|
nSecond = (chunk + 1) * 2;
|
|
|
|
outPar.first = getW(nFirst);
|
|
outPar.second = getW(nSecond);
|
|
|
|
return outPar;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void print(ostream &os);
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline int getChunkCount() const { return m_centerLineArray.size(); }
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline int getControlPointCount() const {
|
|
UINT out = 2 * getChunkCount() + 1;
|
|
return out;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TThickQuadratic *getChunk(int index) {
|
|
if (0 <= index && index < getChunkCount()) return m_centerLineArray[index];
|
|
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
// Declared but not defined.
|
|
Imp(const Imp &other);
|
|
Imp &operator=(const Imp &other);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace {
|
|
int maxStrokeId = 0;
|
|
}
|
|
|
|
/*! init() is required to initialize all variable
|
|
Call init after centerline initialization, because
|
|
it's necessary to compute BBox
|
|
*/
|
|
void TStroke::Imp::init() {
|
|
m_flag = c_dirty_flag;
|
|
|
|
m_styleId = 1; // DefaultStrokeStyle;
|
|
m_prop = 0;
|
|
|
|
m_id = ++maxStrokeId;
|
|
m_isValidLength = false;
|
|
m_isOutlineValid = false;
|
|
m_areDisabledComputeOfCaches = false;
|
|
m_selfLoop = false;
|
|
m_averageThickness = 0;
|
|
m_maxThickness = -1;
|
|
m_negativeThicknessPoints = 0;
|
|
for (UINT j = 0; j < m_centerLineArray.size(); j++) {
|
|
if (m_centerLineArray[j]->getThickP0().thick <= 0)
|
|
m_negativeThicknessPoints++;
|
|
if (m_centerLineArray[j]->getThickP1().thick <= 0)
|
|
m_negativeThicknessPoints++;
|
|
}
|
|
if (!m_centerLineArray.empty() &&
|
|
m_centerLineArray.back()->getThickP2().thick <= 0)
|
|
m_negativeThicknessPoints++;
|
|
|
|
computeParameterInControlPoint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::Imp::Imp() { init(); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::Imp::Imp(const std::vector<TThickPoint> &v) {
|
|
buildChunksFromControlPoints(m_centerLineArray, v);
|
|
roundNegativeThickess(m_centerLineArray);
|
|
|
|
init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::Imp::Imp(const std::vector<TPointD> &v) {
|
|
buildChunksFromControlPoints(m_centerLineArray, v);
|
|
roundNegativeThickess(m_centerLineArray);
|
|
|
|
init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::Imp::swapGeometry(Imp &other) throw() {
|
|
std::swap(m_flag, other.m_flag);
|
|
std::swap(m_isValidLength, other.m_isValidLength);
|
|
std::swap(m_isOutlineValid, other.m_isOutlineValid);
|
|
std::swap(m_areDisabledComputeOfCaches, other.m_areDisabledComputeOfCaches);
|
|
std::swap(m_bBox, other.m_bBox);
|
|
std::swap(m_partialLengthArray, other.m_partialLengthArray);
|
|
std::swap(m_parameterValueAtControlPoint,
|
|
other.m_parameterValueAtControlPoint);
|
|
std::swap(m_centerLineArray, other.m_centerLineArray);
|
|
std::swap(m_selfLoop, other.m_selfLoop);
|
|
std::swap(m_negativeThicknessPoints, other.m_negativeThicknessPoints);
|
|
std::swap(m_averageThickness, other.m_averageThickness);
|
|
std::swap(m_maxThickness, other.m_maxThickness);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::Imp::computeMaxThickness() {
|
|
m_maxThickness = m_centerLineArray[0]->getThickP0().thick;
|
|
for (UINT i = 0; i < m_centerLineArray.size(); i++)
|
|
m_maxThickness =
|
|
std::max({m_maxThickness, m_centerLineArray[i]->getThickP1().thick,
|
|
m_centerLineArray[i]->getThickP2().thick});
|
|
}
|
|
|
|
void TStroke::Imp::computeCacheVector() {
|
|
// se la stroke e' stata invalidata a causa dell'inserimento di punti
|
|
// di controllo o dal ricampionamento
|
|
if (!m_areDisabledComputeOfCaches && !m_isValidLength) {
|
|
if (getChunkCount() > 0) // se ci sono cionchi
|
|
{
|
|
// (re)inizializzo un vettore
|
|
m_partialLengthArray.resize(getControlPointCount(),
|
|
(std::numeric_limits<double>::max)());
|
|
|
|
m_partialLengthArray[0] = 0.0;
|
|
|
|
double length = 0.0;
|
|
int j = 0;
|
|
const TThickQuadratic *tq;
|
|
|
|
TQuadraticLengthEvaluator lengthEvaluator;
|
|
|
|
for (int i = 0; i < getChunkCount(); ++i) {
|
|
assert(j <= getControlPointCount());
|
|
tq = getChunk(i);
|
|
lengthEvaluator.setQuad(*tq);
|
|
m_partialLengthArray[j++] = length;
|
|
m_partialLengthArray[j++] = length + lengthEvaluator.getLengthAt(0.5);
|
|
length += lengthEvaluator.getLengthAt(1.0);
|
|
}
|
|
|
|
m_partialLengthArray[j++] = length;
|
|
assert(j == getControlPointCount());
|
|
// assert( m_parameterValueAtControlPoint.size() ==
|
|
// m_partialLengthArray.size() );
|
|
}
|
|
m_isValidLength = true;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::Imp::computeParameterInControlPoint() {
|
|
if (!m_areDisabledComputeOfCaches) {
|
|
// questa funzione ricalcola i valori dei parametri nei cionchi
|
|
// N.B. deve essere richiamata quando si effettuano inserimenti
|
|
// di punti di controllo che cambiano la lunghezza della curva
|
|
// insert, push e costruttore
|
|
if (!getChunkCount()) {
|
|
m_parameterValueAtControlPoint.clear();
|
|
return;
|
|
}
|
|
|
|
int controlPointCount = getControlPointCount();
|
|
|
|
m_parameterValueAtControlPoint.resize(controlPointCount, 0);
|
|
|
|
// N.B. number of control point is reduced of 1
|
|
--controlPointCount;
|
|
|
|
double val = 0.0;
|
|
|
|
assert(controlPointCount >= 0.0);
|
|
|
|
for (int i = 0; i <= controlPointCount; ++i) {
|
|
val = i / (double)controlPointCount;
|
|
m_parameterValueAtControlPoint[i] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::Imp::updateParameterValue(double w, UINT chunk,
|
|
TThickQuadratic *tq1,
|
|
TThickQuadratic *tq2) {
|
|
DoublePair p = retrieveParametersFromChunk(chunk);
|
|
|
|
UINT controlPointToErase = 2 * chunk + 1;
|
|
DoubleIt it = m_parameterValueAtControlPoint.begin();
|
|
std::advance(it, controlPointToErase);
|
|
m_parameterValueAtControlPoint.erase(it);
|
|
|
|
double normalizedParam = tq2->getT(tq2->getP1());
|
|
|
|
std::vector<double>::iterator first;
|
|
|
|
normalizedParam = proportion(p.second, normalizedParam, 1.0, w);
|
|
|
|
first =
|
|
std::upper_bound(m_parameterValueAtControlPoint.begin(),
|
|
m_parameterValueAtControlPoint.end(), normalizedParam);
|
|
|
|
if (first != m_parameterValueAtControlPoint.end()) {
|
|
first = m_parameterValueAtControlPoint.insert(first, normalizedParam);
|
|
|
|
first = m_parameterValueAtControlPoint.insert(first, w);
|
|
|
|
normalizedParam = tq1->getT(tq1->getP1());
|
|
normalizedParam = proportion(w, normalizedParam, 1.0, p.first);
|
|
|
|
m_parameterValueAtControlPoint.insert(first, normalizedParam);
|
|
}
|
|
|
|
/* FAB
|
|
assert( getControlPointCount() <=
|
|
(int)m_parameterValueAtControlPoint.size() );
|
|
//*/
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::getChunkAndTAtLength(double s, int &chunk, double &t) const {
|
|
return m_imp->retrieveChunkAndItsParamameterAtLength(s, chunk, t);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::Imp::retrieveChunkAndItsParamameterAtLength(double s, int &chunk,
|
|
double &t) {
|
|
vector<double>::iterator first;
|
|
|
|
// cerco nella cache la posizione che compete alla lunghezza s
|
|
first = std::upper_bound(m_partialLengthArray.begin(),
|
|
m_partialLengthArray.end(), s);
|
|
|
|
// se s e' interna al vettore di cache
|
|
if (first != m_partialLengthArray.end()) {
|
|
// individuo il punto di controllo della stroke...
|
|
int controlPointOffset = distance(m_partialLengthArray.begin(), first);
|
|
|
|
// ...e da questo il cionco relativo.
|
|
chunk = retrieveChunkFromControlPointIndex(controlPointOffset);
|
|
|
|
if (first != m_partialLengthArray.begin() && s == *(first - 1)) {
|
|
controlPointOffset--;
|
|
if (controlPointOffset & 1) {
|
|
const DoublePair &p = retrieveParametersFromChunk(chunk);
|
|
t = proportion(1.0, getW(controlPointOffset) - p.first,
|
|
p.second - p.first);
|
|
} else
|
|
t = 0.0;
|
|
|
|
return false;
|
|
}
|
|
|
|
// fisso un offset per l'algoritmo di bisezione
|
|
double offset = (first == m_partialLengthArray.begin())
|
|
? s
|
|
: s - m_partialLengthArray[chunk * 2];
|
|
|
|
// cerco il parametro minimo a meno di una tolleranza epsilon
|
|
|
|
const double tol = TConsts::epsilon * 0.1;
|
|
int err;
|
|
|
|
computeOffset_ op(getChunk(chunk), offset);
|
|
computeSpeed_ op2(getChunk(chunk));
|
|
|
|
if (!findZero_Newton(0.0, 1.0, op, op2, tol, tol, 100, t, err))
|
|
t = -1; // if can not find a good value set parameter to error value
|
|
|
|
// se l'algoritmo di ricerca ha fallito fissa il valore ad uno dei due
|
|
// estremi
|
|
if (t == -1) {
|
|
if (s <= m_partialLengthArray[controlPointOffset]) t = 0.0;
|
|
t = 1.0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (s <= 0.0) {
|
|
chunk = 0;
|
|
t = 0.0;
|
|
} else if (s >= m_partialLengthArray.back()) {
|
|
chunk = getChunkCount() - 1;
|
|
t = 1.0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::getChunkAndT(double w, int &chunk, double &t) const {
|
|
return m_imp->retrieveChunkAndItsParamameter(w, chunk, t);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::Imp::retrieveChunkAndItsParamameter(double w, int &chunk,
|
|
double &t) {
|
|
vector<double>::iterator first;
|
|
|
|
// trova l'iteratore alla prima posizione che risulta maggiore o uguale a w
|
|
first = std::lower_bound(m_parameterValueAtControlPoint.begin(),
|
|
m_parameterValueAtControlPoint.end(), w);
|
|
|
|
// se non e' stato possibile trovare w nel vettore ritorna errore
|
|
if (first == m_parameterValueAtControlPoint.end()) return true;
|
|
/* FAB
|
|
double
|
|
found = *first;
|
|
assert(found <= *first);
|
|
//*/
|
|
// individuo il punto di controllo che compete alla posizione nel vettore
|
|
int controlPointOffset =
|
|
distance(m_parameterValueAtControlPoint.begin(), first);
|
|
|
|
// individuo il cionco relativo al punto di controllo
|
|
chunk = retrieveChunkFromControlPointIndex(controlPointOffset);
|
|
|
|
// calcolo il parametro relativo al cionco
|
|
DoublePair p = retrieveParametersFromChunk(chunk);
|
|
/* FAB
|
|
assert( p.first <= w &&
|
|
w <= p.second );
|
|
|
|
#ifdef _DEBUG
|
|
chunk = retrieveChunkFromControlPointIndex( controlPointOffset );
|
|
p = retrieveParametersFromChunk( chunk );
|
|
#endif
|
|
//*/
|
|
|
|
if (w < p.first || w > p.second) {
|
|
t = (p.first + p.second) * 0.5;
|
|
} else
|
|
t = proportion(1.0, w - p.first, p.second - p.first);
|
|
|
|
/* FAB
|
|
assert( 0.0 <= t && t <= 1.0 );
|
|
//*/
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TRectD TStroke::Imp::computeCenterlineBBox() {
|
|
UINT n = m_centerLineArray.size();
|
|
if (m_centerLineArray.empty()) return TRectD();
|
|
TQuadratic q(m_centerLineArray[0]->getP0(), m_centerLineArray[0]->getP1(),
|
|
m_centerLineArray[0]->getP2());
|
|
TRectD bbox = q.getBBox();
|
|
for (UINT i = 1; i < n; i++) {
|
|
q = TQuadratic(m_centerLineArray[i]->getP0(), m_centerLineArray[i]->getP1(),
|
|
m_centerLineArray[i]->getP2());
|
|
bbox += q.getBBox();
|
|
}
|
|
return bbox;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TRectD TStroke::Imp::computeSubBBox(double w0, double w1) const {
|
|
if (m_centerLineArray.empty()) return TRectD();
|
|
|
|
int n = m_centerLineArray.size();
|
|
|
|
TRectD bBox;
|
|
const double eps = 0.000000001;
|
|
int i;
|
|
|
|
if (w0 > w1) std::swap(w0, w1);
|
|
|
|
double nw0 = w0 * n;
|
|
double nw1 = w1 * n;
|
|
|
|
int i0 = (int)nw0; // indice della quadrica che contiene w0
|
|
int i1 = (int)nw1; // idem per w1
|
|
|
|
double t0 =
|
|
nw0 -
|
|
(double)i0; // parametro di w0 rispetto alla quadrica che lo contiene
|
|
double t1 = nw1 - (double)i1; // idem per w1
|
|
|
|
if (t0 < eps) // se t0 e' quasi uguale a zero, evito di fare lo split e
|
|
// considero tutta la quadrica i0
|
|
{
|
|
i0--;
|
|
t0 = 1.0;
|
|
}
|
|
if (t1 > (1 - eps)) // se t1 e' quasi uguale a uno, evito di fare lo split e
|
|
// considero tutta la quadrica i1
|
|
{
|
|
i1++;
|
|
t1 = 0.0;
|
|
}
|
|
|
|
TThickQuadratic quadratic1, quadratic2, quadratic3;
|
|
|
|
if (i0 == i1) // i due punti di taglio capitano nella stessa quadratica
|
|
{
|
|
if (t0 < eps && t1 > (1 - eps)) return m_centerLineArray[i0]->getBBox();
|
|
|
|
if (t0 < eps) {
|
|
m_centerLineArray[i0]->split(t1, quadratic1, quadratic2);
|
|
return quadratic1.getBBox();
|
|
}
|
|
|
|
if (t1 > (1 - eps)) {
|
|
m_centerLineArray[i0]->split(t0, quadratic1, quadratic2);
|
|
return quadratic2.getBBox();
|
|
}
|
|
|
|
// quadratic1 e' la quadratica risultante dallo split tra t0 e t1 di
|
|
// m_centerLineArray[i0]
|
|
m_centerLineArray[i0]->split(t0, quadratic1, quadratic2);
|
|
quadratic2.split((t1 - t0) / (1 - t0), quadratic1, quadratic3);
|
|
|
|
return quadratic1.getBBox();
|
|
}
|
|
|
|
// se i due punti di taglio capitano in quadratiche diverse
|
|
|
|
// sommo le bbox di quelle interne
|
|
for (i = i0 + 1; i < i1; i++) bBox += m_centerLineArray[i]->getBBox();
|
|
|
|
// e sommo le bbox delle quadratiche splittate agli estremi se non sono
|
|
// irrilevanti
|
|
if (i0 >= 0 && t0 < (1 - eps)) {
|
|
m_centerLineArray[i0]->split(t0, quadratic1, quadratic2);
|
|
bBox += quadratic2.getBBox();
|
|
}
|
|
|
|
if (i1 < n && t1 > eps) {
|
|
m_centerLineArray[i1]->split(t1, quadratic1, quadratic2);
|
|
bBox += quadratic1.getBBox();
|
|
}
|
|
|
|
return bBox;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::Imp::print(ostream &os) {
|
|
#if defined(_DEBUG) || defined(DEBUG)
|
|
|
|
os << "m_isValidLength:" << m_isValidLength << endl;
|
|
|
|
os << "m_isOutlineValid:" << m_isOutlineValid << endl;
|
|
|
|
os << "m_areDisabledComputeOfCaches:" << m_areDisabledComputeOfCaches << endl;
|
|
|
|
os << "m_bBox:" << m_bBox << endl;
|
|
|
|
os << "m_partialLengthArray";
|
|
printContainer(os, m_partialLengthArray);
|
|
os << endl;
|
|
|
|
os << "m_parameterValueAtControlPoint";
|
|
printContainer(os, m_parameterValueAtControlPoint);
|
|
os << endl;
|
|
|
|
os << "m_centerLineArray";
|
|
// os.setf(myIOFlags::scientific);
|
|
printContainerOfPointer(os, m_centerLineArray);
|
|
os << endl;
|
|
|
|
/*
|
|
vector<TPixel> m_outlineColorArray;
|
|
|
|
vector<TPointD> m_texArray;
|
|
|
|
TFilePath m_filePath;
|
|
TRasterP m_texture;
|
|
*/
|
|
// TSystem::outputDebug( os.str());
|
|
#else
|
|
#endif
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
// Needed to DEBUG
|
|
DEFINE_CLASS_CODE(TStroke, 15)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Constructor
|
|
TStroke::TStroke() : TSmartObject(m_classCode) {
|
|
vector<TThickPoint> p(3);
|
|
p[0] = TThickPoint(0, 0, 0);
|
|
p[1] = p[0];
|
|
p[2] = p[1];
|
|
|
|
m_imp.reset(new TStroke::Imp(p));
|
|
|
|
/*
|
|
// da fissare deve trovarsi prima della init
|
|
m_imp->m_centerLineArray.push_back ( new TThickQuadratic );
|
|
*/
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Build a stroke from a set of ThickPoint
|
|
TStroke::TStroke(const vector<TThickPoint> &v)
|
|
: TSmartObject(m_classCode), m_imp(new TStroke::Imp(v)) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::TStroke(const vector<TPointD> &v)
|
|
: TSmartObject(m_classCode), m_imp(new TStroke::Imp(v)) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::~TStroke() {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::TStroke(const TStroke &other)
|
|
: TSmartObject(m_classCode), m_imp(new TStroke::Imp()) {
|
|
m_imp->m_bBox = other.getBBox();
|
|
m_imp->m_isValidLength = other.m_imp->m_isValidLength;
|
|
m_imp->m_isOutlineValid = other.m_imp->m_isOutlineValid;
|
|
m_imp->m_areDisabledComputeOfCaches =
|
|
other.m_imp->m_areDisabledComputeOfCaches;
|
|
m_imp->m_flag = other.m_imp->m_flag;
|
|
m_imp->m_outlineOptions = other.m_imp->m_outlineOptions;
|
|
|
|
// Are they sure as regards exceptions ?
|
|
m_imp->m_centerLineArray.resize(other.m_imp->m_centerLineArray.size());
|
|
int i;
|
|
for (i = 0; i < (int)other.m_imp->m_centerLineArray.size(); i++)
|
|
m_imp->m_centerLineArray[i] =
|
|
new TThickQuadratic(*other.m_imp->m_centerLineArray[i]);
|
|
|
|
// copy( other.m_imp->m_centerLineArray.begin(),
|
|
// other.m_imp->m_centerLineArray.end(),
|
|
// TThickQuadraticArrayInsertIterator(m_imp->m_centerLineArray));
|
|
|
|
copy(other.m_imp->m_partialLengthArray.begin(),
|
|
other.m_imp->m_partialLengthArray.end(),
|
|
back_inserter<DoubleArray>(m_imp->m_partialLengthArray));
|
|
copy(other.m_imp->m_parameterValueAtControlPoint.begin(),
|
|
other.m_imp->m_parameterValueAtControlPoint.end(),
|
|
back_inserter<DoubleArray>(m_imp->m_parameterValueAtControlPoint));
|
|
|
|
m_imp->m_styleId = other.m_imp->m_styleId;
|
|
m_imp->m_prop =
|
|
0; // other.m_imp->m_prop ? other.m_imp->m_prop->clone(this) : 0;
|
|
m_imp->m_selfLoop = other.m_imp->m_selfLoop;
|
|
m_imp->m_negativeThicknessPoints = other.m_imp->m_negativeThicknessPoints;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke &TStroke::operator=(const TStroke &other) {
|
|
TStroke temp(other);
|
|
swap(temp);
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::getNearestW(const TPointD &p, double &outW, double &dist2,
|
|
bool checkBBox) const {
|
|
double outT;
|
|
int chunkIndex;
|
|
bool ret = getNearestChunk(p, outT, chunkIndex, dist2, checkBBox);
|
|
if (ret) outW = getW(chunkIndex, outT);
|
|
return ret;
|
|
}
|
|
|
|
bool TStroke::getNearestChunk(const TPointD &p, double &outT, int &chunkIndex,
|
|
double &dist2, bool checkBBox) const {
|
|
dist2 = (numeric_limits<double>::max)();
|
|
|
|
for (UINT i = 0; i < m_imp->m_centerLineArray.size(); i++) {
|
|
if (checkBBox &&
|
|
!m_imp->m_centerLineArray[i]->getBBox().enlarge(30).contains(p))
|
|
continue;
|
|
|
|
double t = (m_imp->m_centerLineArray)[i]->getT(p);
|
|
double dist = tdistance2((m_imp->m_centerLineArray)[i]->getPoint(t), p);
|
|
|
|
if (dist < dist2) {
|
|
dist2 = dist;
|
|
chunkIndex = i;
|
|
outT = t;
|
|
}
|
|
}
|
|
|
|
return dist2 < (numeric_limits<double>::max)();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// finds all points on stroke which are "enough" close to point p. return the
|
|
// number of such points.
|
|
|
|
int TStroke::getNearChunks(const TThickPoint &p,
|
|
vector<TThickPoint> &pointsOnStroke,
|
|
bool checkBBox) const {
|
|
int currIndex = -100;
|
|
double currDist2 = 100000;
|
|
|
|
for (UINT i = 0; i < m_imp->m_centerLineArray.size(); i++) {
|
|
TThickQuadratic *q = m_imp->m_centerLineArray[i];
|
|
|
|
if (checkBBox && !q->getBBox().enlarge(30).contains(p)) continue;
|
|
|
|
double t = q->getT(p);
|
|
TThickPoint p1 = q->getThickPoint(t);
|
|
double dist2 = tdistance2(p1, p);
|
|
|
|
if (dist2 < (p1.thick + p.thick + 5) * (p1.thick + p.thick + 5)) {
|
|
if (!pointsOnStroke.empty() &&
|
|
areAlmostEqual(p1, pointsOnStroke.back(), 1e-3))
|
|
continue;
|
|
|
|
if (currIndex == i - 1) {
|
|
if (dist2 < currDist2)
|
|
pointsOnStroke.pop_back();
|
|
else
|
|
continue;
|
|
}
|
|
|
|
currIndex = i;
|
|
currDist2 = dist2;
|
|
pointsOnStroke.push_back(p1);
|
|
}
|
|
}
|
|
|
|
return pointsOnStroke.size(); // dist2 < (numeric_limits<double>::max)();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::getControlPoints(vector<TThickPoint> &v) const {
|
|
assert(v.empty());
|
|
v.resize(m_imp->m_centerLineArray.size() * 2 + 1);
|
|
|
|
v[0] = m_imp->m_centerLineArray[0]->getThickP0();
|
|
|
|
for (UINT i = 0; i < m_imp->m_centerLineArray.size(); i++) {
|
|
TThickQuadratic *q = m_imp->m_centerLineArray[i];
|
|
v[2 * i + 1] = q->getThickP1();
|
|
v[2 * i + 2] = q->getThickP2();
|
|
}
|
|
}
|
|
|
|
TThickPoint TStroke::getControlPoint(int n) const {
|
|
if (n <= 0) return m_imp->m_centerLineArray.front()->getThickP0();
|
|
|
|
if (n >= getControlPointCount())
|
|
return m_imp->m_centerLineArray.back()->getThickP2();
|
|
|
|
// calcolo l'offset del chunk risolvendo l'equazione
|
|
// 2 * chunkNumber + 1 = n
|
|
// chunkNumber = tceil((n - 1) / 2)
|
|
int chunkNumber = tceil((n - 1) * 0.5);
|
|
assert(chunkNumber <= getChunkCount());
|
|
|
|
int pointOffset = n - chunkNumber * 2;
|
|
|
|
if (chunkNumber == getChunkCount()) // e' l'ultimo punto della stroke
|
|
return getChunk(chunkNumber - 1)->getThickP2();
|
|
|
|
switch (pointOffset) {
|
|
case 0:
|
|
return getChunk(chunkNumber)->getThickP0();
|
|
case 1:
|
|
return getChunk(chunkNumber)->getThickP1();
|
|
case 2:
|
|
return getChunk(chunkNumber)->getThickP2();
|
|
}
|
|
|
|
assert("Not yet finished" && false);
|
|
return getControlPoint(0);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TThickPoint TStroke::getControlPointAtParameter(double w) const {
|
|
if (w <= 0) return m_imp->m_centerLineArray.front()->getThickP0();
|
|
|
|
if (w >= 1.0) return m_imp->m_centerLineArray.back()->getThickP2();
|
|
|
|
vector<double>::iterator it_begin =
|
|
m_imp->m_parameterValueAtControlPoint.begin(),
|
|
first,
|
|
it_end = m_imp->m_parameterValueAtControlPoint.end();
|
|
|
|
// find iterator at position greater or equal to w
|
|
first = std::lower_bound(it_begin, it_end, w);
|
|
|
|
assert(first != it_end);
|
|
|
|
// now is possible to get control point
|
|
// if( areAlmostEqual(*first, w, 0.1) )
|
|
// return getControlPoint( distance(it_begin, first) );
|
|
if (first == it_begin)
|
|
return getControlPoint(0);
|
|
else if ((*first - w) <= w - *(first - 1))
|
|
return getControlPoint(distance(it_begin, first));
|
|
else
|
|
return getControlPoint(distance(it_begin, first - 1));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TStroke::getControlPointIndexAfterParameter(double w) const {
|
|
const vector<double>::const_iterator
|
|
begin = m_imp->m_parameterValueAtControlPoint.begin(),
|
|
end = m_imp->m_parameterValueAtControlPoint.end();
|
|
|
|
vector<double>::const_iterator it = std::upper_bound(begin, end, w);
|
|
|
|
if (it == end)
|
|
return getControlPointCount();
|
|
else
|
|
return std::distance(begin, it);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::setControlPoint(int n, const TThickPoint &pos) {
|
|
assert(n >= 0);
|
|
assert(n < getControlPointCount());
|
|
if (n < 0 || n >= getControlPointCount()) return;
|
|
|
|
invalidate();
|
|
|
|
QuadStrokeChunkArray &chunkArray = m_imp->m_centerLineArray;
|
|
|
|
if (getControlPoint(n).thick <= 0 && pos.thick > 0)
|
|
m_imp->m_negativeThicknessPoints--;
|
|
else if (getControlPoint(n).thick > 0 && pos.thick <= 0)
|
|
m_imp->m_negativeThicknessPoints++;
|
|
|
|
if (n == 0) {
|
|
chunkArray[0]->setThickP0(pos);
|
|
// m_imp->computeBBox();
|
|
return;
|
|
}
|
|
|
|
int chunkNumber = tceil((n - 1) * 0.5);
|
|
assert(chunkNumber <= getChunkCount());
|
|
|
|
int pointOffset = n - chunkNumber * 2;
|
|
|
|
if (chunkNumber == getChunkCount()) // e' l'ultimo punto della stroke
|
|
{
|
|
chunkArray[chunkNumber - 1]->setThickP2(pos);
|
|
// m_imp->computeBBox();
|
|
return;
|
|
}
|
|
|
|
if (0 == pointOffset) {
|
|
chunkArray[chunkNumber]->setThickP0(pos);
|
|
|
|
if (chunkNumber >= 1) {
|
|
chunkNumber--;
|
|
chunkArray[chunkNumber]->setThickP2(pos);
|
|
}
|
|
} else if (1 == pointOffset)
|
|
chunkArray[chunkNumber]->setThickP1(pos);
|
|
else if (2 == pointOffset) {
|
|
chunkArray[chunkNumber]->setThickP2(pos);
|
|
|
|
if (chunkNumber < getChunkCount() - 1) {
|
|
chunkNumber++;
|
|
chunkArray[chunkNumber]->setThickP0(pos);
|
|
}
|
|
}
|
|
// m_imp->computeBBox();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//! Ridisegna lo stroke
|
|
void TStroke::reshape(const TThickPoint pos[], int count) {
|
|
// count deve essere dispari e maggiore o uguale a tre
|
|
assert(count >= 3);
|
|
assert(count & 1);
|
|
QuadStrokeChunkArray &chunkArray = m_imp->m_centerLineArray;
|
|
clearPointerContainer(chunkArray);
|
|
|
|
m_imp->m_negativeThicknessPoints = 0;
|
|
for (int i = 0; i < count - 1; i += 2) {
|
|
chunkArray.push_back(new TThickQuadratic(pos[i], pos[i + 1], pos[i + 2]));
|
|
if (pos[i].thick <= 0) m_imp->m_negativeThicknessPoints++;
|
|
if (pos[i + 1].thick <= 0) m_imp->m_negativeThicknessPoints++;
|
|
}
|
|
if (pos[count - 1].thick <= 0) m_imp->m_negativeThicknessPoints++;
|
|
|
|
invalidate();
|
|
// m_imp->computeBBox();
|
|
m_imp->computeParameterInControlPoint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getApproximateLength(double w0, double w1, double error) const {
|
|
m_imp->computeCacheVector();
|
|
|
|
assert((int)m_imp->m_partialLengthArray.size() == getControlPointCount());
|
|
|
|
if (w0 == w1) return 0.0;
|
|
|
|
w0 = min(max(0.0, w0), 1.0);
|
|
w1 = min(max(0.0, w1), 1.0);
|
|
|
|
if (w0 > w1) std::swap(w0, w1);
|
|
|
|
// vede se la lunghezza e' individuabile nella cache
|
|
if (0.0 == w0) {
|
|
vector<double>::iterator first;
|
|
|
|
// trova l'iteratore alla prima posizione che risulta maggiore di w
|
|
first = std::upper_bound(m_imp->m_parameterValueAtControlPoint.begin(),
|
|
m_imp->m_parameterValueAtControlPoint.end(),
|
|
w1 - TConsts::epsilon);
|
|
|
|
if (first != m_imp->m_parameterValueAtControlPoint.end() &&
|
|
*first < w1 + TConsts::epsilon) {
|
|
int offset =
|
|
distance(m_imp->m_parameterValueAtControlPoint.begin(), first);
|
|
return m_imp->m_partialLengthArray[offset];
|
|
}
|
|
}
|
|
|
|
int firstChunk, secondChunk;
|
|
double firstT, secondT;
|
|
|
|
// calcolo i chunk interessati ed i valori del parametro t
|
|
bool val1 = m_imp->retrieveChunkAndItsParamameter(w0, firstChunk, firstT);
|
|
assert(val1);
|
|
|
|
bool val2 = m_imp->retrieveChunkAndItsParamameter(w1, secondChunk, secondT);
|
|
assert(val2);
|
|
|
|
if (firstChunk == secondChunk)
|
|
return getChunk(firstChunk)->getApproximateLength(firstT, secondT, error);
|
|
|
|
double totalLength = 0;
|
|
|
|
totalLength += getChunk(firstChunk)->getApproximateLength(firstT, 1, error);
|
|
|
|
// lunghezza dei pezzi intermedi
|
|
for (int i = firstChunk + 1; i != secondChunk; i++)
|
|
totalLength += getChunk(i)->getApproximateLength(0.0, 1.0, error);
|
|
|
|
totalLength +=
|
|
getChunk(secondChunk)->getApproximateLength(0.0, secondT, error);
|
|
|
|
return totalLength;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getLength(double w0, double w1) const {
|
|
if (w0 == w1) return 0.0;
|
|
|
|
// If necessary, swap values
|
|
w0 = min(max(0.0, w0), 1.0);
|
|
w1 = min(max(0.0, w1), 1.0);
|
|
|
|
if (w0 > w1) std::swap(w0, w1);
|
|
|
|
// Retrieve s1
|
|
int chunk;
|
|
double t;
|
|
|
|
bool ok = !m_imp->retrieveChunkAndItsParamameter(w1, chunk, t);
|
|
assert(ok);
|
|
|
|
double s1 = getLength(chunk, t);
|
|
|
|
if (w0 == 0.0) return s1;
|
|
|
|
// Retrieve s0
|
|
ok = !m_imp->retrieveChunkAndItsParamameter(w0, chunk, t);
|
|
assert(ok);
|
|
|
|
return s1 - getLength(chunk, t);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getLength(int chunk, double t) const {
|
|
// Compute length caches
|
|
m_imp->computeCacheVector();
|
|
assert((int)m_imp->m_partialLengthArray.size() == getControlPointCount());
|
|
|
|
if (t == 1.0) ++chunk, t = 0.0;
|
|
|
|
double s = m_imp->m_partialLengthArray[chunk << 1];
|
|
if (t > 0.0) s += getChunk(chunk)->getLength(t);
|
|
|
|
return s;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::invalidate() {
|
|
m_imp->m_maxThickness = -1;
|
|
m_imp->m_isOutlineValid = false;
|
|
m_imp->m_isValidLength = false;
|
|
m_imp->m_flag = m_imp->m_flag | c_dirty_flag;
|
|
if (m_imp->m_prop) m_imp->m_prop->notifyStrokeChange();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*!
|
|
N.B. Questa funzione e' piu' lenta rispetto alla insertCP
|
|
perche' ricerca la posizione di s con un algoritmo di bisezione.
|
|
*/
|
|
void TStroke::insertControlPointsAtLength(double s) {
|
|
if (0 > s || s > getLength()) return;
|
|
|
|
int chunk;
|
|
double t;
|
|
|
|
// cerca il cionco ed il parametro alla lunghezza s
|
|
if (!m_imp->retrieveChunkAndItsParamameterAtLength(s, chunk, t)) {
|
|
if (isAlmostZero(t) || areAlmostEqual(t, 1)) return;
|
|
|
|
// calcolo i due "cionchi"
|
|
TThickQuadratic *tqfirst = new TThickQuadratic,
|
|
*tqsecond = new TThickQuadratic;
|
|
|
|
getChunk(chunk)->split(t, *tqfirst, *tqsecond);
|
|
|
|
double parameterInStroke;
|
|
|
|
if (0 == chunk)
|
|
parameterInStroke = m_imp->getW(2) * t;
|
|
else
|
|
parameterInStroke =
|
|
t * m_imp->getW((chunk + 1) * 2) + (1 - t) * m_imp->getW(chunk * 2);
|
|
|
|
m_imp->updateParameterValue(parameterInStroke, chunk, tqfirst, tqsecond);
|
|
|
|
// recupero la posizione nella lista delle curve
|
|
QuadStrokeChunkArray::iterator it = m_imp->m_centerLineArray.begin();
|
|
|
|
// elimino la curva vecchia
|
|
advance(it, chunk);
|
|
delete *it;
|
|
it = m_imp->m_centerLineArray.erase(it);
|
|
|
|
// ed aggiungo le nuove
|
|
it = m_imp->m_centerLineArray.insert(it, tqsecond);
|
|
it = m_imp->m_centerLineArray.insert(it, tqfirst);
|
|
}
|
|
/* FAB
|
|
#ifdef _DEBUG
|
|
{
|
|
const int
|
|
size = m_imp->m_parameterValueAtControlPoint.size();
|
|
double
|
|
prev = m_imp->m_parameterValueAtControlPoint[0];
|
|
for( int i = 1;
|
|
i < size;
|
|
++i )
|
|
{
|
|
assert( prev <= m_imp->m_parameterValueAtControlPoint[i] );
|
|
prev = m_imp->m_parameterValueAtControlPoint[i];
|
|
}
|
|
}
|
|
#endif
|
|
//*/
|
|
invalidate();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::insertControlPoints(double w) {
|
|
if (0.0 > w || w > 1.0) return;
|
|
|
|
int chunk;
|
|
double tOfDivision = -1;
|
|
|
|
if (m_imp->retrieveChunkAndItsParamameter(w, chunk, tOfDivision)) return;
|
|
|
|
if (isAlmostZero(tOfDivision) || areAlmostEqual(tOfDivision, 1)) return;
|
|
|
|
assert(0 <= chunk && chunk < getChunkCount());
|
|
assert(0 <= tOfDivision && tOfDivision <= 1.0);
|
|
|
|
// calcolo i due "cionchi"
|
|
TThickQuadratic *tqfirst = new TThickQuadratic,
|
|
*tqsecond = new TThickQuadratic;
|
|
|
|
getChunk(chunk)->split(tOfDivision, *tqfirst, *tqsecond);
|
|
|
|
m_imp->updateParameterValue(w, chunk, tqfirst, tqsecond);
|
|
|
|
// recupero la posizione nella lista delle curve
|
|
QuadStrokeChunkArray::iterator it = m_imp->m_centerLineArray.begin();
|
|
|
|
// elimino la curva vecchia
|
|
advance(it, chunk);
|
|
delete *it;
|
|
it = m_imp->m_centerLineArray.erase(it);
|
|
|
|
// ed aggiungo le nuove
|
|
it = m_imp->m_centerLineArray.insert(it, tqsecond);
|
|
m_imp->m_centerLineArray.insert(it, tqfirst);
|
|
|
|
invalidate();
|
|
m_imp->computeCacheVector();
|
|
|
|
m_imp->m_negativeThicknessPoints = 0;
|
|
for (UINT j = 0; j < m_imp->m_centerLineArray.size(); j++) {
|
|
if (m_imp->m_centerLineArray[j]->getThickP0().thick <= 0)
|
|
m_imp->m_negativeThicknessPoints++;
|
|
if (m_imp->m_centerLineArray[j]->getThickP1().thick <= 0)
|
|
m_imp->m_negativeThicknessPoints++;
|
|
}
|
|
if (!m_imp->m_centerLineArray.empty() &&
|
|
m_imp->m_centerLineArray.back()->getThickP2().thick <= 0)
|
|
m_imp->m_negativeThicknessPoints++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::reduceControlPoints(double error, vector<int> corners) {
|
|
double step, quadLen;
|
|
vector<TThickPoint> tempVect, controlPoints;
|
|
TStroke *tempStroke = 0;
|
|
double missedLen = 0;
|
|
UINT cp, nextQuad, quadI, cornI, cpSize, size;
|
|
|
|
const TThickQuadratic *quad = m_imp->m_centerLineArray.front();
|
|
|
|
size = corners.size();
|
|
assert(size > 1);
|
|
if (size < 2) {
|
|
// Have at least the first and last stroke points as corners
|
|
corners.resize(2);
|
|
corners[0] = 0;
|
|
corners[1] = m_imp->m_centerLineArray.size();
|
|
}
|
|
|
|
// For every corners interval
|
|
for (cornI = 0; cornI < size - 1; ++cornI) {
|
|
tempVect.clear();
|
|
|
|
nextQuad = corners[cornI + 1];
|
|
if (nextQuad > m_imp->m_centerLineArray.size()) {
|
|
assert(!"bad quadric index");
|
|
return;
|
|
}
|
|
if (corners[cornI] >= (int)m_imp->m_centerLineArray.size()) {
|
|
assert(!"bad quadric index");
|
|
return;
|
|
}
|
|
|
|
for (quadI = corners[cornI]; quadI < nextQuad; quadI++) {
|
|
quad = getChunk(quadI);
|
|
quadLen = quad->getLength();
|
|
|
|
missedLen += quadLen;
|
|
if (quadLen && (missedLen > 1 || quadI == 0 ||
|
|
quadI == nextQuad - 1)) // err instead of 1?
|
|
{
|
|
missedLen = 0;
|
|
step = 1.0 / quadLen; // err instead of 1.0?
|
|
|
|
// si, lo so che t non e' lineare sulla lunghezza, ma secondo me
|
|
// funziona benissimo
|
|
// cosi'. tanto devo interpolare dei punto e non e' richiesto che siano
|
|
// a distanze
|
|
// simili. e poi difficilmete il punto p1 di una quadratica e' cosi'
|
|
// asimmetrico
|
|
for (double t = 0; t < 1.0; t += step)
|
|
tempVect.push_back(quad->getThickPoint(t));
|
|
}
|
|
}
|
|
tempVect.push_back(quad->getThickP2());
|
|
tempStroke = TStroke::interpolate(tempVect, error, false);
|
|
|
|
cpSize = tempStroke->getControlPointCount();
|
|
for (cp = 0; cp < cpSize - 1; cp++) {
|
|
controlPoints.push_back(tempStroke->getControlPoint(cp));
|
|
}
|
|
delete tempStroke;
|
|
tempStroke = 0;
|
|
}
|
|
controlPoints.push_back(m_imp->m_centerLineArray.back()->getThickP2());
|
|
|
|
#ifdef _DEBUG
|
|
cpSize = controlPoints.size();
|
|
for (cp = 1; cp < cpSize; cp++)
|
|
assert(!(controlPoints[cp - 1] == controlPoints[cp]));
|
|
#endif
|
|
|
|
reshape(&(controlPoints[0]), controlPoints.size());
|
|
invalidate();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::reduceControlPoints(double error) {
|
|
vector<int> corners;
|
|
corners.push_back(0);
|
|
detectCorners(this, 10, corners);
|
|
corners.push_back(getChunkCount());
|
|
reduceControlPoints(error, corners);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getAverageThickness() const {
|
|
return m_imp->m_averageThickness;
|
|
}
|
|
|
|
double TStroke::getMaxThickness() {
|
|
if (m_imp->m_maxThickness == -1) m_imp->computeMaxThickness();
|
|
return m_imp->m_maxThickness;
|
|
}
|
|
|
|
void TStroke::setAverageThickness(double thickness) {
|
|
m_imp->m_averageThickness = thickness;
|
|
}
|
|
|
|
bool TStroke::operator==(const TStroke &s) const {
|
|
if (getChunkCount() != s.getChunkCount()) return false;
|
|
int i;
|
|
for (i = 0; i < getChunkCount(); i++) {
|
|
const TThickQuadratic *chanck = getChunk(i);
|
|
const TThickQuadratic *sChanck = s.getChunk(i);
|
|
if (chanck->getThickP0() != sChanck->getThickP0() ||
|
|
chanck->getThickP1() != sChanck->getThickP1() ||
|
|
chanck->getThickP2() != sChanck->getThickP2())
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TStroke::getChunkCount() const { return m_imp->getChunkCount(); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TStroke::getControlPointCount() const {
|
|
return m_imp->getControlPointCount();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const TThickQuadratic *TStroke::getChunk(int index) const {
|
|
return m_imp->getChunk(index);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TRectD TStroke::getBBox(double w0, double w1) const {
|
|
if (w0 > w1) std::swap(w0, w1);
|
|
|
|
if (w0 != 0.0 || w1 != 1.0) return m_imp->computeSubBBox(w0, w1);
|
|
|
|
if (m_imp->m_flag & c_dirty_flag) ((TStroke *)this)->computeBBox();
|
|
|
|
return m_imp->m_bBox;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::computeBBox() {
|
|
m_imp->m_bBox = TOutlineUtil::computeBBox(*this);
|
|
m_imp->m_flag &= ~c_dirty_flag;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TRectD TStroke::getCenterlineBBox() const {
|
|
return m_imp->computeCenterlineBBox();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::disableComputeOfCaches() {
|
|
m_imp->m_areDisabledComputeOfCaches = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::enableComputeOfCaches() {
|
|
m_imp->m_areDisabledComputeOfCaches = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// DEL double TStroke::getDistance2(const TPointD &p,
|
|
// DEL double maxDistance2,
|
|
// DEL UINT &chunkIndex,
|
|
// DEL double &currT)
|
|
// DEL {
|
|
// DEL TRectD rect = getBBox();
|
|
// DEL
|
|
// DEL if (!rect.contains(p))
|
|
// DEL {
|
|
// DEL double dist21 = tdistance2(p, rect.getP00());
|
|
// DEL double dist22 = tdistance2(p, rect.getP01());
|
|
// DEL double dist23 = tdistance2(p, rect.getP10());
|
|
// DEL double dist24 = tdistance2(p, rect.getP11());
|
|
// DEL
|
|
// DEL if (std::min(dist21, dist22, dist23, dist24)>=maxDistance2)
|
|
// DEL return maxDistance2;
|
|
// DEL }
|
|
// DEL
|
|
// DEL double distance2, curMaxDistance2=maxDistance2;
|
|
// DEL
|
|
// DEL for (UINT i=0; i < m_imp->m_centerLineArray.size(); i++)
|
|
// DEL {
|
|
// DEL distance2 = getTQDistance2(*(m_imp->m_centerLineArray)[i], p,
|
|
// maxDistance2, currT);
|
|
// DEL if (distance2 < curMaxDistance2)
|
|
// DEL {
|
|
// DEL curMaxDistance2 = distance2;
|
|
// DEL chunkIndex = i;
|
|
// DEL }
|
|
// DEL }
|
|
// DEL
|
|
// DEL return curMaxDistance2;
|
|
// DEL }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TThickPoint TStroke::getThickPointAtLength(double s) const {
|
|
assert(!m_imp->m_centerLineArray.empty());
|
|
|
|
if (s <= 0) return getControlPoint(0);
|
|
|
|
if (s >= getLength()) return getControlPoint(getControlPointCount() - 1);
|
|
|
|
int chunk;
|
|
double tOfDivision;
|
|
|
|
bool error =
|
|
m_imp->retrieveChunkAndItsParamameterAtLength(s, chunk, tOfDivision);
|
|
|
|
if (error)
|
|
error =
|
|
m_imp->retrieveChunkAndItsParamameterAtLength(s, chunk, tOfDivision);
|
|
|
|
assert(!error);
|
|
|
|
if (error) return getControlPoint(0);
|
|
|
|
return getChunk(chunk)->getThickPoint(tOfDivision);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TThickPoint TStroke::getThickPoint(double w) const {
|
|
assert(!m_imp->m_centerLineArray.empty());
|
|
|
|
if (w < 0) return getControlPoint(0);
|
|
|
|
if (w > 1.0) return getControlPoint(getControlPointCount() - 1);
|
|
|
|
int chunk = 0;
|
|
double t = 0;
|
|
|
|
bool error = m_imp->retrieveChunkAndItsParamameter(w, chunk, t);
|
|
|
|
assert(!error);
|
|
|
|
if (error) return getControlPoint(0);
|
|
|
|
return getChunk(chunk)->getThickPoint(t);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getParameterAtLength(double s) const {
|
|
if (s <= 0)
|
|
return 0;
|
|
else if (s >= getLength())
|
|
return 1;
|
|
|
|
int chunk;
|
|
double t;
|
|
|
|
if (!m_imp->retrieveChunkAndItsParamameterAtLength(s, chunk, t)) {
|
|
DoublePair p = m_imp->retrieveParametersFromChunk(chunk);
|
|
|
|
return proportion(p.second, t, 1.0, p.first);
|
|
} else if (chunk < (int)getChunkCount() && t == -1)
|
|
return getParameterAtControlPoint(2 * chunk);
|
|
|
|
return 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getParameterAtControlPoint(int n) const {
|
|
double out = -1;
|
|
|
|
if (0 <= n && n < getControlPointCount()) out = m_imp->getW(n);
|
|
/* FAB
|
|
assert( 0.0 <= out &&
|
|
out <= 1.0 );
|
|
*/
|
|
if (0.0 > out) return 0.0;
|
|
if (out > 1.0) return 1.0;
|
|
return out;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getW(int chunkIndex, double t) const {
|
|
DoublePair parRange = m_imp->retrieveParametersFromChunk(chunkIndex);
|
|
|
|
double w = proportion(parRange.second, t, 1.0, parRange.first);
|
|
|
|
assert(0 <= w && w <= 1.0);
|
|
|
|
return w;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getW(const TPointD &p) const {
|
|
int chunkIndex;
|
|
|
|
double tOfchunk, distance2 = (numeric_limits<double>::max)();
|
|
|
|
// cerca il chunk piu' vicino senza testare la BBox
|
|
getNearestChunk(p, tOfchunk, chunkIndex, distance2, false);
|
|
|
|
assert(0 <= chunkIndex && chunkIndex <= getChunkCount());
|
|
|
|
DoublePair parRange = m_imp->retrieveParametersFromChunk(chunkIndex);
|
|
|
|
double t = proportion(parRange.second, tOfchunk, 1.0, parRange.first);
|
|
|
|
assert(0 <= t && t <= 1.0);
|
|
|
|
return t;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::getSpeedTwoValues(double w, TPointD &speed0,
|
|
TPointD &speed1) const {
|
|
bool ret = false;
|
|
|
|
assert(!m_imp->m_centerLineArray.empty());
|
|
|
|
if (w < 0) {
|
|
speed0 = m_imp->m_centerLineArray.front()->getSpeed(0.0);
|
|
return ret;
|
|
}
|
|
|
|
if (w > 1.0) {
|
|
speed0 = m_imp->m_centerLineArray.back()->getSpeed(1.0);
|
|
return ret;
|
|
}
|
|
|
|
int chunk;
|
|
double t;
|
|
|
|
bool error = m_imp->retrieveChunkAndItsParamameter(w, chunk, t);
|
|
|
|
assert(!error);
|
|
|
|
if (error) {
|
|
speed0 = m_imp->m_centerLineArray.front()->getSpeed(0.0);
|
|
speed1 = -speed0;
|
|
return ret;
|
|
}
|
|
|
|
speed0 = getChunk(chunk)->getSpeed(t);
|
|
speed1 = -speed0;
|
|
|
|
if (areAlmostEqual(t, 0.0, 1e-9) && chunk > 0 &&
|
|
(speed1 = -getChunk(chunk - 1)->getSpeed(1.0)) != -speed0)
|
|
ret = true;
|
|
else if (areAlmostEqual(t, 1.0, 1e-9) && chunk < getChunkCount() - 1 &&
|
|
(speed1 = -getChunk(chunk + 1)->getSpeed(0.0)) != -speed0) {
|
|
TPointD aux = -speed0;
|
|
speed0 = -speed1;
|
|
speed1 = aux;
|
|
ret = true;
|
|
}
|
|
|
|
if (speed0 == TPointD()) // la quadratica e' degenere!!!
|
|
{
|
|
while (speed0 == TPointD()) {
|
|
speed0 = getChunk(chunk--)->getSpeed(1.0);
|
|
if (chunk <= 0) break;
|
|
}
|
|
chunk = 0;
|
|
while (speed0 == TPointD()) {
|
|
speed0 = getChunk(chunk++)->getSpeed(0.0);
|
|
if (chunk >= getChunkCount() - 1) break;
|
|
}
|
|
|
|
if (speed0 == TPointD()) {
|
|
if (getChunkCount() == 1) {
|
|
const TThickQuadratic *q = getChunk(0);
|
|
|
|
if (q->getP0() == q->getP1() && q->getP1() != q->getP2())
|
|
speed0 = TSegment(q->getP1(), q->getP2()).getSpeed(t);
|
|
else if (q->getP1() == q->getP2() && q->getP0() != q->getP1())
|
|
speed0 = TSegment(q->getP0(), q->getP1()).getSpeed(t);
|
|
else
|
|
assert(speed0 != TPointD());
|
|
} else
|
|
assert(speed0 != TPointD());
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
TPointD TStroke::getSpeed(double w, bool outSpeed) const {
|
|
assert(!m_imp->m_centerLineArray.empty());
|
|
|
|
if (w < 0) return m_imp->m_centerLineArray.front()->getSpeed(0.0);
|
|
|
|
if (w > 1.0) return m_imp->m_centerLineArray.back()->getSpeed(1.0);
|
|
|
|
int chunk;
|
|
double t;
|
|
|
|
bool error = m_imp->retrieveChunkAndItsParamameter(w, chunk, t);
|
|
if (t == 1 && outSpeed && chunk < getChunkCount() - 1) {
|
|
chunk++;
|
|
t = 0;
|
|
}
|
|
assert(!error);
|
|
|
|
if (error) return m_imp->m_centerLineArray.front()->getSpeed(0.0);
|
|
|
|
TPointD speed = getChunk(chunk)->getSpeed(t);
|
|
|
|
if (speed == TPointD()) // la quadratica e' degenere!!!
|
|
{
|
|
while (speed == TPointD()) {
|
|
speed = getChunk(chunk--)->getSpeed(1.0);
|
|
if (chunk <= 0) break;
|
|
}
|
|
chunk = 0;
|
|
while (speed == TPointD()) {
|
|
speed = getChunk(chunk++)->getSpeed(0.0);
|
|
if (chunk >= getChunkCount() - 1) break;
|
|
}
|
|
if (speed == TPointD()) {
|
|
if (getChunkCount() == 1) {
|
|
const TThickQuadratic *q = getChunk(0);
|
|
|
|
if (q->getP0() == q->getP1() && q->getP1() != q->getP2())
|
|
return TSegment(q->getP1(), q->getP2()).getSpeed(t);
|
|
else if (q->getP1() == q->getP2() && q->getP0() != q->getP1())
|
|
return TSegment(q->getP0(), q->getP1()).getSpeed(t);
|
|
else
|
|
assert(speed != TPointD());
|
|
} else
|
|
assert(speed != TPointD());
|
|
}
|
|
}
|
|
return speed;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TPointD TStroke::getSpeedAtLength(double s) const {
|
|
double t = getParameterAtLength(s);
|
|
return getSpeed(t);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TStroke::getLengthAtControlPoint(int n) const {
|
|
m_imp->computeCacheVector();
|
|
|
|
if (n >= getControlPointCount()) return m_imp->m_partialLengthArray.back();
|
|
|
|
if (n <= 0) return m_imp->m_partialLengthArray.front();
|
|
|
|
return m_imp->m_partialLengthArray[n];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::split(double w, TStroke &f, TStroke &s) const {
|
|
int chunk;
|
|
double t;
|
|
f.m_imp->m_maxThickness = -1;
|
|
s.m_imp->m_maxThickness = -1;
|
|
if (!m_imp->retrieveChunkAndItsParamameter(w, chunk, t)) {
|
|
assert(0 <= chunk && chunk < getChunkCount());
|
|
assert(0 <= w && w <= 1.0);
|
|
assert(0 <= t && t <= 1.0);
|
|
|
|
QuadStrokeChunkArray &chunkArray = m_imp->m_centerLineArray;
|
|
|
|
// build two temporary quadratic
|
|
TThickQuadratic *tq1 = new TThickQuadratic, *tq2 = new TThickQuadratic;
|
|
// make split
|
|
chunkArray[chunk]->split(t, *tq1, *tq2);
|
|
|
|
// a temporary vector of ThickQuadratic
|
|
QuadStrokeChunkArray vTQ;
|
|
|
|
// copy all chunk of stroke in a vTQ
|
|
int i;
|
|
for (i = 0; i < chunk; ++i) vTQ.push_back(chunkArray[i]);
|
|
|
|
// not insert null length chunk (unless vTQ is empty....)
|
|
if (tq1->getLength() != 0.0 || w == 0.0 || vTQ.empty()) vTQ.push_back(tq1);
|
|
|
|
// build a temp and swap
|
|
TStroke *ts1 = TStroke::create(vTQ);
|
|
if (!ts1) ts1 = new TStroke;
|
|
ts1->swapGeometry(f);
|
|
|
|
// clear vector (chunks are now under TStroke control)
|
|
vTQ.clear();
|
|
|
|
// idem...
|
|
if (tq2->getLength() != 0.0 || w == 1.0 || getChunkCount() == 0)
|
|
vTQ.push_back(tq2);
|
|
|
|
for (i = chunk + 1; i < getChunkCount(); ++i) vTQ.push_back(chunkArray[i]);
|
|
|
|
TStroke *ts2 = TStroke::create(vTQ);
|
|
if (!ts2) ts2 = new TStroke;
|
|
ts2->swapGeometry(s);
|
|
|
|
// Copy style infos
|
|
f.setStyle(getStyle());
|
|
s.setStyle(getStyle());
|
|
f.outlineOptions() = s.outlineOptions() = outlineOptions();
|
|
|
|
delete ts2;
|
|
delete ts1;
|
|
// delete temporary quadratic
|
|
delete tq1;
|
|
delete tq2;
|
|
if (f.getControlPointCount() == 3 &&
|
|
f.getControlPoint(0) !=
|
|
f.getControlPoint(2)) // gli stroke con solo 1 chunk vengono fatti
|
|
// dal tape tool...e devono venir
|
|
// riconosciuti come speciali di autoclose
|
|
// proprio dal fatto che hanno 1 solo chunk.
|
|
f.insertControlPoints(0.5);
|
|
if (s.getControlPointCount() == 3 &&
|
|
s.getControlPoint(0) !=
|
|
s.getControlPoint(2)) // gli stroke con solo 1 chunk vengono fatti
|
|
// dal tape tool...e devono venir
|
|
// riconosciuti come speciali di autoclose
|
|
// proprio dal fatto che hanno 1 solo chunk.
|
|
s.insertControlPoints(0.5);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::print(ostream &os) const {
|
|
// m_imp->print(os);
|
|
const TThickQuadratic *q;
|
|
|
|
os << "Punti di controllo\n";
|
|
for (int i = 0; i < getChunkCount(); ++i) {
|
|
os << "quad #" << i << ":" << endl;
|
|
q = getChunk(i);
|
|
|
|
os << " P0:" << q->getThickP0().x << ", " << q->getThickP0().y << ", "
|
|
<< q->getThickP0().thick << endl;
|
|
os << " P1:" << q->getThickP1().x << ", " << q->getThickP1().y << ", "
|
|
<< q->getThickP1().thick << endl;
|
|
assert(i == getChunkCount() - 1 ||
|
|
(getChunk(i)->getThickP2() == getChunk(i + 1)->getThickP0()));
|
|
}
|
|
|
|
q = getChunk(getChunkCount() - 1);
|
|
|
|
os << " P2:" << q->getThickP2().x << ", " << q->getThickP2().y << ", "
|
|
<< q->getThickP2().thick << endl;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::transform(const TAffine &aff, bool doChangeThickness) {
|
|
for (UINT i = 0; i < m_imp->m_centerLineArray.size(); ++i) {
|
|
TThickQuadratic &ref = *m_imp->m_centerLineArray[i];
|
|
ref = transformQuad(aff, ref, doChangeThickness);
|
|
|
|
if (doChangeThickness) {
|
|
double det = aff.det();
|
|
if (det == 0) m_imp->m_negativeThicknessPoints = getControlPointCount();
|
|
if (m_imp->m_maxThickness != -1) m_imp->m_maxThickness *= sqrt(fabs(det));
|
|
// else if(det<0)
|
|
// m_imp->m_negativeThicknessPoints=getControlPointCount()-m_imp->m_negativeThicknessPoints;
|
|
}
|
|
}
|
|
|
|
invalidate();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*
|
|
void TStroke::draw(const TVectorRenderData &rd) const
|
|
{
|
|
if(! m_imp->m_styleId)
|
|
return;
|
|
|
|
TColorStyle * style = rd.m_palette->getStyle(m_imp->m_styleId);
|
|
|
|
if( !style->isStrokeStyle() || style->isEnabled() == false )
|
|
return;
|
|
|
|
|
|
|
|
if( !m_imp->m_prop || style != m_imp->m_prop->getColorStyle() )
|
|
{
|
|
delete m_imp->m_prop;
|
|
m_imp->m_prop = style->makeStrokeProp(this);
|
|
}
|
|
|
|
m_imp->m_prop->draw(rd);
|
|
}
|
|
|
|
*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStrokeProp *TStroke::getProp() const {
|
|
#if !defined(DISEGNO_OUTLINE)
|
|
if (!m_imp->m_styleId) return 0;
|
|
#endif
|
|
|
|
/*
|
|
TColorStyle * style = palette->getStyle(m_imp->m_styleId);
|
|
if( !style->isStrokeStyle() || style->isEnabled() == false )
|
|
return 0;
|
|
|
|
if( !m_imp->m_prop || style != m_imp->m_prop->getColorStyle() )
|
|
{
|
|
delete m_imp->m_prop;
|
|
m_imp->m_prop = style->makeStrokeProp(this);
|
|
}
|
|
*/
|
|
return m_imp->m_prop;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::setProp(TStrokeProp *prop) {
|
|
assert(prop);
|
|
delete m_imp->m_prop;
|
|
m_imp->m_prop = prop;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TStroke::getStyle() const { return m_imp->m_styleId; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::setStyle(int styleId) {
|
|
m_imp->m_styleId = styleId;
|
|
|
|
/*
|
|
if (!colorStyle || (colorStyle && colorStyle->isStrokeStyle()) )
|
|
{
|
|
m_imp->m_colorStyle = colorStyle;
|
|
delete m_imp->m_prop;
|
|
m_imp->m_prop = 0;
|
|
}
|
|
*/
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke &TStroke::changeDirection() {
|
|
UINT chunkCount = getChunkCount();
|
|
UINT to = tfloor(chunkCount * 0.5);
|
|
UINT i;
|
|
|
|
if (chunkCount & 1) changeTQDirection(m_imp->m_centerLineArray[to]);
|
|
|
|
--chunkCount;
|
|
|
|
for (i = 0; i < to; ++i) {
|
|
changeTQDirection(m_imp->m_centerLineArray[i]);
|
|
changeTQDirection(m_imp->m_centerLineArray[chunkCount - i]);
|
|
TThickQuadratic *q1 = m_imp->m_centerLineArray[i];
|
|
m_imp->m_centerLineArray[i] = m_imp->m_centerLineArray[chunkCount - i];
|
|
m_imp->m_centerLineArray[chunkCount - i] = q1;
|
|
}
|
|
invalidate();
|
|
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::setFlag(TStrokeFlag flag, bool status) {
|
|
if (status)
|
|
m_imp->m_flag |= flag;
|
|
else
|
|
m_imp->m_flag &= ~flag;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::getFlag(TStrokeFlag flag) const {
|
|
return (m_imp->m_flag & flag) != 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::swap(TStroke &ref) {
|
|
std::swap(m_imp, ref.m_imp);
|
|
|
|
// Stroke props need to update their stroke owners
|
|
if (m_imp->m_prop) m_imp->m_prop->setStroke(this);
|
|
if (ref.m_imp->m_prop) ref.m_imp->m_prop->setStroke(&ref);
|
|
|
|
// The id is retained. This is coherent as the stroke id is supposedly
|
|
// not an exchangeable info.
|
|
std::swap(m_imp->m_id, ref.m_imp->m_id);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::swapGeometry(TStroke &ref) { m_imp->swapGeometry(*ref.m_imp); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TStroke::getId() const { return m_imp->m_id; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::setId(int id) { m_imp->m_id = id; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// magari poi la sposto in un altro file
|
|
TThickPoint TStroke::getCentroid() const {
|
|
double totalLen = getLength();
|
|
|
|
if (totalLen == 0) return getControlPoint(0);
|
|
|
|
double step = totalLen * 0.1;
|
|
double len = 0;
|
|
if (step > 10.0) step = 10.0;
|
|
int count = 0;
|
|
TThickPoint point;
|
|
for (; len <= totalLen; len += step) {
|
|
count++;
|
|
point += getThickPointAtLength(len);
|
|
}
|
|
return point * (1.0 / (double)count);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TStroke::setSelfLoop(bool loop) {
|
|
if (loop) {
|
|
// assert that a self loop is a stroke where first and last control points
|
|
// are the same
|
|
const int cpCount = this->getControlPointCount();
|
|
|
|
TThickPoint p, p0 = this->getControlPoint(0),
|
|
pn = this->getControlPoint(cpCount - 1);
|
|
|
|
p = (p0 + pn) * 0.5;
|
|
|
|
this->setControlPoint(0, p);
|
|
this->setControlPoint(cpCount - 1, p);
|
|
}
|
|
m_imp->m_selfLoop = loop;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::isSelfLoop() const { return m_imp->m_selfLoop; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TStroke::isCenterLine() const {
|
|
assert(m_imp->m_negativeThicknessPoints <= getControlPointCount());
|
|
|
|
return m_imp->m_negativeThicknessPoints == getControlPointCount();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::OutlineOptions &TStroke::outlineOptions() {
|
|
return m_imp->m_outlineOptions;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const TStroke::OutlineOptions &TStroke::outlineOptions() const {
|
|
return m_imp->m_outlineOptions;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// End Of File
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke *joinStrokes(const TStroke *s0, const TStroke *s1) {
|
|
TStroke *newStroke;
|
|
|
|
if (s0 == s1) {
|
|
newStroke = new TStroke(*s0);
|
|
newStroke->setSelfLoop();
|
|
return newStroke;
|
|
}
|
|
int i;
|
|
vector<TThickPoint> v;
|
|
for (i = 0; i < s0->getControlPointCount(); i++)
|
|
v.push_back(s0->getControlPoint(i));
|
|
if (areAlmostEqual(v.back(), s1->getControlPoint(0), 1e-3))
|
|
for (i = 1; i < s1->getControlPointCount(); i++)
|
|
v.push_back(s1->getControlPoint(i));
|
|
else if (areAlmostEqual(v.back(),
|
|
s1->getControlPoint(s1->getControlPointCount() - 1),
|
|
1e-3))
|
|
for (i = s1->getControlPointCount() - 2; i >= 0; i--)
|
|
v.push_back(s1->getControlPoint(i));
|
|
else
|
|
assert(false);
|
|
|
|
newStroke = new TStroke(v);
|
|
newStroke->setStyle(s0->getStyle());
|
|
newStroke->outlineOptions() = s0->outlineOptions();
|
|
|
|
return newStroke;
|
|
|
|
/*
|
|
int cpCount1 = stroke1->getControlPointCount();
|
|
int cpCount2 = stroke2->getControlPointCount();
|
|
|
|
int qCount1 = stroke1->getChunkCount();
|
|
const TThickQuadratic* q1=stroke1->getChunk(qCount1-1 );
|
|
const TThickQuadratic* q2=stroke2->getChunk(0);
|
|
|
|
TThickPoint extreme1 = q1->getThickP2() ;
|
|
TThickPoint extreme2 = q2->getThickP0();
|
|
|
|
vector<TThickPoint> points;
|
|
points.reserve(cpCount1+cpCount2-1);
|
|
|
|
int i = 0;
|
|
for(; i!=cpCount1-1; i++)
|
|
points.push_back( stroke1->getControlPoint(i));
|
|
|
|
if(extreme1==extreme2)
|
|
{
|
|
points.push_back(extreme1);
|
|
}
|
|
else
|
|
{
|
|
double len1=q1->getLength();
|
|
assert(len1>=0);
|
|
if(len1<=0)
|
|
len1=0;
|
|
double w1= exp(-len1*0.01);
|
|
|
|
double len2=q2->getLength();
|
|
assert(len2>=0);
|
|
if(len2<=0)
|
|
len2=0;
|
|
double w2= exp(-len2*0.01);
|
|
|
|
|
|
TThickPoint m1=q1->getThickP1();
|
|
TThickPoint m2=q2->getThickP1();
|
|
|
|
TThickPoint p1= extreme1*(1-w1)+m1*w1;
|
|
TThickPoint p2= extreme2*(1-w2)+m2*w2;
|
|
|
|
TThickPoint middleP= (p1 + p2)*0.5;
|
|
|
|
double angle=fabs(cross(normalize(m1-middleP),normalize(m2-middleP)));
|
|
if( angle< 0.05)
|
|
middleP=(m1+m2)*0.5;
|
|
|
|
points.push_back(middleP);
|
|
}
|
|
|
|
for(i = 1; i!=cpCount2; i++)
|
|
points.push_back( stroke2->getControlPoint(i));
|
|
|
|
newStroke = new TStroke(points);
|
|
newStroke->setStyle(stroke1->getStyle());
|
|
return newStroke;
|
|
*/
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
namespace {
|
|
|
|
int local_intersect(const TStroke &stroke, const TSegment &segment,
|
|
std::vector<DoublePair> &intersections,
|
|
bool strokeIsFirst) {
|
|
const TThickQuadratic *chunk;
|
|
for (int i = 0; i < stroke.getChunkCount(); i++) {
|
|
std::vector<DoublePair> localIntersections;
|
|
chunk = stroke.getChunk(i);
|
|
|
|
if (intersect(*chunk, segment, localIntersections)) {
|
|
for (UINT j = 0; j < localIntersections.size(); j++) {
|
|
double strokePar = localIntersections[j].first;
|
|
|
|
strokePar = stroke.getW(chunk->getPoint(strokePar));
|
|
|
|
// check for multiple solution
|
|
DoublePair sol(
|
|
strokeIsFirst ? strokePar : localIntersections[j].second,
|
|
strokeIsFirst ? localIntersections[j].second : strokePar);
|
|
|
|
std::vector<DoublePair>::iterator it_end = intersections.end();
|
|
|
|
if (it_end == std::find(intersections.begin(), it_end, sol))
|
|
intersections.push_back(sol);
|
|
}
|
|
}
|
|
}
|
|
return intersections.size();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool almostOverlaps(const TRectD &r0, const TRectD &r1) {
|
|
if (r0.overlaps(r1)) return true;
|
|
|
|
if ((r0.x1 < r1.x0) && (areAlmostEqual(r0.x1, r1.x0, 1e-5)))
|
|
return true;
|
|
else if ((r1.x1 < r0.x0) && (areAlmostEqual(r1.x1, r0.x0, 1e-5)))
|
|
return true;
|
|
if ((r0.y1 < r1.y0) && (areAlmostEqual(r0.y1, r1.y0, 1e-5)))
|
|
return true;
|
|
else if ((r1.y1 < r0.y0) && (areAlmostEqual(r1.y1, r0.y0, 1e-5)))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool greaterThanOneAndLesserThanZero(double val) {
|
|
if (val > 1.0 || val < 0.0) return true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
int intersect(const TStroke *s1, const TStroke *s2,
|
|
std::vector<DoublePair> &intersections, bool checkBBox) {
|
|
UINT k = 0;
|
|
|
|
intersections.clear();
|
|
|
|
if (checkBBox && !s1->getBBox().overlaps(s2->getBBox())) return 0;
|
|
|
|
for (int i = 0; i < s1->getChunkCount(); i++) {
|
|
const TQuadratic *q1 = s1->getChunk(i);
|
|
if (q1->getP0() == q1->getP2() && q1->getP1() == q1->getP2()) continue;
|
|
int j = 0;
|
|
if (s1 ==
|
|
s2) // this 'if': if after i-th stroke there are degenere strokes,
|
|
// I do not consider them; so, instead of starting from j = i+2
|
|
// I start from j = i+2+numDegeneres
|
|
{
|
|
j = i + 2;
|
|
|
|
while (j <= s2->getChunkCount()) {
|
|
const TQuadratic *qAux = s2->getChunk(j - 1);
|
|
if (qAux->getP0() != qAux->getP2() || qAux->getP1() != qAux->getP2())
|
|
break;
|
|
j++;
|
|
}
|
|
}
|
|
|
|
for (; j < s2->getChunkCount(); j++) {
|
|
const TQuadratic *q2 = s2->getChunk(j);
|
|
if (q2->getP0() == q2->getP2() && q2->getP1() == q2->getP2()) continue;
|
|
|
|
if (!almostOverlaps(q1->getBBox(), q2->getBBox())) continue;
|
|
#ifdef CHECK_DEGLI_ESTREMI
|
|
vector<DoublePair> quadIntersections1;
|
|
if (i == 0 || i == s1->getChunkCount() - 1) && (j==0 || j==s2->getChunkCount()-1))
|
|
{
|
|
TPointD pp1 = (i == 0 ? q1->getP0() : q1->getP2());
|
|
TPointD pp2 = (j == 0 ? q2->getP0() : q2->getP2());
|
|
if (areAlmostEqual(pp1, pp2)) {
|
|
intersections.push_back(
|
|
DoublePair(i == 0 ? 0.0 : 1.0, j == 0 ? 0.0 : 1.0));
|
|
k++;
|
|
continue;
|
|
}
|
|
if (s1->getChunkCount() == 1 && s2->getChunkCount() == 1) {
|
|
TPointD pp1 = q1->getP2();
|
|
TPointD pp2 = q2->getP2();
|
|
if (areAlmostEqual(pp1, pp2)) {
|
|
intersections.push_back(DoublePair(1.0, 1.0));
|
|
k++;
|
|
continue;
|
|
}
|
|
}
|
|
if (s1->getChunkCount() == 1) {
|
|
TPointD pp1 = q1->getP2();
|
|
TPointD pp2 = (j == 0 ? q2->getP0() : q2->getP2());
|
|
if (areAlmostEqual(pp1, pp2)) {
|
|
intersections.push_back(DoublePair(1.0, j == 0 ? 0.0 : 1.0));
|
|
k++;
|
|
continue;
|
|
}
|
|
}
|
|
if (s2->getChunkCount() == 1) {
|
|
TPointD pp1 = (i == 0 ? q1->getP0() : q1->getP2());
|
|
TPointD pp2 = q2->getP2();
|
|
if (areAlmostEqual(pp1, pp2)) {
|
|
intersections.push_back(DoublePair(i == 0 ? 0.0 : 1.0, 1.0));
|
|
k++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// if (j<s2->getChunkCount()-1)
|
|
// {
|
|
// const TQuadratic *q3= s2->getChunk(j==0?0:j+1);
|
|
// evito di intersecare se le quadratiche sono uguali
|
|
if (*q1 == *q2 ||
|
|
(q1->getP0() == q2->getP2() && q1->getP1() == q2->getP1() &&
|
|
q1->getP2() == q2->getP0())) {
|
|
// j+=((j==0)?1:2);
|
|
continue;
|
|
}
|
|
// }
|
|
|
|
vector<DoublePair> quadIntersections;
|
|
if (intersect(*q1, *q2, quadIntersections))
|
|
for (int h = 0; h < (int)quadIntersections.size(); h++) {
|
|
DoublePair res(getWfromChunkAndT(s1, i, quadIntersections[h].first),
|
|
getWfromChunkAndT(s2, j, quadIntersections[h].second));
|
|
|
|
if (areAlmostEqual(quadIntersections[h].first, 0) ||
|
|
areAlmostEqual(quadIntersections[h].first, 1) ||
|
|
areAlmostEqual(quadIntersections[h].second, 0) ||
|
|
areAlmostEqual(quadIntersections[h].second, 1)) {
|
|
int q = 0;
|
|
for (q = 0; q < (int)intersections.size(); q++)
|
|
if (areAlmostEqual(intersections[q].first, res.first, 1e-8) &&
|
|
areAlmostEqual(intersections[q].second, res.second, 1e-8))
|
|
break;
|
|
if (q < (int)intersections.size()) continue;
|
|
}
|
|
intersections.push_back(res);
|
|
// if (k==0 || intersections[k].first!=intersections[k-1].first ||
|
|
// intersections[k].second!=intersections[k-1].second)
|
|
k++;
|
|
}
|
|
}
|
|
}
|
|
if (s1 == s2 &&
|
|
(s1->isSelfLoop() || s1->getPoint(0.0) == s1->getPoint(1.0))) {
|
|
int i;
|
|
for (i = 0; i < (int)intersections.size(); i++) {
|
|
assert(!(areAlmostEqual(intersections[i].first, 1.0, 1e-1) &&
|
|
areAlmostEqual(intersections[i].second, 0.0, 1e-1)));
|
|
if (areAlmostEqual(intersections[i].first, 0.0, 1e-1) &&
|
|
areAlmostEqual(intersections[i].second, 1.0, 1e-1))
|
|
break;
|
|
}
|
|
if (i == (int)intersections.size()) {
|
|
intersections.push_back(DoublePair(0.0, 1.0));
|
|
k++;
|
|
}
|
|
}
|
|
|
|
return k;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int intersect(const TSegment &segment, const TStroke &stroke,
|
|
std::vector<DoublePair> &intersections) {
|
|
return local_intersect(stroke, segment, intersections, false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int intersect(const TStroke &stroke, const TSegment &segment,
|
|
std::vector<DoublePair> &intersections) {
|
|
return local_intersect(stroke, segment, intersections, true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int intersect(const TStroke &stroke, const TPointD ¢er, double radius,
|
|
vector<double> &intersections) {
|
|
// 2 2 2
|
|
// riconduco x + y = r con x(t) y(t) alla forma
|
|
// 2 2 2 2 2
|
|
// ( a_x t + b_x t + c_x ) + ( a_y t + b_y t + c_y ) = r
|
|
|
|
// 2
|
|
// a x + b x + c
|
|
|
|
const int a = 2;
|
|
const int b = 1;
|
|
const int c = 0;
|
|
|
|
vector<TPointD> bez(3);
|
|
vector<TPointD> pol(3);
|
|
vector<double> coeff(5);
|
|
|
|
for (int chunk = 0; chunk < stroke.getChunkCount(); ++chunk) {
|
|
const TThickQuadratic *tq = stroke.getChunk(chunk);
|
|
|
|
bez[0] = tq->getP0();
|
|
bez[1] = tq->getP1();
|
|
bez[2] = tq->getP2();
|
|
|
|
bezier2poly(bez, pol);
|
|
|
|
pol[c] -= center;
|
|
|
|
coeff[4] = sq(pol[a].x) + sq(pol[a].y);
|
|
coeff[3] = 2.0 * (pol[a].x * pol[b].x + pol[a].y * pol[b].y);
|
|
coeff[2] = 2.0 * (pol[a].x * pol[c].x + pol[a].y * pol[c].y) +
|
|
sq(pol[b].x) + sq(pol[b].y);
|
|
coeff[1] = 2.0 * (pol[b].x * pol[c].x + pol[b].y * pol[c].y);
|
|
coeff[0] = sq(pol[c].x) + sq(pol[c].y) - sq(radius);
|
|
|
|
vector<double> sol;
|
|
rootFinding(coeff, sol);
|
|
|
|
sol.erase(
|
|
remove_if(sol.begin(), sol.end(), greaterThanOneAndLesserThanZero),
|
|
sol.end());
|
|
|
|
for (UINT j = 0; j < sol.size(); ++j)
|
|
intersections.push_back(getWfromChunkAndT(&stroke, chunk, sol[j]));
|
|
}
|
|
|
|
#if defined(DEBUG) || defined(_DEBUG)
|
|
/*
|
|
cout<<"interesections:";
|
|
copy( intersections.begin(), intersections.end(), ostream_iterator<double>(
|
|
cout, " " ) );
|
|
cout<<endl;
|
|
*/
|
|
// assert to test intersections are not decrescent
|
|
vector<double> test;
|
|
|
|
adjacent_difference(intersections.begin(), intersections.end(),
|
|
back_inserter(test));
|
|
|
|
while (!test.empty()) {
|
|
assert(test.back() >= 0);
|
|
test.pop_back();
|
|
}
|
|
|
|
#endif
|
|
|
|
return intersections.size();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void splitStroke(const TStroke &tq, const vector<double> &pars,
|
|
std::vector<TStroke *> &v) {
|
|
if (pars.empty()) return;
|
|
|
|
UINT i, vSize = pars.size();
|
|
|
|
vector<double> length(vSize);
|
|
|
|
// primo passo estraggo i parametri di lunghezza
|
|
for (i = 0; i < vSize; ++i) length[i] = tq.getLength(pars[i]);
|
|
|
|
std::adjacent_difference(length.begin(), length.end(), length.begin());
|
|
|
|
TStroke *q1, q2, q3;
|
|
|
|
q1 = new TStroke();
|
|
tq.split(pars[0], *q1, q2);
|
|
|
|
assert(areAlmostEqual(q1->getLength(), length[0], 1e-4));
|
|
v.push_back(q1);
|
|
|
|
for (i = 1; i < vSize; ++i) {
|
|
q1 = new TStroke();
|
|
double par = q2.getParameterAtLength(length[i]);
|
|
assert(0 <= par && par <= 1.0);
|
|
q2.split(par, *q1, q3);
|
|
|
|
assert(areAlmostEqual(q1->getLength(), length[i], 1e-4));
|
|
v.push_back(q1);
|
|
q2 = q3;
|
|
}
|
|
|
|
v.push_back(new TStroke(q2));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
void detectCorners(const TStroke *stroke, double minDegree,
|
|
std::vector<int> &corners) {
|
|
const double minSin = fabs(sin(minDegree * M_PI_180));
|
|
|
|
const TThickQuadratic *quad1 = 0;
|
|
const TThickQuadratic *quad2 = 0;
|
|
UINT quadCount1 = stroke->getChunkCount();
|
|
TPointD speed1, speed2;
|
|
|
|
TPointD tan1, tan2;
|
|
quad1 = stroke->getChunk(0);
|
|
for (UINT j = 1; j < quadCount1; j++) {
|
|
quad2 = stroke->getChunk(j);
|
|
|
|
speed1 = quad1->getSpeed(1);
|
|
speed2 = quad2->getSpeed(0);
|
|
if (!(speed1 == TPointD() || speed2 == TPointD())) {
|
|
tan1 = normalize(speed1);
|
|
tan2 = normalize(speed2);
|
|
if (tan1 * tan2 < 0 || fabs(cross(tan1, tan2)) >= minSin)
|
|
corners.push_back(j);
|
|
}
|
|
quad1 = quad2;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------------------
|
|
namespace {
|
|
|
|
//! Rimuove le quadratiche nulle, cioe' i chunk in cui i TThickPoint sono quasi
|
|
//! uguali
|
|
bool removeNullQuadratic(TStroke *stroke, bool checkThickness = true) {
|
|
vector<TThickPoint> points;
|
|
UINT i, qCount = stroke->getChunkCount();
|
|
const TThickQuadratic *q;
|
|
TThickPoint p1, p2, p3;
|
|
|
|
// se i punti coincidono e' una stroke puntiforme ed e' ammessa
|
|
if (qCount == 1) return false;
|
|
|
|
bool check = false;
|
|
|
|
for (i = 0; i != qCount; i++) {
|
|
q = stroke->getChunk(i);
|
|
p1 = q->getThickP0();
|
|
p2 = q->getThickP1();
|
|
p3 = q->getThickP2();
|
|
|
|
if (areAlmostEqual(p1.x, p2.x) && areAlmostEqual(p2.x, p3.x) &&
|
|
areAlmostEqual(p1.y, p2.y) && areAlmostEqual(p2.y, p3.y) &&
|
|
(!checkThickness || (areAlmostEqual(p1.thick, p2.thick) &&
|
|
areAlmostEqual(p2.thick, p3.thick)))) {
|
|
// assert(!"null quadratic");
|
|
check = true;
|
|
} else {
|
|
points.push_back(p1);
|
|
points.push_back(p2);
|
|
}
|
|
}
|
|
|
|
if (check) {
|
|
points.push_back(p3);
|
|
stroke->reshape(&(points[0]), points.size());
|
|
}
|
|
|
|
return check;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
//! Converte un TThickPoint p0 in un T3DPoint
|
|
inline T3DPointD thickPntTo3DPnt(const TThickPoint &p0) {
|
|
return T3DPointD(p0.x, p0.y, p0.thick);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//! Converte un vettore di TThickPoint from in un vettore di T3DPointD to
|
|
void convert(const vector<TThickPoint> &from, vector<T3DPointD> &to) {
|
|
to.resize(from.size());
|
|
transform(from.begin(), from.end(), to.begin(), thickPntTo3DPnt);
|
|
}
|
|
|
|
typedef vector<TThickCubic *> TThickCubicArray;
|
|
typedef vector<TThickQuadratic *> QuadStrokeChunkArray;
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*!
|
|
Restituisce un puntatore ad un array di double che contiene la
|
|
distanza tra
|
|
il primo punto e i successivi diviso la distanza tra il primo
|
|
punto e l'ultimo
|
|
*/
|
|
double *chordLengthParameterize3D(const T3DPointD *pointsArrayBegin, int size) {
|
|
double *u = new double[size];
|
|
u[0] = 0.0;
|
|
int i;
|
|
for (i = 1; i < size; i++)
|
|
u[i] = u[i - 1] +
|
|
tdistance(*(pointsArrayBegin + i), *(pointsArrayBegin + i - 1));
|
|
for (i = 1; i < size; i++) {
|
|
assert(!isAlmostZero(u[size - 1]));
|
|
u[i] = u[i] / u[size - 1];
|
|
}
|
|
return u;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*!
|
|
Returns a \a measure of the maximal discrepancy of the points specified
|
|
by pointsArray from the corresponding cubic(u[]) points.
|
|
*/
|
|
double computeMaxError3D(const TThickCubic &cubic,
|
|
const T3DPointD *pointsArrayBegin, int size, double *u,
|
|
int &splitPoint) {
|
|
double err, maxErr = 0;
|
|
splitPoint = 0;
|
|
|
|
for (int i = 1; i < size - 1; i++) {
|
|
#ifdef USE_NEW_3D_ERROR_COMPUTE
|
|
|
|
// Being cubic a THICK cubic, we assume that the supplied points' z
|
|
// refers to thicknesses as well.
|
|
|
|
// So, given 2 thick points in the plane, we use the maximal distance
|
|
// of 'corresponding' outline points. Correspondence refers to the
|
|
// same relative position from centers. It's easily verifiable that
|
|
// such maximal distance is found when the relative positions both lie
|
|
// along the line connecting the two centers.
|
|
|
|
const TThickPoint &A(cubic.getThickPoint(u[i]));
|
|
const T3DPointD &B(pointsArrayBegin[i]);
|
|
|
|
err = sqrt(sq(B.x - A.x) + sq(B.y - A.y)) + fabs(B.z - A.thick);
|
|
|
|
#else
|
|
|
|
// Old version, less intuitive. Similar to the above, except that the
|
|
// 2d-norm is
|
|
// roughly multiplied by norm((TPointD) B-A) / A.thick ... I wonder
|
|
// why ....
|
|
|
|
T3DPointD delta =
|
|
thickPntTo3DPnt(cubic.getThickPoint(u[i])) - *(pointsArrayBegin + i);
|
|
|
|
double thick = cubic.getThickPoint(u[i]).thick;
|
|
if (thick <= 2.0) thick = 2.0;
|
|
|
|
err = norm2(TPointD(delta.x, delta.y)) / thick;
|
|
|
|
if (fabs(delta.z) > 2.0) err = err + fabs(delta.z);
|
|
|
|
#endif
|
|
|
|
if (err >= maxErr) {
|
|
maxErr = err;
|
|
splitPoint = i;
|
|
}
|
|
}
|
|
|
|
return maxErr;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
double NewtonRaphsonRootFind3D(const TThickCubic &cubic, const T3DPointD &p3D,
|
|
double u) {
|
|
TPointD qU = cubic.getPoint(u);
|
|
TPointD q1U = cubic.getSpeed(u);
|
|
TPointD q2U = cubic.getAcceleration(u);
|
|
|
|
TPointD p(p3D.x, p3D.y);
|
|
|
|
return u - ((qU - p) * q1U) / (norm2(q1U) + (qU - p) * q2U);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
int compareDouble(const void *e1, const void *e2) {
|
|
return (*(double *)e1 < *(double *)e2)
|
|
? -1
|
|
: (*(double *)e1 == *(double *)e2) ? 0 : 1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//! Ricalcola i valori di u[] sulla base del metodo di Newton Raphson
|
|
double *reparameterize3D(const TThickCubic &cubic,
|
|
const T3DPointD *pointsArrayBegin, int size,
|
|
double *u) {
|
|
double *uPrime = new double[size];
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
uPrime[i] = NewtonRaphsonRootFind3D(cubic, *(pointsArrayBegin + i), u[i]);
|
|
if (!std::isfinite(uPrime[i])) {
|
|
delete[] uPrime;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
qsort(uPrime, size, sizeof(double), compareDouble);
|
|
// std::sort( uPrime, uPrime+size );
|
|
|
|
if (uPrime[0] < 0.0 || uPrime[size - 1] > 1.0) {
|
|
delete[] uPrime;
|
|
return NULL;
|
|
}
|
|
|
|
assert(uPrime[0] >= 0.0);
|
|
assert(uPrime[size - 1] <= 1.0);
|
|
|
|
return uPrime;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline double B1(double u) {
|
|
double tmp = 1.0 - u;
|
|
return 3 * u * tmp * tmp;
|
|
}
|
|
inline double B2(double u) { return 3 * u * u * (1 - u); }
|
|
inline double B0plusB1(double u) {
|
|
double tmp = 1.0 - u;
|
|
return tmp * tmp * (1.0 + 2.0 * u);
|
|
}
|
|
inline double B2plusB3(double u) { return u * u * (3.0 - 2.0 * u); }
|
|
|
|
} // end of unnamed namespace
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//! Classe che definisce uno stroke cubico
|
|
|
|
class TCubicStroke {
|
|
private:
|
|
//! Genera un TThickCubic
|
|
TThickCubic *generateCubic3D(const T3DPointD pointsArrayBegin[],
|
|
const double uPrime[], int size,
|
|
const T3DPointD &tangentLeft,
|
|
const T3DPointD &tangentRight);
|
|
|
|
//! Genera una cubica in modo ricorsivo
|
|
void fitCubic3D(const T3DPointD pointsArrayBegin[], int size,
|
|
const T3DPointD &tangentLeft, const T3DPointD &tangentRight,
|
|
double error);
|
|
|
|
//! Rettangolo che contiene il TCubicStroke
|
|
TRectD m_bBox;
|
|
|
|
public:
|
|
//! Puntatore a vettore di puntatori a TThickCubic
|
|
vector<TThickCubic *> *m_cubicChunkArray;
|
|
|
|
//! Costruttore
|
|
TCubicStroke();
|
|
//! Costruttore
|
|
/*!
|
|
Costruisce un TCubicStroke uguale al TCubicStroke datogli
|
|
*/
|
|
TCubicStroke(const TCubicStroke &stroke);
|
|
//! Costruttore
|
|
/*!
|
|
Costruisce un TCubicStroke da un array di T3DPointD,
|
|
in funzione dei due parametri error e doDetectCorners
|
|
*/
|
|
TCubicStroke(const vector<T3DPointD> &pointsArray3D, double error,
|
|
bool doDetectCorners = true);
|
|
/*
|
|
TCubicStroke( vector<TPointD> &pointsArray,
|
|
double error,
|
|
const TPointD &tangentLeft,
|
|
const TPointD &tangentRight);
|
|
*/
|
|
//! Distruttore
|
|
~TCubicStroke();
|
|
};
|
|
|
|
namespace {
|
|
|
|
// It implements the degree reduction algorithm, returning the times
|
|
// that the cubic must be splitted (in the half), in order to approximate
|
|
// it with a sequence of quadratic bezier curves.
|
|
// This method doesn't take into count the thickness of the control points,
|
|
// so it just operates on the center line of the fat cubic curve
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*! It splits a cubic bezier curve 'splits' times in the half. Then each
|
|
subcurve is converted into quadratic curve, computing the middle control
|
|
circle as the weighted averege of the four control circles of the
|
|
original cubic subcurve.
|
|
*/
|
|
void doComputeQuadraticsFromCubic(const TThickCubic &cubic, int splits,
|
|
vector<TThickQuadratic *> &chunkArray) {
|
|
TThickPoint p0r, p1r, p2r, p3r, p0l, p1l, p2l, p3l;
|
|
|
|
p0l = cubic.getThickP0();
|
|
p1l = cubic.getThickP1();
|
|
p2l = cubic.getThickP2();
|
|
p3l = cubic.getThickP3();
|
|
|
|
p3l = 0.5 * (p3l + p2l);
|
|
p2l = 0.5 * (p2l + p1l);
|
|
p1l = 0.5 * (p1l + p0l);
|
|
p3l = 0.5 * (p3l + p2l);
|
|
p2l = 0.5 * (p2l + p1l);
|
|
p3l = 0.5 * (p3l + p2l);
|
|
|
|
// cubic.getControlPoints(p0r, p1r, p2r, p3r);
|
|
p0r = cubic.getThickP0();
|
|
p1r = cubic.getThickP1();
|
|
p2r = cubic.getThickP2();
|
|
p3r = cubic.getThickP3();
|
|
|
|
p0r = 0.5 * (p0r + p1r);
|
|
p1r = 0.5 * (p1r + p2r);
|
|
p2r = 0.5 * (p2r + p3r);
|
|
p0r = 0.5 * (p0r + p1r);
|
|
p1r = 0.5 * (p1r + p2r);
|
|
p0r = 0.5 * (p0r + p1r);
|
|
|
|
if (splits > 0) {
|
|
TThickCubic cubic1(cubic);
|
|
TThickCubic tmp_1(p0l, p1l, p2l, p3l);
|
|
std::swap(cubic1, tmp_1);
|
|
doComputeQuadraticsFromCubic(cubic1, splits - 1, chunkArray);
|
|
TThickCubic tmp_2(p0r, p1r, p2r, p3r);
|
|
std::swap(cubic1, tmp_2);
|
|
doComputeQuadraticsFromCubic(cubic1, splits - 1, chunkArray);
|
|
} else {
|
|
TThickQuadratic *chunkL =
|
|
new TThickQuadratic(p0l, 0.25 * (3 * (p1l + p2l) - (p0l + p3l)), p3l);
|
|
TThickQuadratic *chunkR =
|
|
new TThickQuadratic(p0r, 0.25 * (3 * (p1r + p2r) - (p0r + p3r)), p3r);
|
|
|
|
// int size = chunkArray.size();
|
|
chunkArray.push_back(chunkL);
|
|
chunkArray.push_back(chunkR);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*!
|
|
Genera una o piu' quadratiche da una cubica.
|
|
Pone una serie di condizioni , se sono verificate crea una unica quadratica,
|
|
altrimenti richiama doComputeQuadraticsFromCubic
|
|
*/
|
|
void computeQuadraticsFromCubic(const TThickCubic &cubic, double error,
|
|
vector<TThickQuadratic *> &chunkArray) {
|
|
const double T = 0.21132486540518711775; /* 1/2 - sqrt(3)/6 */
|
|
const double S = (1 - T);
|
|
int splits;
|
|
double dist2 = tdistance2(cubic.getP1(), cubic.getP2());
|
|
if (dist2 < 2) {
|
|
chunkArray.push_back(new TThickQuadratic(
|
|
cubic.getThickP0(), 0.5 * (cubic.getThickP1() + cubic.getThickP2()),
|
|
cubic.getThickP3()));
|
|
return;
|
|
}
|
|
|
|
TPointD dp = ((S * S * S) - (S * S - S * T / 2)) * cubic.getP0() +
|
|
((3 * S * S * T) - (S * T * 3 / 2)) * cubic.getP1() +
|
|
((3 * S * T * T) - (S * T * 3 / 2)) * cubic.getP2() +
|
|
((T * T * T) - (T * T - S * T / 2)) * cubic.getP3();
|
|
|
|
double dist_sq = norm2(dp);
|
|
|
|
for (splits = 0; dist_sq > error; splits++) dist_sq *= 0.125 * 0.125;
|
|
|
|
if (splits == 0) {
|
|
TPointD p0 = cubic.getP0();
|
|
TPointD p1 = cubic.getP1();
|
|
TPointD p2 = cubic.getP2();
|
|
TPointD p3 = cubic.getP3();
|
|
|
|
TPointD side01 = p1 - p0;
|
|
TPointD side32 = p2 - p3;
|
|
// se sono verificate TUTTE le condizioni dei seguenti if nidificati,
|
|
// allora viene
|
|
// generata un'unica quadratica per approssimare cubic. Altrimenti,
|
|
// se NON viene verificata ALMENO una delle condizioni dei seguenti if
|
|
// nidificati, allora
|
|
// cubic viene splittata ulteriormente e trattata da
|
|
// doComputeQuadraticsFromCubic
|
|
double det =
|
|
-side01.x * side32.y + side01.y * side32.x; // -cross(side01, side32)
|
|
if (!isAlmostZero(det)) // side01 incidente side32 (verra' calcolata
|
|
// l'intersezione...)
|
|
{
|
|
TPointD side03 = p3 - p0;
|
|
double det01 = -side03.x * side32.y + side03.y * side32.x;
|
|
double det32 = side01.x * side03.y - side01.y * side03.x;
|
|
double t01 = det01 / det;
|
|
double t32 = det32 / det;
|
|
// unused variable
|
|
#if 0
|
|
TPointD p01 = p0 + t01*(p1 - p0); // debug
|
|
TPointD p32 = p3 + t32*(p2 - p3); // debug
|
|
#endif
|
|
// TPointD intersection = p0 + t01*(p1 - p0) = p3 + t32*(p2 - p3)
|
|
// assert (areAlmostEqual(p0 + t01*(p1 - p0), p3 + t32*(p2 - p3)));
|
|
if (t01 >= 1 && t32 >= 1) { // poligonale p0_p1_p2_p3 NON e' a "zig-zag"
|
|
double norm2_side0p = norm2(t01 * side01);
|
|
double norm2_side3p = norm2(t32 * side32);
|
|
if (!isAlmostZero(norm2_side0p, 1e-20) &&
|
|
!isAlmostZero(norm2_side3p,
|
|
1e-20)) { // la condizione puo' essere violata anche
|
|
// nel caso !isAlmostZero(det) == true
|
|
double norm2_side03 = norm2(side03);
|
|
double tmp = norm2_side0p + norm2_side3p - norm2_side03;
|
|
// double cs = tmp/(2*sqrt(norm2_side0p)*sqrt(norm2_side3p)); //
|
|
// debug
|
|
double cs_sign =
|
|
tmp >= 0 ? 1 : -1; // cs2 "perde" il segno (cs2 = cs*cs)
|
|
// th coseno: gli assert del tipo acos(sqrt(cs2)) sono commentati
|
|
// perche' puo' essere cs2 > 1 per errori
|
|
// di approssimazione: tuttavia la cosa non costituisce problema
|
|
// (acos non viene mai eseguta...)
|
|
double cs2 = sq(tmp) / (4 * norm2_side0p * norm2_side3p);
|
|
// assert (0 <= cs2 && cs2 <= 1 + TConsts::epsilon);
|
|
assert(areAlmostEqual(
|
|
tsign(cs_sign) * sqrt(cs2),
|
|
tmp / (2 * sqrt(norm2_side0p) * sqrt(norm2_side3p))));
|
|
if (cs_sign < 0 || cs2 < 0.969846) // cos(10°)^2 = 0.969846
|
|
{ // limita distanza di intersection: elimina quadratiche "cappio"
|
|
// (con p1 "lontano")
|
|
// assert (acos(tsign(cs_sign)*sqrt(cs2)) > 10*M_PI_180);
|
|
assert(tsign(cs_sign) * sqrt(cs2) < cos(10 * M_PI_180));
|
|
TPointD intersection =
|
|
p0 + t01 * (p1 - p0); // = p2 + t32*(p2 - p3)
|
|
TThickPoint p(
|
|
intersection.x, intersection.y,
|
|
0.5 * (cubic.getThickP1().thick +
|
|
cubic.getThickP2()
|
|
.thick)); // compatibilita' precedente funzione
|
|
chunkArray.push_back(
|
|
new TThickQuadratic(cubic.getThickP0(), p, cubic.getThickP3()));
|
|
|
|
#ifdef _DEBUG
|
|
TThickQuadratic *lastTq = chunkArray.back();
|
|
TThickPoint pDeb = lastTq->getThickP0();
|
|
assert(std::isfinite(pDeb.x));
|
|
assert(std::isfinite(pDeb.y));
|
|
assert(std::isfinite(pDeb.thick));
|
|
pDeb = lastTq->getThickP1();
|
|
assert(std::isfinite(pDeb.x));
|
|
assert(std::isfinite(pDeb.y));
|
|
assert(std::isfinite(pDeb.thick));
|
|
pDeb = lastTq->getThickP2();
|
|
assert(std::isfinite(pDeb.x));
|
|
assert(std::isfinite(pDeb.y));
|
|
assert(std::isfinite(pDeb.thick));
|
|
#endif
|
|
numSaved++; // variabile debug: compatibilita' precedente funzione
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
TPointD side03 = p3 - p0;
|
|
double det01 = -side03.x * side32.y + side03.y * side32.x;
|
|
if (isAlmostZero(det01)) {
|
|
// e' una retta!, crea unica quadratica con p in mezzo a p1 e p2
|
|
chunkArray.push_back(new TThickQuadratic(
|
|
cubic.getThickP0(), (cubic.getThickP1() + cubic.getThickP2()) * 0.5,
|
|
cubic.getThickP3()));
|
|
numSaved++; // variabile debug: compatibilita' precedente funzione
|
|
return;
|
|
}
|
|
}
|
|
// else: se arriva qui, almeno una delle condizioni negli if nidificati
|
|
// precedenti e' falsa
|
|
splits++;
|
|
}
|
|
doComputeQuadraticsFromCubic(cubic, splits - 1, chunkArray);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// TStroke *computeQuadStroke(const TCubicStroke& cubic, double error)
|
|
|
|
//! Ricava uno stroke quadratico da uno stroke cubico
|
|
TStroke *computeQuadStroke(const TCubicStroke &cubic) {
|
|
vector<TThickQuadratic *> chunkArray;
|
|
|
|
for (UINT i = 0; i < cubic.m_cubicChunkArray->size(); i++) {
|
|
TThickCubic tmp(*(*cubic.m_cubicChunkArray)[i]);
|
|
|
|
#ifdef _DEBUG
|
|
{
|
|
TThickPoint p = tmp.getThickP0();
|
|
assert(std::isfinite(p.x));
|
|
assert(std::isfinite(p.y));
|
|
assert(std::isfinite(p.thick));
|
|
p = tmp.getThickP1();
|
|
assert(std::isfinite(p.x));
|
|
assert(std::isfinite(p.y));
|
|
assert(std::isfinite(p.thick));
|
|
p = tmp.getThickP2();
|
|
assert(std::isfinite(p.x));
|
|
assert(std::isfinite(p.y));
|
|
assert(std::isfinite(p.thick));
|
|
p = tmp.getThickP3();
|
|
assert(std::isfinite(p.x));
|
|
assert(std::isfinite(p.y));
|
|
assert(std::isfinite(p.thick));
|
|
}
|
|
#endif
|
|
|
|
// this code use a Chebychev version of degree reduction
|
|
|
|
// This code is for old algorithm only:
|
|
computeQuadraticsFromCubic(tmp, 2.0 /*0.5*/, chunkArray);
|
|
}
|
|
|
|
TStroke *outStroke = TStroke::create(chunkArray);
|
|
|
|
clearPointerContainer(chunkArray);
|
|
|
|
return outStroke;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// helper function (defined in tstroke.h)
|
|
|
|
void computeQuadraticsFromCubic(const TThickPoint &p0, const TThickPoint &p1,
|
|
const TThickPoint &p2, const TThickPoint &p3,
|
|
double error,
|
|
vector<TThickQuadratic *> &chunkArray) {
|
|
computeQuadraticsFromCubic(TThickCubic(p0, p1, p2, p3), error, chunkArray);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TCubicStroke::TCubicStroke() : m_bBox() {
|
|
m_cubicChunkArray = new TThickCubicArray();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TCubicStroke::TCubicStroke(const TCubicStroke &stroke)
|
|
: m_bBox(stroke.m_bBox), m_cubicChunkArray(stroke.m_cubicChunkArray) {
|
|
m_cubicChunkArray = new TThickCubicArray(*stroke.m_cubicChunkArray);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TCubicStroke::~TCubicStroke() {
|
|
if (m_cubicChunkArray) {
|
|
while (!m_cubicChunkArray->empty()) {
|
|
delete m_cubicChunkArray->back();
|
|
m_cubicChunkArray->pop_back();
|
|
}
|
|
|
|
delete m_cubicChunkArray;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TCubicStroke::TCubicStroke(const vector<T3DPointD> &pointsArray3D, double error,
|
|
bool doDetectCorners) {
|
|
vector<int> corners;
|
|
corners.push_back(0);
|
|
if (doDetectCorners) detectCorners(pointsArray3D, 3, 3, 15, 100, corners);
|
|
corners.push_back(pointsArray3D.size() - 1);
|
|
|
|
#ifndef USE_NEW_3D_ERROR_COMPUTE
|
|
error *= error;
|
|
#endif
|
|
|
|
m_cubicChunkArray = new vector<TThickCubic *>();
|
|
|
|
for (int i = 1; i < (int)corners.size(); i++) {
|
|
int size = corners[i] - corners[i - 1] + 1;
|
|
int firstPoint = corners[i - 1];
|
|
T3DPointD tanLeft, tanRigth;
|
|
assert(size > 0);
|
|
if (size > 1) // capita che corners[i] = corners[i - 1] ("clic" senza drag
|
|
// oppure bug (noto!!!) del cornerDetector)
|
|
{
|
|
tanLeft = -pointsArray3D[firstPoint + 1] + pointsArray3D[firstPoint];
|
|
tanRigth = pointsArray3D[firstPoint + size - 2] -
|
|
pointsArray3D[firstPoint + size - 1];
|
|
|
|
if (norm2(tanLeft) > 0) tanLeft = normalize(tanLeft);
|
|
|
|
if (norm2(tanRigth) > 0) tanRigth = normalize(tanRigth);
|
|
|
|
fitCubic3D(&pointsArray3D[firstPoint], size, tanLeft, tanRigth, error);
|
|
} else if (pointsArray3D.size() == 1) {
|
|
// caso in cui i non calcola nessun corner a meno di quello iniziale
|
|
// e finale coincidenti: 1 solo punto campionato ("clic" senza drag)
|
|
assert(size == 1);
|
|
assert(corners.size() == 2);
|
|
assert(corners[0] == 0);
|
|
assert(corners[1] == 0);
|
|
m_cubicChunkArray->push_back(
|
|
new TThickCubic(pointsArray3D[0], pointsArray3D[0], pointsArray3D[0],
|
|
pointsArray3D[0]));
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TCubicStroke::fitCubic3D(const T3DPointD pointsArrayBegin[], int size,
|
|
const T3DPointD &tangentLeft,
|
|
const T3DPointD &tangentRight, double error) {
|
|
int maxIterations = 4;
|
|
|
|
if (size == 2) {
|
|
double dist = tdistance(*pointsArrayBegin, *(pointsArrayBegin + 1)) / 3.0;
|
|
TThickCubic *strokeCubicChunk = new TThickCubic(
|
|
*pointsArrayBegin, *pointsArrayBegin - dist * tangentLeft,
|
|
*(pointsArrayBegin + 1) + dist * tangentRight, *(pointsArrayBegin + 1));
|
|
|
|
m_cubicChunkArray->push_back(strokeCubicChunk);
|
|
return;
|
|
}
|
|
|
|
double *u = chordLengthParameterize3D(pointsArrayBegin, size);
|
|
TThickCubic *cubic =
|
|
generateCubic3D(pointsArrayBegin, u, size, tangentLeft, tangentRight);
|
|
|
|
int splitPoint;
|
|
double maxError =
|
|
computeMaxError3D(*cubic, pointsArrayBegin, size, u, splitPoint);
|
|
|
|
if (maxError < error) {
|
|
delete[] u;
|
|
m_cubicChunkArray->push_back(cubic);
|
|
return;
|
|
}
|
|
|
|
// if (maxError<error)
|
|
{
|
|
double *uPrime = NULL;
|
|
for (int i = 0; i < maxIterations; i++) {
|
|
// delete uPrime;
|
|
uPrime = reparameterize3D(*cubic, pointsArrayBegin, size, u);
|
|
if (!uPrime) break;
|
|
|
|
delete cubic;
|
|
cubic = generateCubic3D(pointsArrayBegin, uPrime, size, tangentLeft,
|
|
tangentRight);
|
|
maxError =
|
|
computeMaxError3D(*cubic, pointsArrayBegin, size, uPrime, splitPoint);
|
|
if (maxError < error) {
|
|
delete[] uPrime;
|
|
delete[] u;
|
|
m_cubicChunkArray->push_back(cubic);
|
|
return;
|
|
}
|
|
delete[] u;
|
|
u = uPrime;
|
|
}
|
|
}
|
|
|
|
delete[] u;
|
|
delete cubic;
|
|
|
|
T3DPointD centralTangent;
|
|
if (*(pointsArrayBegin + splitPoint - 1) ==
|
|
*(pointsArrayBegin + splitPoint + 1))
|
|
centralTangent = normalize(*(pointsArrayBegin + splitPoint) -
|
|
*(pointsArrayBegin + splitPoint + 1));
|
|
else
|
|
centralTangent = normalize(*(pointsArrayBegin + splitPoint - 1) -
|
|
*(pointsArrayBegin + splitPoint + 1));
|
|
|
|
fitCubic3D(pointsArrayBegin, splitPoint + 1, tangentLeft, centralTangent,
|
|
error);
|
|
|
|
fitCubic3D(pointsArrayBegin + splitPoint, size - splitPoint, centralTangent,
|
|
tangentRight, error);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TThickCubic *TCubicStroke::generateCubic3D(const T3DPointD pointsArrayBegin[],
|
|
const double uPrime[], int size,
|
|
const T3DPointD &tangentLeft,
|
|
const T3DPointD &tangentRight) {
|
|
double X[2], C[2][2];
|
|
int i;
|
|
|
|
T3DPointD p0 = *pointsArrayBegin;
|
|
T3DPointD p3 = *(pointsArrayBegin + size - 1);
|
|
|
|
C[0][0] = C[0][1] = X[0] = 0;
|
|
C[1][0] = C[1][1] = X[1] = 0;
|
|
|
|
for (i = 0; i < size; i++) {
|
|
const T3DPointD A[2] = {
|
|
tangentLeft * B1(uPrime[i]), tangentRight * B2(uPrime[i]),
|
|
};
|
|
|
|
C[0][0] += A[0] * A[0];
|
|
C[0][1] += A[0] * A[1];
|
|
C[1][1] += A[1] * A[1];
|
|
|
|
C[1][0] = C[0][1];
|
|
|
|
T3DPointD tmp = *(pointsArrayBegin + i) - (B0plusB1(uPrime[i]) * p0) +
|
|
B2plusB3(uPrime[i]) * p3;
|
|
X[0] += A[0] * tmp;
|
|
X[1] += A[1] * tmp;
|
|
}
|
|
|
|
double detC0C1 = C[0][0] * C[1][1] - C[0][1] * C[1][0];
|
|
double detC0X = X[1] * C[0][0] - X[0] * C[0][1];
|
|
double detXC1 = X[0] * C[1][1] - X[1] * C[0][1];
|
|
|
|
if (isAlmostZero(detC0C1)) detC0C1 = C[0][0] * C[1][1] * 10e-12;
|
|
|
|
double alphaL = detXC1 / detC0C1;
|
|
double alphaR = detC0X / detC0C1;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// il problema e' che i valori stupidi per alpha non adrebbere messi solo
|
|
// quando ci si accorge
|
|
// che il segno e' sbagliato, ma anche se i valori sono troppo alti. Ma come
|
|
// fare a valutarlo?
|
|
|
|
// Intanto bisognerebbe accertarsi che 'sti valori alcune volte sono cosi'
|
|
// assurdi solo per problemi
|
|
// di approssimazione e non per bachi nel codice
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
double xmin = (numeric_limits<double>::max)();
|
|
double ymin = (numeric_limits<double>::max)();
|
|
double xmax = -(numeric_limits<double>::max)();
|
|
double ymax = -(numeric_limits<double>::max)();
|
|
double thickmin = (numeric_limits<double>::max)();
|
|
double thickmax = -(numeric_limits<double>::max)();
|
|
|
|
for (i = 0; i < size; i++) {
|
|
if (pointsArrayBegin[i].x < xmin) xmin = pointsArrayBegin[i].x;
|
|
if (pointsArrayBegin[i].x > xmax) xmax = pointsArrayBegin[i].x;
|
|
if (pointsArrayBegin[i].y < ymin) ymin = pointsArrayBegin[i].y;
|
|
if (pointsArrayBegin[i].y > ymax) ymax = pointsArrayBegin[i].y;
|
|
if (pointsArrayBegin[i].z < thickmin) thickmin = pointsArrayBegin[i].z;
|
|
if (pointsArrayBegin[i].z > thickmax) thickmax = pointsArrayBegin[i].z;
|
|
}
|
|
|
|
double lx = xmax - xmin;
|
|
assert(lx >= 0);
|
|
double ly = ymax - ymin;
|
|
assert(ly >= 0);
|
|
double lt = thickmax - thickmin;
|
|
assert(lt >= 0);
|
|
|
|
xmin -= lx;
|
|
xmax += lx;
|
|
ymin -= ly;
|
|
ymax += ly;
|
|
thickmin -= lt;
|
|
thickmax += lt;
|
|
|
|
TRectD bbox(xmin, ymin, xmax, ymax);
|
|
|
|
if (alphaL < 0.0 || alphaR < 0.0)
|
|
alphaL = alphaR = sqrt(tdistance2(p0, p3)) / 3.0;
|
|
|
|
T3DPointD p1 = p0 - tangentLeft * alphaL;
|
|
T3DPointD p2 = p3 + tangentRight * alphaR;
|
|
|
|
if (!bbox.contains(TPointD(p1.x, p1.y)) ||
|
|
!bbox.contains(TPointD(p2.x, p2.y))) {
|
|
alphaL = alphaR = sqrt(tdistance2(p0, p3)) / 3.0;
|
|
p1 = p0 - tangentLeft * alphaL;
|
|
p2 = p3 + tangentRight * alphaR;
|
|
}
|
|
|
|
if (p1.z < thickmin)
|
|
p1.z = thickmin;
|
|
else if (p1.z > thickmax)
|
|
p1.z = thickmax;
|
|
|
|
if (p2.z < thickmin)
|
|
p2.z = thickmin;
|
|
else if (p2.z > thickmax)
|
|
p2.z = thickmax;
|
|
|
|
TThickCubic *thickCubic = new TThickCubic(
|
|
TThickPoint(p0.x, p0.y, p0.z), TThickPoint(p1.x, p1.y, p1.z),
|
|
TThickPoint(p2.x, p2.y, p2.z), TThickPoint(p3.x, p3.y, p3.z));
|
|
|
|
return thickCubic;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//! Restituisce uno stroke da un vettore di TThickPoint
|
|
/*!
|
|
Trasforma un vettore di TThickPoint in un vettore di T3DPointD che usa per
|
|
trovare un
|
|
TCubicStroke, cioe' uno stroke cubico. Da questo trova lo stroke
|
|
quadratico.
|
|
*/
|
|
TStroke *TStroke::interpolate(const vector<TThickPoint> &points, double error,
|
|
bool findCorners) {
|
|
vector<T3DPointD> pointsArray3D;
|
|
convert(points, pointsArray3D);
|
|
|
|
TCubicStroke cubicStroke(pointsArray3D, error, findCorners);
|
|
numSaved = 0;
|
|
|
|
// TStroke *stroke = computeQuadStroke(cubicStroke,error);
|
|
TStroke *stroke = computeQuadStroke(cubicStroke);
|
|
|
|
#ifdef _DEBUG
|
|
|
|
UINT cpIndex = 0;
|
|
TThickPoint p;
|
|
for (; cpIndex != (UINT)stroke->getControlPointCount(); cpIndex++) {
|
|
p = stroke->getControlPoint(cpIndex);
|
|
assert(std::isfinite(p.x));
|
|
assert(std::isfinite(p.y));
|
|
assert(std::isfinite(p.thick));
|
|
}
|
|
#endif
|
|
|
|
removeNullQuadratic(stroke);
|
|
stroke->invalidate();
|
|
|
|
return stroke;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
//! Restituisce uno stroke da un vettore di TThickQuadratic
|
|
/*!
|
|
Estrae dalle curve i punti di controllo e crea con questi un nuovo stroke
|
|
*/
|
|
TStroke *TStroke::create(const vector<TThickQuadratic *> &curves) {
|
|
if (curves.empty()) return 0;
|
|
|
|
// make a vector of control points
|
|
vector<TThickPoint> ctrlPnts;
|
|
|
|
extractStrokeControlPoints(curves, ctrlPnts);
|
|
|
|
TStroke *stroke = new TStroke(ctrlPnts);
|
|
|
|
stroke->invalidate();
|
|
|
|
return stroke;
|
|
}
|
|
|
|
//============================================================================
|
|
|
|
TStrokeProp::TStrokeProp(const TStroke *stroke)
|
|
: m_stroke(stroke), m_strokeChanged(true), m_mutex() {}
|
|
|
|
//============================================================================
|
|
|
|
TStroke::OutlineOptions::OutlineOptions()
|
|
: m_capStyle(ROUND_CAP)
|
|
, m_joinStyle(ROUND_JOIN)
|
|
, m_miterLower(0.0)
|
|
, m_miterUpper(4.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke::OutlineOptions::OutlineOptions(UCHAR capStyle, UCHAR joinStyle,
|
|
double lower, double upper)
|
|
: m_capStyle(capStyle)
|
|
, m_joinStyle(joinStyle)
|
|
, m_miterLower(lower)
|
|
, m_miterUpper(upper) {}
|