/////////////////////////////////////////////////////////////////////////////
// Smooth path
/////////////////////////////////////////////////////////////////////////////
void K1999::Smooth(int Step)
{
int prev = ((Divs - Step) / Step) * Step;
int prevprev = prev - Step;
int next = Step;
int nextnext = next + Step;
assert(prev >= 0);
//std::cout << Divs << ", " << Step << ", " << prev << ", " << tx.size() << std::endl;
assert(prev < (int)tx.size());
assert(prev < (int)ty.size());
assert(next < (int)tx.size());
assert(next < (int)ty.size());
for (int i = 0; i <= Divs - Step; i += Step)
{
double ri0 = GetRInverse(prevprev, tx[prev], ty[prev], i);
double ri1 = GetRInverse(i, tx[next], ty[next], nextnext);
double lPrev = Mag(tx[i] - tx[prev], ty[i] - ty[prev]);
double lNext = Mag(tx[i] - tx[next], ty[i] - ty[next]);
double TargetRInverse = (lNext * ri0 + lPrev * ri1) / (lNext + lPrev);
double Security = lPrev * lNext / (8 * SecurityR);
AdjustRadius(prev, i, next, TargetRInverse, Security);
prevprev = prev;
prev = i;
next = nextnext;
nextnext = next + Step;
if (nextnext > Divs - Step)
nextnext = 0;
}
}
static void Smooth(int Step)
{
int prev = ((nSegments - Step) / Step) * Step;
int prevprev = prev - Step;
int next = Step;
int nextnext = next + Step;
for (int i = 0; i <= nSegments - Step; i += Step) {
double ri0 = GetRInverse(prevprev, rlseg[prev].t, i);
double ri1 = GetRInverse(i, rlseg[next].t, nextnext);
double lPrev = (rlseg[i].t-rlseg[prev].t).len();
double lNext = (rlseg[i].t-rlseg[next].t).len();
double TargetRInverse = (lNext * ri0 + lPrev * ri1) / (lNext + lPrev);
double Security = lPrev * lNext / (8 * SecurityR);
AdjustRadius(prev, i, next, TargetRInverse, Security);
prevprev = prev;
prev = i;
next = nextnext;
nextnext = next + Step;
if (nextnext > nSegments - Step)
nextnext = 0;
}
}
static void StepInterpolate(int iMin, int iMax, int Step)
{
int next = (iMax + Step) % nSegments;
if (next > nSegments - Step)
next = 0;
int prev = (((nSegments + iMin - Step) % nSegments) / Step) * Step;
if (prev > nSegments - Step)
prev -= Step;
double ir0 = GetRInverse(prev, rlseg[iMin].t, iMax % nSegments);
double ir1 = GetRInverse(iMin, rlseg[iMax % nSegments].t, next);
for (int k = iMax; --k > iMin;) {
double x = double(k - iMin) / double(iMax - iMin);
double TargetRInverse = x * ir1 + (1 - x) * ir0;
AdjustRadius(iMin, k, iMax % nSegments, TargetRInverse);
}
}
/////////////////////////////////////////////////////////////////////////////
// Interpolate between two control points
/////////////////////////////////////////////////////////////////////////////
void K1999::StepInterpolate(int iMin, int iMax, int Step)
{
int next = (iMax + Step) % Divs;
if (next > Divs - Step)
next = 0;
int prev = (((Divs + iMin - Step) % Divs) / Step) * Step;
if (prev > Divs - Step)
prev -= Step;
double ir0 = GetRInverse(prev, tx[iMin], ty[iMin], iMax % Divs);
double ir1 = GetRInverse(iMin, tx[iMax % Divs], ty[iMax % Divs], next);
for (int k = iMax; --k > iMin;)
{
double x = double(k - iMin) / double(iMax - iMin);
double TargetRInverse = x * ir1 + (1 - x) * ir0;
AdjustRadius(iMin, k, iMax % Divs, TargetRInverse);
}
}
