tahoma2d/toonz/sources/tnzext/NotSimmetricExpPotential.cpp
2016-06-15 15:43:10 +09:00

228 lines
6.7 KiB
C++

#include "ext/NotSimmetricExpPotential.h"
#include <tmathutil.h>
#include <algorithm>
using namespace std;
//-----------------------------------------------------------------------------
namespace {
typedef unary_function<double, double> unary_functionDD;
//---------------------------------------------------------------------------
class mySqr : unary_functionDD {
public:
result_type operator()(argument_type x) { return 1.0 - sq(x); }
};
//---------------------------------------------------------------------------
class myExp : unary_functionDD {
public:
result_type operator()(argument_type x) { return exp(-sq(x)); }
};
//---------------------------------------------------------------------------
struct blender {
double operator()(double a, double b, double t) {
assert(0.0 <= t && t <= 1.0);
return (a * (1.0 - t) + b * t);
}
};
//---------------------------------------------------------------------------
struct blender_2 {
double operator()(double a, double b, double t) {
assert(0.0 <= t && t <= 1.0);
// a(1-t)^2 + 2t*(1-t) + t^2
double one_t = 1.0 - t;
double num = 3.0;
double den = 4.0;
// solution of a(1-t)^2 + P*2t(1-t) + b*t^2 = (a+b)/2
// with t = num/den
double middle =
sq(den) / (2.0 * num) * ((a + b) * 0.5 - (a + sq(num) * b) / sq(den));
return a * sq(one_t) + middle * t * one_t + b * sq(t);
}
};
}
//-----------------------------------------------------------------------------
void ToonzExt::NotSimmetricExpPotential::setParameters_(const TStroke *ref,
double par, double al) {
ref_ = ref;
par_ = par;
actionLength_ = al;
assert(ref_);
strokeLength_ = ref->getLength();
lenghtAtParam_ = ref->getLength(par);
// lunghezza dal pto di click all'inizio della curva
leftFactor_ = min(lenghtAtParam_,
actionLength_ * 0.5); // lenghtAtParam_ / strokeLength_;
// lunghezza dal pto di click alla fine
rightFactor_ = min(strokeLength_ - lenghtAtParam_, actionLength_ * 0.5);
// considero come intervallo di mapping [-range,range].
// 4 ha come valore c.a. 10exp-6
// cioé sposterei un pixel su un movimento di un milione di pixel
range_ = 2.8;
}
//-----------------------------------------------------------------------------
ToonzExt::NotSimmetricExpPotential::~NotSimmetricExpPotential() {}
//-----------------------------------------------------------------------------
double ToonzExt::NotSimmetricExpPotential::value_(double value2test) const {
assert(0.0 <= value2test && value2test <= 1.0);
return this->compute_value(value2test);
}
//-----------------------------------------------------------------------------
// normalization of parameter in range interval
double ToonzExt::NotSimmetricExpPotential::compute_shape(
double value2test) const {
double x = ref_->getLength(value2test);
double shape = this->actionLength_ * 0.5;
if (isAlmostZero(shape)) shape = 1.0;
x = ((x - lenghtAtParam_) * range_) / shape;
return x;
}
//-----------------------------------------------------------------------------
double ToonzExt::NotSimmetricExpPotential::compute_value(
double value2test) const {
myExp me;
mySqr ms;
blender op;
// usually use the form below
// ( ) 2
// ( (x - l)*range_ )
// - (--------------- )
// ( factor )
// l,r
// e
//
// where factor is computed like in constructor
// on extremes use
// 2
// 1-x
//
// when is near to extreme uses a mix notation
double x = 0.0;
double res = 0.0;
// lenght at parameter
x = ref_->getLength(value2test);
const double tolerance = 2.0; // need to be pixel based
// if is an extreme
if (max(lenghtAtParam_, 0.0) < tolerance ||
max(strokeLength_ - lenghtAtParam_, 0.0) < tolerance) {
double tmp_al = actionLength_ * 0.5;
// compute correct parameter considering offset
// try to have a square curve like shape
//
// 2
// m = x
//
if (leftFactor_ <= tolerance)
x = 1.0 - x / tmp_al;
else
x = (x - (strokeLength_ - tmp_al)) / tmp_al;
if (x < 0.0) return 0.0;
assert(0.0 <= x && x <= 1.0 + TConsts::epsilon);
res = sq(x);
} else // when is not an extreme
{
double lenght_at_value2test = ref_->getLength(value2test);
const double min_level = 0.01;
// if check a parameter over click point
if (lenght_at_value2test >= lenghtAtParam_) {
// check if extreme can be moved from this parameter configuration
double tmp_x = this->compute_shape(1.0);
double tmp_res = me(tmp_x);
if (tmp_res > min_level) {
// please note that in this case
// lenghtAtParam_ + rightFactor_ == strokeLength_
// (by ctor).
x = (lenght_at_value2test - lenghtAtParam_) / rightFactor_;
assert(0.0 <= x && x <= 1.0);
// then movement use another shape
double exp_val = me(x * range_);
double how_many_of_shape =
(strokeLength_ - lenghtAtParam_) / (actionLength_ * 0.5);
assert(0.0 <= how_many_of_shape && how_many_of_shape <= 1.0);
// return ms(x);
return op(ms(x), exp_val, how_many_of_shape);
}
} else {
// leftFactor_
double tmp_x = this->compute_shape(0.0);
double tmp_res = me(tmp_x);
if (tmp_res > min_level) {
double x = lenght_at_value2test / leftFactor_;
assert(0.0 <= x && x <= 1.0);
// then movement use another shape
double diff = x - 1.0;
double exp_val = me(diff * range_);
double how_many_of_shape = lenghtAtParam_ / (actionLength_ * 0.5);
assert(0.0 <= how_many_of_shape && how_many_of_shape <= 1.0);
// return ms(diff);
return op(ms(diff), exp_val, how_many_of_shape);
}
}
// default behaviour is an exp
x = this->compute_shape(value2test);
res = me(x);
}
return res;
}
//-----------------------------------------------------------------------------
ToonzExt::Potential *ToonzExt::NotSimmetricExpPotential::clone() {
return new NotSimmetricExpPotential;
}
// DEL double ToonzExt::NotSimmetricExpPotential::gradient(double value2test)
// const
// DEL {
// DEL assert(false);
// DEL //double x = this->compute_shape(value2test);
// DEL //double res = -(2.0*range_) / actionLength_ * x * exp(-sq(x));
// DEL //return res;
// DEL return 0;
// DEL }
//-----------------------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------------------