#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 length
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
//-----------------------------------------------------------------------------