1276 lines
34 KiB
C++
1276 lines
34 KiB
C++
|
|
|
|
#ifdef _DEBUG
|
|
#define _STLP_DEBUG 1
|
|
#endif
|
|
#include <tcurves.h>
|
|
#include <tstroke.h>
|
|
#include <tmathutil.h>
|
|
#include <tcurveutil.h>
|
|
#include <tgl.h>
|
|
#include <set>
|
|
#include <iterator>
|
|
// please do not move, it is necessary to be the last
|
|
// to work properely with DVAPI macro
|
|
#include "ext/ExtUtil.h"
|
|
|
|
// just to override assert
|
|
#ifdef _DEBUG
|
|
#define EXT_NORMALIZE(a) norm2(a) != 0.0 ? normalize(a) : a
|
|
#define DEBUG_EXPORT DVAPI
|
|
#else
|
|
#define EXT_NORMALIZE(a) normalize(a)
|
|
#define DEBUG_EXPORT static
|
|
#endif
|
|
|
|
namespace {
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline bool isWGood(double first, double w, double second, const TStroke *s) {
|
|
if (!ToonzExt::isValid(first) || !ToonzExt::isValid(second) ||
|
|
!ToonzExt::isValid(w))
|
|
return false;
|
|
|
|
if (s) {
|
|
if (s->isSelfLoop())
|
|
if (first > second) {
|
|
if ((first < w && w <= 1.0) || (0.0 <= w && w < second)) return true;
|
|
} else if (first == second) {
|
|
if (areAlmostEqual(w, first)) return true;
|
|
}
|
|
}
|
|
|
|
if (first < w && w < second) return true;
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
inline int normalizeAngle(int angle) {
|
|
if (angle < 0) angle = -angle;
|
|
return angle %= 181;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
int getStrokeId(const TStroke *s, const TVectorImageP &vi) {
|
|
if (!ToonzExt::isValid(s) || !vi) return -1;
|
|
|
|
int count = vi->getStrokeCount();
|
|
if (!count) return -1;
|
|
|
|
while (count--) {
|
|
if (s == vi->getStroke(count)) return count;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Verify if a curve is a "almost" point.
|
|
*/
|
|
template <class T>
|
|
bool isImproper(const T *tq) {
|
|
TPointD v1 = tq->getP0() - tq->getP1(), v2 = tq->getP2() - tq->getP1();
|
|
|
|
if (isAlmostZero(norm2(v1)) && isAlmostZero(norm2(v2))) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool areParallel(const TPointD &v1, const TPointD &v2) {
|
|
double res = cross(EXT_NORMALIZE(v1), EXT_NORMALIZE(v2));
|
|
if (isAlmostZero(res)) return true;
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool areInSameDirection(const TPointD &v1, const TPointD &v2) {
|
|
if (v1 * v2 >= 0) return true;
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Verify if a curve is a straight line.
|
|
*/
|
|
template <class T>
|
|
bool curveIsStraight(const T *tq, double &t) {
|
|
t = -1;
|
|
assert(tq);
|
|
if (!tq) return false;
|
|
|
|
TPointD v1 = tq->getP1() - tq->getP0();
|
|
TPointD v2 = tq->getP2() - tq->getP1();
|
|
|
|
double res = cross(v1, v2);
|
|
if (isAlmostZero(res)) {
|
|
if (v1 * v2 < 0) {
|
|
t = tq->getT(tq->getP1());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Verify if junction between two curves, is smooth.
|
|
*/
|
|
template <class T>
|
|
bool corner(const T *q1, const T *q2, double tolerance) {
|
|
if (!q1 || !q2 || !areAlmostEqual(q1->getP2(), q2->getP0())) return false;
|
|
|
|
// really near to the extremes
|
|
TPointD
|
|
// pnt = q1->getP2(),
|
|
v1 = q1->getSpeed(1.0), // q1->getPoint(1.0-TConsts::epsilon) - pnt,
|
|
v2 = q2->getSpeed(0.0); // q2->getPoint(TConsts::epsilon) - pnt;
|
|
|
|
v1 = EXT_NORMALIZE(v1);
|
|
v2 = EXT_NORMALIZE(v2);
|
|
|
|
double res = cross(v1, v2);
|
|
|
|
if (!isAlmostZero(res, tolerance)) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
int detectStraightIntervals_(const TThickQuadratic *ttq,
|
|
ToonzExt::Intervals &intervals, double tolerance) {
|
|
if (!ttq) return 0;
|
|
|
|
TPointD v0 = ttq->getP1() - ttq->getP0(), v1 = ttq->getP2() - ttq->getP1();
|
|
|
|
double v0_norm2 = norm(v0), v1_norm2 = norm(v1);
|
|
|
|
if (v0_norm2 != 0.0) v0 = v0 * (1.0 / v0_norm2);
|
|
if (v1_norm2 != 0.0) v1 = v1 * (1.0 / v1_norm2);
|
|
|
|
double v0xv1 = v0 * v1;
|
|
|
|
if (v0xv1 == 0.0 && v0_norm2 == 0.0 &&
|
|
v1_norm2 == 0.0) // null value with all zero
|
|
return 0;
|
|
|
|
if (isAlmostZero(cross(v0, v1) /*,tolerance*/)) {
|
|
if (v0xv1 >= 0) {
|
|
intervals.push_back(ToonzExt::Interval(0.0, 1.0));
|
|
return 1;
|
|
} else {
|
|
double t = ttq->getT(ttq->getP1());
|
|
intervals.push_back(ToonzExt::Interval(0.0, t));
|
|
intervals.push_back(ToonzExt::Interval(t, 1.0));
|
|
return 2;
|
|
}
|
|
}
|
|
#if 0
|
|
// need to be analysed
|
|
else
|
|
{
|
|
double
|
|
pixelSize = 1.0;
|
|
#ifndef _DEBUG
|
|
pixelSize = sqrt(tglGetPixelSize2());
|
|
#endif
|
|
double
|
|
step = computeStep(*ttq,
|
|
pixelSize);
|
|
|
|
//assert( step < 1.0 );
|
|
if( step > 1.0 )
|
|
return 0;
|
|
|
|
double
|
|
t = 0.0;
|
|
|
|
TPointD
|
|
pnt ,
|
|
p0 = ttq->getP0(),
|
|
pn;
|
|
|
|
ToonzExt::Interval
|
|
last_interval(-1,-1),
|
|
curr_interval;
|
|
|
|
pnt = ttq->getPoint(step);
|
|
v0 = pnt - p0;
|
|
if( t+step < 1.0)
|
|
pn = ttq->getPoint( step+step );
|
|
else
|
|
pn = ttq->getP2();
|
|
v1 = pn - pnt;
|
|
|
|
v0 = EXT_NORMALIZE(v0);
|
|
v1 = EXT_NORMALIZE(v1);
|
|
if( isAlmostZero( cross(v0,v1), tolerance ) )
|
|
{
|
|
assert( v0*v1 >0);
|
|
last_interval.first = ttq->getT(p0);
|
|
last_interval.second= ttq->getT(pn);
|
|
}
|
|
p0 = pn;
|
|
|
|
for(t=2.0*step;
|
|
t<1.0;
|
|
t+=2.0*step)
|
|
{
|
|
pnt = ttq->getPoint(t);
|
|
v0 = pnt - p0;
|
|
if( t+step < 1.0)
|
|
pn = ttq->getPoint( t+step );
|
|
else
|
|
pn = ttq->getP2();
|
|
v1 = pn - pnt;
|
|
|
|
v0 = EXT_NORMALIZE(v0);
|
|
v1 = EXT_NORMALIZE(v1);
|
|
if( isAlmostZero( cross(v0,v1), tolerance ) )
|
|
{
|
|
//assert( v0 * v1 > 0 );
|
|
curr_interval.first = ttq->getT(p0);
|
|
curr_interval.second = ttq->getT(pn);
|
|
|
|
if( curr_interval.first != last_interval.second ||
|
|
v0 * v1 < 0)
|
|
{
|
|
intervals.push_back(last_interval);
|
|
last_interval.first =
|
|
last_interval.second = curr_interval.second;
|
|
}
|
|
else
|
|
{
|
|
last_interval.second = curr_interval.second;
|
|
}
|
|
}
|
|
// for quadratic is not possible
|
|
std::swap(p0,pn);
|
|
}
|
|
|
|
pn=ttq->getP2();
|
|
v1 = pn - pnt;
|
|
if( isAlmostZero( cross(v0,v1), tolerance ) )
|
|
{
|
|
if( v0 * v1 > 0 )
|
|
{
|
|
curr_interval.first = ttq->getT(p0);
|
|
curr_interval.second = ttq->getT(pn);
|
|
|
|
if( curr_interval.first == last_interval.second )
|
|
last_interval.second = curr_interval.second;
|
|
|
|
intervals.push_back(last_interval);
|
|
}
|
|
}
|
|
return intervals.size();
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/*
|
|
int
|
|
detectStraightIntervals_(const TThickQuadratic* ttq,
|
|
std::set<double>& values)
|
|
{
|
|
if(!ttq ||
|
|
isImproper( ttq ))
|
|
return 0;
|
|
|
|
TPointD
|
|
v0 = ttq->getP1() - ttq->getP0(),
|
|
v1 = ttq->getP2() - ttq->getP1();
|
|
|
|
if( isAlmostZero( cross(v0,v1) ) )
|
|
{
|
|
values.insert(0.0);
|
|
values.insert(1.0);
|
|
if(v0 * v1 > 0 )
|
|
{
|
|
return values.size()-1;
|
|
}
|
|
else
|
|
{
|
|
double
|
|
t = ttq->getT(ttq->getP1());
|
|
values.insert( t );
|
|
return values.size()-1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double
|
|
pixelSize = 1.0;
|
|
#ifndef _DEBUG
|
|
pixelSize = sqrt(tglGetPixelSize2());
|
|
#endif
|
|
double
|
|
step = computeStep(*ttq,
|
|
pixelSize);
|
|
|
|
double
|
|
t = 0.0;
|
|
|
|
TPointD
|
|
pnt ,
|
|
p0 = ttq->getP0(),
|
|
pn;
|
|
for(t=step;
|
|
t<1.0;
|
|
t+=2.0*step)
|
|
{
|
|
pnt = ttq->getPoint(t);
|
|
v0 = pnt - p0;
|
|
if( t+step < 1.0)
|
|
pn = ttq->getPoint( t+step );
|
|
else
|
|
pn = ttq->getP2();
|
|
v1 = pn - pnt;
|
|
if( isAlmostZero( cross(v0,v1) ) )
|
|
{
|
|
assert( v0 * v1 > 0 );
|
|
values.insert(ttq->getT(p0));
|
|
values.insert(ttq->getT(pn));
|
|
}
|
|
// for quadratic is not possible
|
|
std::swap(p0,pn);
|
|
}
|
|
|
|
pn=ttq->getP2();
|
|
v1 = pn - pnt;
|
|
if( isAlmostZero( cross(v0,v1) ) )
|
|
{
|
|
assert( v0 * v1 > 0 );
|
|
values.insert(ttq->getT(p0));
|
|
values.insert(ttq->getT(pn));
|
|
}
|
|
}
|
|
|
|
return values.size()-1;
|
|
}
|
|
*/
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool mapValueInStroke(const TStroke *stroke, const TThickQuadratic *ttq,
|
|
double value, double &out) {
|
|
assert(ttq);
|
|
|
|
if (!ttq || !ToonzExt::isValid(stroke) || !ToonzExt::isValid(value))
|
|
return false;
|
|
|
|
if (value == 1.0) {
|
|
if (ttq->getPoint(1.0) == stroke->getPoint(1.0)) {
|
|
if (!stroke->isSelfLoop())
|
|
out = 1.0;
|
|
else
|
|
out = 0.0;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
out = stroke->getW(ttq->getPoint(value));
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool mapIntervalInStroke(const TStroke *stroke, const TThickQuadratic *ttq,
|
|
const ToonzExt::Interval &ttq_interval,
|
|
ToonzExt::Interval &stroke_interval) {
|
|
if (!ttq || !ToonzExt::isValid(stroke)) return false;
|
|
|
|
if (ttq_interval.first > ttq_interval.second || 0.0 > ttq_interval.first ||
|
|
ttq_interval.second > 1.0)
|
|
return false;
|
|
|
|
bool check =
|
|
mapValueInStroke(stroke, ttq, ttq_interval.first, stroke_interval.first);
|
|
assert(check);
|
|
if (!check) return false;
|
|
check = mapValueInStroke(stroke, ttq, ttq_interval.second,
|
|
stroke_interval.second);
|
|
|
|
assert(check);
|
|
if (!check) return false;
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool addQuadraticIntervalInStroke(const TStroke *stroke,
|
|
ToonzExt::Intervals &stroke_intervals,
|
|
const TThickQuadratic *ttq,
|
|
ToonzExt::Intervals &ttq_intervals) {
|
|
if (!ttq || !ToonzExt::isValid(stroke)) return false;
|
|
|
|
const int size = ttq_intervals.size();
|
|
|
|
if (size == 0) return false;
|
|
|
|
int i = 0;
|
|
|
|
for (i = 0; i < size; ++i) {
|
|
const ToonzExt::Interval &tmp = ttq_intervals[i];
|
|
|
|
if (tmp.first > tmp.second || 0.0 > tmp.first || tmp.second > 1.0)
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < size; ++i) {
|
|
const ToonzExt::Interval &ttq_interval = ttq_intervals[i];
|
|
ToonzExt::Interval stroke_interval;
|
|
|
|
// start to add interval in stroke
|
|
if (mapIntervalInStroke(stroke, ttq, ttq_interval, stroke_interval)) {
|
|
stroke_intervals.push_back(stroke_interval);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool addQuadraticSetInStroke(const TStroke *stroke,
|
|
ToonzExt::Intervals &stroke_intervals,
|
|
const TThickQuadratic *ttq,
|
|
const std::set<double> &ttq_set) {
|
|
if (!ttq || !ToonzExt::isValid(stroke)) return false;
|
|
|
|
const int size = ttq_set.size();
|
|
|
|
if (size < 1) return false;
|
|
|
|
std::set<double>::const_iterator cit, cit_end = ttq_set.end();
|
|
|
|
for (cit = ttq_set.begin(); cit != cit_end; ++cit) {
|
|
if (0.0 > *cit || *cit > 1.0) return false;
|
|
}
|
|
|
|
cit = ttq_set.begin();
|
|
std::set<double>::const_iterator next_cit = cit;
|
|
std::advance(next_cit, 1);
|
|
|
|
for (; next_cit != cit_end; ++next_cit) {
|
|
ToonzExt::Interval stroke_interval;
|
|
|
|
bool check = mapValueInStroke(stroke, ttq, *cit, stroke_interval.first);
|
|
assert(check);
|
|
if (!check) return false;
|
|
|
|
check = mapValueInStroke(stroke, ttq, *next_cit, stroke_interval.second);
|
|
|
|
assert(check);
|
|
if (!check) return false;
|
|
|
|
assert(stroke_interval.first <= stroke_interval.second);
|
|
if (stroke_interval.first > stroke_interval.second) return false;
|
|
stroke_intervals.push_back(stroke_interval);
|
|
cit = next_cit;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool isThere(double value, const ToonzExt::Intervals &intervals) {
|
|
ToonzExt::Intervals::const_iterator cit = intervals.begin(),
|
|
cit_end = intervals.end();
|
|
|
|
while (cit != cit_end) {
|
|
if (cit->first == value || cit->second == value) return true;
|
|
++cit;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool isThere(double value, const std::set<double> &mySet) {
|
|
std::set<double>::const_iterator cit_end = mySet.end();
|
|
|
|
if (cit_end == mySet.find(value)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool isCorner(const ToonzExt::Intervals &values, double w, double tolerance) {
|
|
ToonzExt::Interval prev = values[0], curr = prev;
|
|
|
|
// first point
|
|
if (areAlmostEqual(prev.first, w, tolerance)) return true;
|
|
|
|
const int size = values.size();
|
|
for (int i = 1; i < size; ++i) {
|
|
curr = values[i];
|
|
|
|
if (areAlmostEqual(prev.second, curr.first) &&
|
|
areAlmostEqual(w, curr.first, tolerance))
|
|
return true;
|
|
prev = curr;
|
|
}
|
|
|
|
// last point
|
|
if (areAlmostEqual(curr.second, w, tolerance)) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
} // end of unnamed namespace
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
DEBUG_EXPORT bool isThereACornerMinusThan(double minCos, double minSin,
|
|
const TThickQuadratic *quad1,
|
|
const TThickQuadratic *quad2) {
|
|
if (!quad1 || !quad2 || !ToonzExt::isValid(fabs(minCos)) ||
|
|
!ToonzExt::isValid(fabs(minSin)))
|
|
return false;
|
|
|
|
TPointD
|
|
// speed1,
|
|
// speed2,
|
|
tan1,
|
|
tan2;
|
|
|
|
// speed1 = quad1->getSpeed(1);
|
|
// speed2 = -quad2->getSpeed(0);
|
|
|
|
tan1 = quad1->getSpeed(1);
|
|
tan2 = -quad2->getSpeed(0);
|
|
|
|
if (norm2(tan1) == 0.0 || norm2(tan2) == 0.0) return false;
|
|
|
|
tan1 = normalize(tan1);
|
|
tan2 = normalize(tan2);
|
|
|
|
// move cos value to compare just positive values
|
|
minCos += 1.0;
|
|
double cosVal = 1.0 + (tan1 * tan2); //, sinVal = fabs(cross(tan1,tan2));
|
|
|
|
assert(minCos >= 0.0);
|
|
if (cosVal >= minCos) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DEBUG_EXPORT double degree2cos(int degree) {
|
|
int tmp = degree < 0 ? -degree : degree;
|
|
tmp %= 360;
|
|
degree = degree < 0 ? 360 - tmp : degree;
|
|
|
|
if (degree == 0) return 1.0;
|
|
|
|
if (degree == 180) return -1.0;
|
|
|
|
if (degree == 90 || degree == 270) return 0.0;
|
|
|
|
return cos(degree * M_PI_180);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DEBUG_EXPORT double degree2sin(int degree) { return degree2cos(degree - 90); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::findNearestSpireCorners(
|
|
const TStroke *stroke, double w, ToonzExt::Interval &out, int cornerSize,
|
|
const ToonzExt::Intervals *const cl, double tolerance) {
|
|
if (!ToonzExt::isValid(stroke) || !ToonzExt::isValid(w)) return false;
|
|
|
|
const ToonzExt::Intervals *values = cl;
|
|
|
|
ToonzExt::Intervals tmpValues;
|
|
|
|
if (!cl) {
|
|
cornerSize = normalizeAngle(cornerSize);
|
|
if (!ToonzExt::detectSpireIntervals(stroke, tmpValues, cornerSize))
|
|
return false;
|
|
values = &tmpValues;
|
|
}
|
|
|
|
if (!values || values->empty()) {
|
|
return false;
|
|
}
|
|
|
|
return findNearestCorners(stroke, w, out, *values, tolerance);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::isASpireCorner(const TStroke *s, double w, int cornerSize,
|
|
const ToonzExt::Intervals *const cl,
|
|
double tolerance) {
|
|
if (!ToonzExt::isValid(s) || !ToonzExt::isValid(w)) return false;
|
|
|
|
ToonzExt::Intervals tmpValues;
|
|
|
|
const ToonzExt::Intervals *values = cl;
|
|
|
|
if (!cl) {
|
|
if (!ToonzExt::detectSpireIntervals(s, tmpValues, cornerSize)) return false;
|
|
values = &tmpValues;
|
|
}
|
|
|
|
if (!values || values->empty()) {
|
|
return false;
|
|
}
|
|
|
|
return isCorner(*values, w, tolerance);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::detectStraightIntervals(const TStroke *stroke,
|
|
ToonzExt::Intervals &intervals,
|
|
double tolerance) {
|
|
if (!ToonzExt::isValid(stroke)) return false;
|
|
|
|
assert(tolerance > 0.0 && tolerance < 1.0 &&
|
|
"Strange tolerance are you sure???");
|
|
|
|
intervals.clear();
|
|
|
|
// first step:
|
|
// store information about chunk and straight interval
|
|
typedef std::pair<const TThickQuadratic *, ToonzExt::Intervals>
|
|
ChunkStraights;
|
|
|
|
std::map<int, ChunkStraights> arrayOfChunkIntervals;
|
|
|
|
int chunkCount = stroke->getChunkCount();
|
|
int counter = 0;
|
|
|
|
for (int i = 0; i < chunkCount; ++i) {
|
|
ToonzExt::Intervals values;
|
|
|
|
const TThickQuadratic *chunk = stroke->getChunk(i);
|
|
if (chunk->getLength() == 0.0) continue;
|
|
int howMany = detectStraightIntervals_(chunk, values, tolerance);
|
|
if (howMany > 0) {
|
|
arrayOfChunkIntervals[counter] = ChunkStraights(chunk, values);
|
|
}
|
|
++counter;
|
|
}
|
|
|
|
// second step:
|
|
// add intervals vs stroke
|
|
std::map<int, ChunkStraights>::iterator it = arrayOfChunkIntervals.begin(),
|
|
end = arrayOfChunkIntervals.end(),
|
|
aux;
|
|
|
|
ToonzExt::Interval myRange = ToonzExt::Interval(-1, -1);
|
|
|
|
for (; it != end; ++it) {
|
|
aux = it;
|
|
std::advance(aux, 1);
|
|
ChunkStraights &cs1 = it->second;
|
|
if (aux != end) {
|
|
ChunkStraights &cs2 = aux->second;
|
|
const int i1 = it->first, i2 = aux->first;
|
|
|
|
// if chunk are a sequence
|
|
if ((i1 + 1 == i2) && !corner(cs1.first, cs2.first, tolerance)) {
|
|
const ToonzExt::Intervals &cs1Intervals = cs1.second;
|
|
|
|
const int size = cs1Intervals.size();
|
|
int i;
|
|
ToonzExt::Interval tmp;
|
|
|
|
for (i = 0; i < size; ++i) {
|
|
tmp = cs1Intervals[i];
|
|
|
|
if (tmp.second == 1.0) break;
|
|
|
|
ToonzExt::Interval stroke_interval;
|
|
if (mapIntervalInStroke(stroke, cs1.first, tmp, stroke_interval))
|
|
intervals.push_back(stroke_interval);
|
|
}
|
|
// assert( i == size-1 );
|
|
|
|
if (myRange.first == -1) {
|
|
if (!mapValueInStroke(stroke, cs1.first, tmp.first, myRange.first))
|
|
assert(!"Ops problemone!!!");
|
|
// remove value added to merge
|
|
// adjacent straight interval
|
|
cs1.second.pop_back();
|
|
}
|
|
|
|
tmp = cs2.second.front();
|
|
|
|
if (!mapValueInStroke(stroke, cs2.first, tmp.second, myRange.second))
|
|
assert(!"Ops problemone!!!");
|
|
cs2.second.erase(cs2.second.begin());
|
|
} else {
|
|
if (myRange.first != -1 && myRange.second != -1) {
|
|
intervals.push_back(myRange);
|
|
myRange = ToonzExt::Interval(-1, -1);
|
|
}
|
|
|
|
// add remaining interval of current stroke
|
|
addQuadraticIntervalInStroke(stroke, intervals, cs1.first, cs1.second);
|
|
}
|
|
} else {
|
|
if (myRange.first != -1 && myRange.second != -1) {
|
|
intervals.push_back(myRange);
|
|
myRange = ToonzExt::Interval(-1, -1);
|
|
}
|
|
|
|
// add remaining interval of current stroke
|
|
addQuadraticIntervalInStroke(stroke, intervals, cs1.first, cs1.second);
|
|
}
|
|
}
|
|
|
|
if (stroke->isSelfLoop()) {
|
|
TPointD v0 = stroke->getSpeed(0.0), vn = stroke->getSpeed(1.0);
|
|
|
|
if (areParallel(v0, vn) && areInSameDirection(v0, vn) &&
|
|
intervals.size() > 1) {
|
|
// then first interval probably can be merged
|
|
ToonzExt::Interval first = intervals.front(), last = intervals.back();
|
|
if (first.first == 0.0 && last.second == 0.0) {
|
|
intervals.pop_back();
|
|
first.first = last.first;
|
|
intervals[0] = first;
|
|
}
|
|
}
|
|
}
|
|
|
|
return !intervals.empty();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::detectSpireIntervals(const TStroke *stroke,
|
|
ToonzExt::Intervals &intervals,
|
|
int minDegree) {
|
|
if (!ToonzExt::isValid(stroke)) return false;
|
|
|
|
minDegree = normalizeAngle(minDegree);
|
|
std::vector<double> corners;
|
|
|
|
bool found = ToonzExt::cornersDetector(stroke, minDegree, corners);
|
|
if (!found) return false;
|
|
|
|
assert(!corners.empty());
|
|
|
|
intervals.clear();
|
|
|
|
double first = corners[0], last = first;
|
|
|
|
int size = corners.size();
|
|
|
|
for (int i = 1; i < size; ++i) {
|
|
last = corners[i];
|
|
intervals.push_back(ToonzExt::Interval(first, last));
|
|
first = last;
|
|
}
|
|
|
|
// intervals.push_back( ToonzExt::Interval(last,1.0));
|
|
|
|
if (stroke->isSelfLoop()) {
|
|
if (corners.size() == 1) {
|
|
double val = corners[0];
|
|
intervals.push_back(ToonzExt::Interval(val, val));
|
|
} else if (!intervals.empty()) {
|
|
ToonzExt::Interval first = intervals.front(), last = intervals.back();
|
|
|
|
intervals.insert(intervals.begin(),
|
|
ToonzExt::Interval(last.second, first.first));
|
|
}
|
|
}
|
|
|
|
return !intervals.empty();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::isAStraightCorner(const TStroke *stroke, double w,
|
|
const ToonzExt::Intervals *const cl,
|
|
double tolerance) {
|
|
if (!ToonzExt::isValid(stroke) || !ToonzExt::isValid(w)) return false;
|
|
|
|
ToonzExt::Intervals tmpValues;
|
|
|
|
const ToonzExt::Intervals *values = cl;
|
|
|
|
if (!cl) {
|
|
if (!ToonzExt::detectStraightIntervals(stroke, tmpValues, tolerance))
|
|
return false;
|
|
values = &tmpValues;
|
|
}
|
|
|
|
if (!values || values->empty()) {
|
|
return false;
|
|
}
|
|
|
|
return isCorner(*values, w, tolerance);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::findNearestStraightCorners(
|
|
const TStroke *stroke, double w, ToonzExt::Interval &out,
|
|
const ToonzExt::Intervals *const cl, double tolerance) {
|
|
if (!stroke || w < 0.0 || w > 1.0) return false;
|
|
|
|
const ToonzExt::Intervals *values = cl;
|
|
|
|
ToonzExt::Intervals tmpValues;
|
|
|
|
if (!cl) {
|
|
if (!ToonzExt::detectStraightIntervals(stroke, tmpValues, tolerance))
|
|
return false;
|
|
values = &tmpValues;
|
|
}
|
|
|
|
if (!values || values->empty()) {
|
|
return false;
|
|
}
|
|
|
|
return findNearestCorners(stroke, w, out, *values, tolerance);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStroke *ToonzExt::rotateControlPoint(const TStroke *stroke,
|
|
const ToonzExt::EvenInt &evenControlPoint,
|
|
double atLength) {
|
|
if (!stroke || !stroke->isSelfLoop() || !evenControlPoint.isEven()) return 0;
|
|
#ifdef _DEBUG
|
|
TThickPoint tp1 = stroke->getControlPoint(0);
|
|
TThickPoint tp2 = stroke->getControlPoint(stroke->getControlPointCount() - 1);
|
|
#endif
|
|
int controlPoint = (int)evenControlPoint;
|
|
|
|
const double length = stroke->getLength();
|
|
|
|
// invalid length
|
|
if (0.0 > atLength || atLength > length) return 0;
|
|
|
|
const int cpCountAtBegin = stroke->getControlPointCount();
|
|
// invalid control point
|
|
if (0 > controlPoint || controlPoint > cpCountAtBegin) return 0;
|
|
|
|
// identity
|
|
if ((controlPoint == 0 || controlPoint == (cpCountAtBegin - 1)) &&
|
|
(areAlmostEqual(atLength, length) || isAlmostZero(atLength)))
|
|
return new TStroke(*stroke);
|
|
|
|
TStroke tmpStroke(*stroke);
|
|
|
|
std::vector<TThickPoint> cp;
|
|
{
|
|
int count = stroke->getControlPointCount();
|
|
for (int i = 0; i < count; ++i) {
|
|
cp.push_back(stroke->getControlPoint(i));
|
|
}
|
|
}
|
|
|
|
// add a control point where is necessary to have rotation (head_queue cp)
|
|
tmpStroke.insertControlPointsAtLength(atLength);
|
|
|
|
#ifdef _DEBUG
|
|
{
|
|
int count = stroke->getControlPointCount(),
|
|
count2 = tmpStroke.getControlPointCount();
|
|
int i, firstDifference = -1;
|
|
for (i = 0; i < count; ++i) {
|
|
if ((tp1 = stroke->getControlPoint(i)) !=
|
|
(tp2 = tmpStroke.getControlPoint(i))) {
|
|
firstDifference = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < count; ++i) {
|
|
if (i < firstDifference)
|
|
assert((tp1 = stroke->getControlPoint(i)) ==
|
|
(tp2 = tmpStroke.getControlPoint(i)));
|
|
else {
|
|
// assert( (tp1=stroke->getControlPoint(i)) ==
|
|
// (tp2=tmpStroke.getControlPoint(i+2)));
|
|
}
|
|
|
|
tp1 = stroke->getControlPoint(i);
|
|
tp2 = tmpStroke.getControlPoint(i);
|
|
}
|
|
}
|
|
#endif
|
|
const int cpCount = tmpStroke.getControlPointCount();
|
|
|
|
double w = tmpStroke.getParameterAtLength(atLength);
|
|
|
|
double butta = tmpStroke.getLength(w);
|
|
assert(areAlmostEqual(butta, atLength));
|
|
|
|
// retrieve head_queue control point
|
|
TThickPoint head_queue = tmpStroke.getControlPointAtParameter(w);
|
|
|
|
// recover index
|
|
int i;
|
|
for (i = 0; i < cpCount; ++i) {
|
|
if (head_queue == tmpStroke.getControlPoint(i)) break;
|
|
}
|
|
|
|
const int head_index = i;
|
|
|
|
// uhmmm really strange
|
|
if (head_index == cpCount) {
|
|
assert(!"Error on procedure!!! Not control point found!!!"
|
|
" Wrong insert control point!!!");
|
|
return 0;
|
|
}
|
|
|
|
// head_index is the new head of stroke
|
|
std::vector<TThickPoint> new_stroke_cp;
|
|
|
|
for (i = head_index; i < cpCount; ++i) {
|
|
TThickPoint to_add = tmpStroke.getControlPoint(i);
|
|
new_stroke_cp.push_back(to_add);
|
|
}
|
|
|
|
TThickPoint tmpCP = tmpStroke.getControlPoint(0);
|
|
|
|
bool check = areAlmostEqual(new_stroke_cp.back(), tmpCP, 0.01);
|
|
// relaxed check
|
|
assert(check);
|
|
|
|
if (!check) {
|
|
assert(!"Error on procedure!!! Please verify algorithm!!!");
|
|
return 0;
|
|
}
|
|
|
|
// 0 position is already inserted
|
|
for (i = 1; i < head_index; ++i) {
|
|
TThickPoint to_add = tmpStroke.getControlPoint(i);
|
|
new_stroke_cp.push_back(to_add);
|
|
}
|
|
|
|
// now add queue == head cp
|
|
new_stroke_cp.push_back(new_stroke_cp[0]);
|
|
|
|
assert((int)new_stroke_cp.size() == cpCount);
|
|
|
|
if (new_stroke_cp.back() != tmpStroke.getControlPoint(head_index)) {
|
|
assert(!"Error on procedure!!! Please verify algorithm!!!");
|
|
return 0;
|
|
}
|
|
|
|
TStroke *out = new TStroke(new_stroke_cp);
|
|
out->setSelfLoop();
|
|
return out;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* A corner is straight, only if is contained two times
|
|
* in the list of intervals.
|
|
*/
|
|
DVAPI bool ToonzExt::straightCornersDetector(const TStroke *stroke,
|
|
std::vector<double> &corners) {
|
|
ToonzExt::Intervals intervals;
|
|
|
|
assert(corners.empty());
|
|
if (!corners.empty()) corners.clear();
|
|
|
|
if (!ToonzExt::detectStraightIntervals(stroke, intervals)) return false;
|
|
|
|
assert(!intervals.empty() && "Intervals are empty!!!");
|
|
if (intervals.empty()) return false;
|
|
|
|
double first;
|
|
|
|
ToonzExt::Interval prev = intervals[0], curr;
|
|
|
|
if (stroke->isSelfLoop()) first = prev.first;
|
|
|
|
int size = intervals.size();
|
|
for (int i = 1; i < size; ++i) {
|
|
curr = intervals[i];
|
|
if (prev.second == curr.first) corners.push_back(curr.first);
|
|
prev = curr;
|
|
}
|
|
|
|
if (stroke->isSelfLoop() && curr.second == first) corners.push_back(first);
|
|
|
|
return !corners.empty();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::cornersDetector(const TStroke *stroke, int minDegree,
|
|
std::vector<double> &corners) {
|
|
assert(stroke);
|
|
if (!stroke) return false;
|
|
assert(corners.empty());
|
|
if (!corners.empty()) corners.clear();
|
|
|
|
assert(0 <= minDegree && minDegree <= 180);
|
|
|
|
minDegree = normalizeAngle(minDegree);
|
|
|
|
const double minSin = degree2sin(minDegree), minCos = degree2cos(minDegree);
|
|
|
|
assert(0.0 <= minSin && minSin <= 1.0);
|
|
|
|
// first step remove chunks with null lenght
|
|
|
|
const TThickQuadratic *quad1 = 0, *quad2 = 0;
|
|
|
|
UINT chunkCount = stroke->getChunkCount();
|
|
|
|
quad1 = stroke->getChunk(0);
|
|
assert(quad1);
|
|
if (!quad1) return false;
|
|
|
|
bool error = false, check = false;
|
|
|
|
std::set<double> internal_corners;
|
|
|
|
double t;
|
|
|
|
if (curveIsStraight(quad1, t)) {
|
|
if (t != -1) {
|
|
check = mapValueInStroke(stroke, quad1, t, t);
|
|
assert(check);
|
|
if (check) internal_corners.insert(t);
|
|
}
|
|
}
|
|
|
|
for (UINT j = 1; j < chunkCount; j++) {
|
|
quad2 = stroke->getChunk(j);
|
|
if (curveIsStraight(quad2, t)) {
|
|
if (t != -1) {
|
|
check = mapValueInStroke(stroke, quad2, t, t);
|
|
assert(check);
|
|
if (check) internal_corners.insert(t);
|
|
}
|
|
}
|
|
|
|
assert(quad2);
|
|
if (!quad2) error = true;
|
|
|
|
double tmp = stroke->getW(quad2->getP0());
|
|
|
|
// jump zero length curves
|
|
if (!isAlmostZero(quad1->getLength()) &&
|
|
!isAlmostZero(quad2->getLength()) &&
|
|
isThereACornerMinusThan(minCos, minSin, quad1, quad2))
|
|
internal_corners.insert(tmp);
|
|
|
|
if (!isAlmostZero(quad2->getLength())) quad1 = quad2;
|
|
}
|
|
|
|
if (stroke->isSelfLoop() && chunkCount > 0) {
|
|
quad2 = stroke->getChunk(0);
|
|
quad1 = stroke->getChunk(chunkCount - 1);
|
|
|
|
if (isThereACornerMinusThan(minCos, minSin, quad1, quad2))
|
|
internal_corners.insert(0.0);
|
|
} else {
|
|
internal_corners.insert(0.0);
|
|
internal_corners.insert(1.0);
|
|
}
|
|
|
|
if (error) return false;
|
|
|
|
std::copy(internal_corners.begin(), internal_corners.end(),
|
|
std::back_inserter(corners));
|
|
|
|
#ifdef _DEBUG
|
|
double temp = 0;
|
|
for (unsigned int k = 0; k < corners.size(); ++k) {
|
|
assert(corners[k] >= temp);
|
|
temp = corners[k];
|
|
}
|
|
#endif
|
|
|
|
return !corners.empty();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void ToonzExt::cloneStrokeStatus(const TStroke *from, TStroke *to) {
|
|
if (!ToonzExt::isValid(from) || !ToonzExt::isValid(to)) return;
|
|
|
|
to->setId(from->getId());
|
|
to->setSelfLoop(from->isSelfLoop());
|
|
to->setStyle(from->getStyle());
|
|
to->setAverageThickness(from->getAverageThickness());
|
|
|
|
to->invalidate();
|
|
to->enableComputeOfCaches();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::replaceStroke(TStroke *old_stroke, TStroke *new_stroke,
|
|
unsigned int n_, TVectorImageP &vi) {
|
|
if (!ToonzExt::isValid(old_stroke) || !ToonzExt::isValid(new_stroke) || !vi)
|
|
return false;
|
|
|
|
const unsigned int strokesCount = vi->getStrokeCount();
|
|
|
|
assert(n_ <= strokesCount);
|
|
if (n_ > strokesCount) return false;
|
|
|
|
assert(vi->getStroke(n_) == old_stroke);
|
|
if (vi->getStroke(n_) != old_stroke) return false;
|
|
|
|
// stroke is replaced (old stroke is deleted)
|
|
// in vector image
|
|
vi->replaceStroke(n_, new_stroke);
|
|
|
|
int new_id = getStrokeId(new_stroke, vi);
|
|
if (new_id == -1) return false;
|
|
|
|
n_ = new_id;
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::getAllW(const TStroke *stroke, const TPointD &pnt,
|
|
double &dist2, std::vector<double> ¶meters) {
|
|
assert(!"To be finished!!!");
|
|
std::set<double> tmp;
|
|
|
|
assert(stroke);
|
|
if (ToonzExt::isValid(stroke)) return false;
|
|
|
|
double outT, w;
|
|
|
|
const TThickQuadratic *tq = 0;
|
|
|
|
int chunkFound = -1;
|
|
|
|
double distance2;
|
|
|
|
if (stroke->getNearestChunk(pnt, outT, chunkFound, distance2, false)) {
|
|
dist2 = distance2;
|
|
tq = stroke->getChunk(chunkFound);
|
|
if (tq) {
|
|
w = stroke->getW(tq->getPoint(outT));
|
|
if (ToonzExt::isValid(w)) tmp.insert(w);
|
|
}
|
|
}
|
|
|
|
int i, chunkCount = stroke->getChunkCount();
|
|
|
|
for (i = 0; i < chunkCount; i++) {
|
|
if (i != chunkFound) {
|
|
tq = stroke->getChunk(i);
|
|
TPointD tmp_pnt = tq->getPoint(tq->getT(pnt));
|
|
if (areAlmostEqual(tdistance2(tmp_pnt, pnt), dist2)) {
|
|
w = stroke->getW(tmp_pnt);
|
|
if (ToonzExt::isValid(w)) tmp.insert(w);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::copy(tmp.begin(), tmp.end(), std::back_inserter(parameters));
|
|
|
|
return !tmp.empty();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI bool ToonzExt::findNearestCorners(const TStroke *stroke, double w,
|
|
ToonzExt::Interval &out,
|
|
const ToonzExt::Intervals &values,
|
|
double tolerance) {
|
|
out = ToonzExt::Interval(-1.0, -1.0);
|
|
|
|
if (!ToonzExt::isValid(stroke) || !ToonzExt::isValid(w) || values.empty())
|
|
return false;
|
|
|
|
ToonzExt::Interval prev = values[0], curr = prev;
|
|
|
|
if (!stroke->isSelfLoop() && areAlmostEqual(w, prev.first, tolerance)) {
|
|
out = prev;
|
|
return true;
|
|
}
|
|
|
|
const int size = values.size();
|
|
|
|
for (int i = 1; i <= size; ++i) {
|
|
if (i < size)
|
|
curr = values[i];
|
|
else
|
|
curr = values[0];
|
|
|
|
// this case, w is an extreme and needs to be considered
|
|
// the nearest external interval
|
|
if (areAlmostEqual(w, curr.first, tolerance) &&
|
|
(prev.second == curr.first)) {
|
|
if (isWGood(prev.first, w, curr.second, stroke) ||
|
|
(prev.first == curr.second)) {
|
|
out.first = prev.first;
|
|
out.second = curr.second;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// normal case
|
|
if (isWGood(curr.first, w, curr.second, stroke)) {
|
|
out = curr;
|
|
return true;
|
|
}
|
|
|
|
prev = curr;
|
|
}
|
|
|
|
curr = values.back();
|
|
|
|
// last point
|
|
if (!stroke->isSelfLoop() && areAlmostEqual(curr.second, w, tolerance)) {
|
|
out = curr;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DVAPI void ToonzExt::findCorners(const TStroke *stroke,
|
|
ToonzExt::Intervals &corners,
|
|
ToonzExt::Intervals &intervals, int angle,
|
|
double tolerance) {
|
|
assert(stroke && "Stroke is null!!!");
|
|
if (!ToonzExt::isValid(stroke)) return;
|
|
|
|
angle = normalizeAngle(angle);
|
|
|
|
ToonzExt::detectSpireIntervals(stroke, corners, angle);
|
|
|
|
// a corner SPIRE is also a STRAIGHT
|
|
ToonzExt::detectStraightIntervals(stroke, intervals, tolerance);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// End Of File
|
|
//-----------------------------------------------------------------------------
|