#include "ext/LinearPotential.h"

#include <tmathutil.h></tmathutil.h>

#include <algorithm></algorithm>

#include "tstroke.h"

using namespace std;

//-----------------------------------------------------------------------------

void ToonzExt::LinearPotential::setParameters_(const TStroke *ref,

											   double par,

											   double al)

{

	ref_ = ref;

	par_ = par;

	actionLength_ = al;

	strokeLength_ = ref->getLength();

	lenghtAtParam_ = ref->getLength(par);

	// lunghezza dal pto di click all'inizio della curva

	leftFactor_ = lenghtAtParam_;

	// lunghezza dal pto di click alla fine

	rightFactor_ = strokeLength_ - lenghtAtParam_;

	// 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::LinearPotential::~LinearPotential()

{

}

//-----------------------------------------------------------------------------

double

ToonzExt::LinearPotential::value_(double value2test) const

{

	assert(0.0 <= value2test &&

		   value2test <= 1.0);

	return this->compute_value(value2test);

}

//-----------------------------------------------------------------------------

// normalization of parameter in range interval

double ToonzExt::LinearPotential::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::LinearPotential::compute_value(double value2test) const

{

	// use

	//

	//  1-x

	//

	double x = 0.0;

	double res = 0.0;

	// lenght  at parameter

	x = ref_->getLength(value2test);

	double tmp_al = actionLength_ * 0.5;

	if (isAlmostZero(par_) ||

		areAlmostEqual(par_, 1.0))

		tmp_al = actionLength_;

	// this is ckecked from wrapper class

	assert(tmp_al != 0.0);

	// compute correct parameter considering offset

	// try to have a square curve like shape

	//

	//  m = x

	//

	if (leftFactor_ == 0.0)

		x = 1.0 - x / tmp_al;

	else if (rightFactor_ == 0.0)

		x = (x - (strokeLength_ - tmp_al)) / tmp_al;

	else {

		if (x <= lenghtAtParam_ &&

			((lenghtAtParam_ - x) <= leftFactor_))

			x = (x - (lenghtAtParam_ - leftFactor_)) / leftFactor_;

		else if (x > lenghtAtParam_ &&

				 ((x - lenghtAtParam_) < rightFactor_))

			x = (rightFactor_ - (x - lenghtAtParam_)) / rightFactor_;

		else

			x = -1;

	}

	if (x < 0.0)

		return 0.0;

	//assert( 0.0 <= x &&

	//  x <= 1.0 + TConsts::epsilon );

	res = x;

	return res;

}

//-----------------------------------------------------------------------------

ToonzExt::Potential *

ToonzExt::LinearPotential::clone()

{

	return new LinearPotential;

}

//-----------------------------------------------------------------------------

//  End Of File

//-----------------------------------------------------------------------------