tgt::vec3 Flow3D::lookupFlowTrilinear(const tgt::vec3& r) const {
tgt::ivec3 ir1(static_cast<int>(floorf(r.x)), static_cast<int>(floorf(r.y)),
static_cast<int>(floorf(r.z)));
ir1 = clampToFlowDimensions(ir1);
tgt::ivec3 ir2 = clampToFlowDimensions(ir1 + tgt::ivec3(1));
// interpolate in x-direction
//
tgt::vec3 v1 = linearInterpolation(r.x, ir1, 0);
tgt::vec3 v2 = linearInterpolation(r.x, tgt::ivec3(0, ir2.y, ir1.z), 0);
tgt::vec3 v3 = linearInterpolation(r.x, tgt::ivec3(0, ir1.y, ir2.z), 0);
tgt::vec3 v4 = linearInterpolation(r.x, ir2, 0);
// interpolates value from x-direction interpolation in y-direction
//
float fintegral = 0.0f;
float b = modff(r.y, &fintegral);
float a = 1.0f - b;
tgt::vec3 v5 = ((v1 * a) + (v2 * b));
tgt::vec3 v6 = ((v3 * a) + (v4 * b));
// interpolate values from y-direction interpolation in z-drection
//
b = modff(r.z, &fintegral);
a = 1.0f - b;
return ((v5 * a) + (v6 * b));
}
//Gouraud shading, uses linear interpolation to determine the color
int Graph::drawLine( Point p1, Point p2){ // should have named it scanLine, as I only use this function for horizontal line drawing
if(p1.x == p2.x){ //vertical line
int y,y_end;
if(p1.y <= p2.y){
y = p1.y;
y_end = p2.y;
}else{
y = p2.y;
y_end = p1.y;
}
for(; y<=y_end; y++)
drawPixel(p1.x, y, linearInterpolation(y, p1.y, p2.y, p1.normalizedIntensity, p2.normalizedIntensity) );
return 0;
}
else if(p1.y == p2.y){ // horizontal line
int x, x_end;
if(p1.x <= p2.x){
x = p1.x;
x_end = p2.x;
}
else{
x = p2.x;
x_end = p1.x;
}
for(; x <= x_end; x++)
drawPixel(x, p1.y, linearInterpolation(x, p1.x, p2.x, p1.normalizedIntensity, p2.normalizedIntensity) );
return 0;
}
DPRINT("################################################SLANTED LINE\n");
bresenham(p1, p2);
return 0;
}
void GraphData::render( ImageObject& img, const Rect& r )
{
int pixel = 0;
int old_pixel = 0;
for(int i = 0; i < values-1; i++)
{
if(pInterpolation == GRAPH_INTERPOLATION_NONE)
{
img.putPixel(data_pixels[i][0], (int)getValue(i, 1), lineColor);
}
else
{
int spacing = (data_pixels[i+1][0]-data_pixels[i][0]);
for(int i2 = 0; i2 < spacing; i2++)
{
float pos = ((float)i2/(float)(data_pixels[i+1][0]-data_pixels[i][0]));
//TODO: Select interpolation type
if(pInterpolation == GRAPH_INTERPOLATION_SPLINE)
{
pixel = (int)splineInterpolation(pos, getValue(i-2,1), getValue(i-1, 1), getValue(i, 1), getValue(i+1, 1), getValue(i+2, 1), getValue(i+3, 1));
}
else if(pInterpolation == GRAPH_INTERPOLATION_CUBIC)
{
pixel = (int)linearInterpolation(pos, getValue(i, 1), getValue(i+1, 1)) + 10;
}
else
{
pixel = (int)linearInterpolation(pos, getValue(i, 1), getValue(i+1, 1));
}
// Going up
if(pixel > old_pixel)
{
for(int apa = abs(pixel-old_pixel); apa >= 0; apa--)
{
img.putPixel(data_pixels[i][0]+i2, pixel-apa, lineColor);
}
}
// Going down
else if(old_pixel > pixel)
{
for(int apa = abs(pixel-old_pixel); apa >= 0; apa--)
{
img.putPixel(data_pixels[i][0]+i2, pixel+apa-1, lineColor);
}
}
// Same value as previous sample
else
{
img.putPixel(data_pixels[i][0]+i2, pixel, lineColor);
img.putPixel(data_pixels[i][0]+i2, pixel-1, lineColor);
}
old_pixel = pixel;
}
}
}
}
double MiscibilityLiveOil::miscible_oil(double press, const surfvol_t& surfvol,
int item, bool deriv) const
{
int section;
double R = linearInterpolation(saturated_oil_table_[0],
saturated_oil_table_[3],
press, section);
double maxR = (surfvol[Liquid] == 0.0) ? 0.0 : surfvol[Vapour]/surfvol[Liquid];
if (deriv) {
if (R < maxR ) { // Saturated case
return linearInterpolationDerivative(saturated_oil_table_[0],
saturated_oil_table_[item],
press);
} else { // Undersaturated case
int is = tableIndex(saturated_oil_table_[3], maxR);
double w = (maxR - saturated_oil_table_[3][is]) /
(saturated_oil_table_[3][is+1] - saturated_oil_table_[3][is]);
ASSERT(undersat_oil_tables_[is][0].size() >= 2);
ASSERT(undersat_oil_tables_[is+1][0].size() >= 2);
double val1 =
linearInterpolationDerivative(undersat_oil_tables_[is][0],
undersat_oil_tables_[is][item],
press);
double val2 =
linearInterpolationDerivative(undersat_oil_tables_[is+1][0],
undersat_oil_tables_[is+1][item],
press);
double val = val1 + w*(val2 - val1);
return val;
}
} else {
if (R < maxR ) { // Saturated case
return linearInterpolation(saturated_oil_table_[0],
saturated_oil_table_[item],
press);
} else { // Undersaturated case
// Interpolate between table sections
int is = tableIndex(saturated_oil_table_[3], maxR);
double w = (maxR - saturated_oil_table_[3][is]) /
(saturated_oil_table_[3][is+1] - saturated_oil_table_[3][is]);
ASSERT(undersat_oil_tables_[is][0].size() >= 2);
ASSERT(undersat_oil_tables_[is+1][0].size() >= 2);
double val1 =
linearInterpolation(undersat_oil_tables_[is][0],
undersat_oil_tables_[is][item],
press);
double val2 =
linearInterpolation(undersat_oil_tables_[is+1][0],
undersat_oil_tables_[is+1][item],
press);
double val = val1 + w*(val2 - val1);
return val;
}
}
}
//------------------------------------------------------------------------------
f32 biLinearInterpolationSmooth(
const f32 x0y0, const f32 x1y0,
const f32 x0y1, const f32 x1y1,
const f32 x, const f32 y)
{
const f32 tx = smoothCurve(x);
const f32 ty = smoothCurve(y);
const f32 u = linearInterpolation(x0y0,x1y0, tx);
const f32 v = linearInterpolation(x0y1,x1y1, tx);
return linearInterpolation(u,v,ty);
}
float FETurbulence::noise2D(int channel, PaintingData& paintingData, const FloatPoint& noiseVector)
{
struct Noise {
int noisePositionIntegerValue;
float noisePositionFractionValue;
Noise(float component)
{
float position = component + s_perlinNoise;
noisePositionIntegerValue = static_cast<int>(position);
noisePositionFractionValue = position - noisePositionIntegerValue;
}
};
Noise noiseX(noiseVector.x());
Noise noiseY(noiseVector.y());
float* q;
float sx, sy, a, b, u, v;
// If stitching, adjust lattice points accordingly.
if (m_stitchTiles) {
checkNoise(noiseX.noisePositionIntegerValue, paintingData.wrapX, paintingData.width);
checkNoise(noiseY.noisePositionIntegerValue, paintingData.wrapY, paintingData.height);
}
noiseX.noisePositionIntegerValue &= s_blockMask;
noiseY.noisePositionIntegerValue &= s_blockMask;
int latticeIndex = paintingData.latticeSelector[noiseX.noisePositionIntegerValue];
int nextLatticeIndex = paintingData.latticeSelector[(noiseX.noisePositionIntegerValue + 1) & s_blockMask];
sx = smoothCurve(noiseX.noisePositionFractionValue);
sy = smoothCurve(noiseY.noisePositionFractionValue);
// This is taken 1:1 from SVG spec: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement.
int temp = paintingData.latticeSelector[latticeIndex + noiseY.noisePositionIntegerValue];
q = paintingData.gradient[channel][temp];
u = noiseX.noisePositionFractionValue * q[0] + noiseY.noisePositionFractionValue * q[1];
temp = paintingData.latticeSelector[nextLatticeIndex + noiseY.noisePositionIntegerValue];
q = paintingData.gradient[channel][temp];
v = (noiseX.noisePositionFractionValue - 1) * q[0] + noiseY.noisePositionFractionValue * q[1];
a = linearInterpolation(sx, u, v);
temp = paintingData.latticeSelector[latticeIndex + noiseY.noisePositionIntegerValue + 1];
q = paintingData.gradient[channel][temp];
u = noiseX.noisePositionFractionValue * q[0] + (noiseY.noisePositionFractionValue - 1) * q[1];
temp = paintingData.latticeSelector[nextLatticeIndex + noiseY.noisePositionIntegerValue + 1];
q = paintingData.gradient[channel][temp];
v = (noiseX.noisePositionFractionValue - 1) * q[0] + (noiseY.noisePositionFractionValue - 1) * q[1];
b = linearInterpolation(sx, u, v);
return linearInterpolation(sy, a, b);
}
int Graph::bresenham(Point pt1, Point pt2 ){ //overloaded bresenham, each points has its own color
Point p1 = pt1;
Point p2 = pt2;
int x, y, x_end, y_end, p;
int dx = (p2.x - p1.x), dy = (p2.y - p1.y); //for determining sign of slope
bool steep = false;
float m = (float)dy/(float)dx ; //find the slope first
DPRINT("The slope is %.2f\n", m);
bool positive_slope;
if( m >= 0 ) // positive slope
positive_slope = true;
else
positive_slope = false;
if( fabs(m) <= 1 ){ //shallow
steep = false;
}
else{ //steep
steep = true;
swapXY(&p1);
swapXY(&p2);
}
determineStartAndEndPoints(p1, p2, &x, &y, &x_end, &y_end);
//DPRINT("x: %d,\ty: %d,\tx_end: %d,\ty_end:%d\n", x, y, x_end, y_end);
dx = abs(x_end - x);
dy = abs(y_end - y);
//draw first point
if(steep)
drawPixel(y,x, linearInterpolation(x, p1.x, p2.x, p1.normalizedIntensity, p2.normalizedIntensity ) );//x and y was swapped before
else
drawPixel(x,y, linearInterpolation(y, p1.y, p2.y, p1.normalizedIntensity, p2.normalizedIntensity ) );
p = 2 * dy - dx;
for( ; x < x_end; ){
x++;
if( p >= 0){ // if d1 - d2 >= 0, means d2 is shorter, so advance y one level up
positive_slope? y++:y--;
p = p + 2*dy - 2*dx;
}
else // if d1 - d2 < 0; means d1 is shorter, so no change of y;
p = p + 2*dy;
if(steep)
drawPixel(y,x, linearInterpolation(x, p1.x, p2.x, p1.normalizedIntensity, p2.normalizedIntensity ) );//x and y was swapped before
else
drawPixel(x,y, linearInterpolation(y, p1.y, p2.y, p1.normalizedIntensity, p2.normalizedIntensity ) );
}
return 0;
}
void testInterpolation(){
double *fx, **a, *x;
int dims=2;
x=allocateDoubleVector(dims);
a=allocateDoubleMatrix(dims,2);
fx=allocateDoubleVector(dims*2);
x[0]=0.25;
x[1]=0.4;
a[0][0]=0;
a[0][1]=1;
a[1][0]=0;
a[1][1]=1;
fx[0]=1;
fx[1]=3;
fx[2]=2;
fx[3]=4;
printf("\nInterpolation\n");
printf("%f\n",linearInterpolation(fx, a, x, dims));
}
qreal SprayBrush::rotationAngle(KisRandomSourceSP randomSource)
{
qreal rotation = 0.0;
if (m_shapeDynamicsProperties->fixedRotation) {
rotation = deg2rad(m_shapeDynamicsProperties->fixedAngle);
}
if (m_shapeDynamicsProperties->randomRotation) {
qreal randomValue = 0.0;
if (m_properties->gaussian) {
randomValue = qBound<qreal>(0.0, randomSource->generateGaussian(0.0, 0.5), 1.0);
} else {
randomValue = randomSource->generateNormalized();
}
rotation =
linearInterpolation(rotation ,
M_PI * 2.0 * randomValue,
m_shapeDynamicsProperties->randomRotationWeight);
}
return rotation;
}
inline double
NonuniformTableLinear<T>
::inverse(const double y) const
{
if (y_values_.front() < y_values_.back()) {
return linearInterpolation(y_values_, x_values_, y);
} else {
if (y_values_reversed_.empty()) {
y_values_reversed_ = y_values_;
std::reverse(y_values_reversed_.begin(), y_values_reversed_.end());
ASSERT(isNondecreasing(y_values_reversed_.begin(), y_values_reversed_.end()));
x_values_reversed_ = x_values_;
std::reverse(x_values_reversed_.begin(), x_values_reversed_.end());
}
return linearInterpolation(y_values_reversed_, x_values_reversed_, y);
}
}
T interpolatedNoise3D(const T x, const T y, const T z)
{
int integerX = static_cast<int>(x);
int integerY = static_cast<int>(y);
int integerZ = static_cast<int>(z);
T fractionalX = x - integerX;
T fractionalY = y - integerY;
T fractionalZ = z - integerZ;
T v1 = smoothNoise3D(integerX, integerY, integerZ);
T v2 = smoothNoise3D(integerX + 1, integerY, integerZ);
T v3 = smoothNoise3D(integerX, integerY + 1, integerZ);
T v4 = smoothNoise3D(integerX + 1, integerY + 1, integerZ);
T v5 = smoothNoise3D(integerX, integerY, integerZ + 1);
T v6 = smoothNoise3D(integerX + 1, integerY, integerZ + 1);
T v7 = smoothNoise3D(integerX, integerY + 1, integerZ + 1);
T v8 = smoothNoise3D(integerX + 1, integerY + 1, integerZ + 1);
T i1 = linearInterpolation(v1, v2, fractionalX);
T i2 = linearInterpolation(v3, v4, fractionalX);
T i3 = linearInterpolation(v5, v6, fractionalX);
T i4 = linearInterpolation(v7, v8, fractionalX);
T lvl0 = linearInterpolation(i1, i2, fractionalY);
T lvl1 = linearInterpolation(i3, i4, fractionalY);
return linearInterpolation(lvl0, lvl1, fractionalZ);
}
T interpolatedNoise2D(const T x, const T y)
{
int integerX = static_cast<int>(x);
T fractionalX = x - integerX;
int integerY = static_cast<int>(y);
T fractionalY = y - integerY;
T v1 = smoothedNoise2D(integerX, integerY);
T v2 = smoothedNoise2D(integerX + 1, integerY);
T v3 = smoothedNoise2D(integerX, integerY + 1);
T v4 = smoothedNoise2D(integerX + 1, integerY + 1);
T i1 = linearInterpolation(v1, v2, fractionalX);
T i2 = linearInterpolation(v3, v4, fractionalX);
return linearInterpolation(i1 , i2 , fractionalY);
}
T interpolatedNoise1D(const T x)
{
int integerX = static_cast<int>(x);
T fractionalX = x - integerX;
T v1 = smoothedNoise1D(integerX);
T v2 = smoothedNoise1D(integerX + 1);
return linearInterpolation(v1,v2,fractionalX);
}
void EPtomo2010subMod(int xInd, int yInd, int zInd, globalDataValues *globalValues, gridStruct *location, depInterpVals *EPtomoData)
/*
Purpose: calculate the rho vp and vs values at a single lat long point for all the depths within this velocity submodel
Input variables:
depths - pointer to a struct containing the references to which points lie within this velocity sub-model layer
veloSubModNum - the reference number of this velocity sub-model
xInd - the indice of the longitude point
yInd - the indice of the latitude point
EPtomoData - pointer to the Eberhart-Phillips 2010 tomography data
Output variables:
values - struct containing the vp vs and rho values for all points within this velo sub-model
*/
{
int count = 0;
double p1, p2;
double Rho1, Rho2, Vp1, Vp2, Vs1, Vs2;
// find the indice of the first "surface" above the data point in question
while(location->Z[zInd]<EPtomoData->deps[count]*1000)
{
count += 1;
}
// loop over the depth points and obtain the vp vs and rho values using interpolation between "surfaces"
p1 = EPtomoData->deps[count-1]*1000;
p2 = EPtomoData->deps[count]*1000;
Rho1 = EPtomoData->Rho[count-1][xInd][yInd];
Rho2 = EPtomoData->Rho[count][xInd][yInd];
Vs1 = EPtomoData->Vs[count-1][xInd][yInd];
Vs2 = EPtomoData->Vs[count][xInd][yInd];
Vp1 = EPtomoData->Vp[count-1][xInd][yInd];
Vp2 = EPtomoData->Vp[count][xInd][yInd];
globalValues->Rho[xInd][yInd][zInd] = linearInterpolation(p1, p2, Rho1, Rho2, location->Z[zInd]);
globalValues->Vs[xInd][yInd][zInd] = linearInterpolation(p1, p2, Vs1, Vs2, location->Z[zInd]);
globalValues->Vp[xInd][yInd][zInd] = linearInterpolation(p1, p2, Vp1, Vp2, location->Z[zInd]);
}
qreal SprayBrush::rotationAngle()
{
qreal rotation = 0.0;
if (m_shapeDynamicsProperties->fixedRotation) {
rotation = deg2rad(m_shapeDynamicsProperties->fixedAngle);
}
if (m_shapeDynamicsProperties->randomRotation) {
if (m_properties->gaussian) {
rotation = linearInterpolation(rotation , M_PI * 2.0 * qBound<qreal>(0.0, m_rand->nextGaussian(0.0, 0.50) , 1.0), m_shapeDynamicsProperties->randomRotationWeight);
}
else {
rotation = linearInterpolation(rotation, M_PI * 2.0 * drand48(), m_shapeDynamicsProperties->randomRotationWeight);
}
}
return rotation;
}
// Vaporised oil-gas ratio derivative
double MiscibilityLiveGas::dRdp(int /*region*/, double press, const surfvol_t& surfvol) const
{
double R = linearInterpolation(saturated_gas_table_[0],
saturated_gas_table_[3], press);
double maxR = surfvol[Liquid]/surfvol[Vapour];
if (R < maxR ) { // Saturated case
return linearInterpolationDerivative(saturated_gas_table_[0],
saturated_gas_table_[3],
press);
} else {
return 0.0; // Undersaturated case
}
}
double MiscibilityLiveOil::evalR(double press, const surfvol_t& surfvol) const
{
if (surfvol[Vapour] == 0.0) {
return 0.0;
}
double R = linearInterpolation(saturated_oil_table_[0],
saturated_oil_table_[3], press);
double maxR = surfvol[Vapour]/surfvol[Liquid];
if (R < maxR ) { // Saturated case
return R;
} else {
return maxR; // Undersaturated case
}
}
void Spline::smoothHandles()
{
for (unsigned int v{ 0 }; v < m_vertices.size() - 1; ++v)
{
const sf::Vector2f p1{ m_vertices[v].position };
const sf::Vector2f p2{ m_vertices[v + 1].position };
sf::Vector2f p0{ p1 };
sf::Vector2f p3{ p2 };
if (v > 0)
p0 = m_vertices[v - 1].position;
if (v < m_vertices.size() - 2)
p3 = m_vertices[v + 2].position;
const sf::Vector2f m0{ linearInterpolation(p0, p1, 0.5f) };
const sf::Vector2f m1{ linearInterpolation(p1, p2, 0.5f) };
const sf::Vector2f m2{ linearInterpolation(p2, p3, 0.5f) };
const float p01{ vectorLength(p1 - p0) };
const float p12{ vectorLength(p2 - p1) };
const float p23{ vectorLength(p3 - p2) };
float proportion0{ 0.f };
float proportion1{ 0.f };
if (p01 + p12 != 0.f)
proportion0 = p01 / (p01 + p12);
if (p12 + p23 != 0.f)
proportion1 = p12 / (p12 + p23);
const sf::Vector2f q0{ linearInterpolation(m0, m1, proportion0) };
const sf::Vector2f q1{ linearInterpolation(m1, m2, proportion1) };
m_vertices[v].frontHandle = m1 - q0;
m_vertices[v + 1].backHandle = m1 - q1;
}
m_vertices.front().backHandle = { 0.f, 0.f };
m_vertices.back().frontHandle = { 0.f, 0.f };
}
void Spline::update()
{
if (m_vertices.size() == 0)
{
m_sfmlVertices.clear();
m_handlesVertices.clear();
return;
}
const unsigned int pointsPerVertex{ m_interpolationSteps + 1u };
m_sfmlVertices.resize(((m_vertices.size() - 1) * pointsPerVertex) + 1);
m_handlesVertices.resize((m_vertices.size()) * 4);
std::vector<sf::Vertex>::iterator itHandle = m_handlesVertices.begin();
for (std::vector<Vertex>::iterator begin = m_vertices.begin(), end = m_vertices.end(), it = begin; it != end; ++it)
{
itHandle->color = sf::Color(255, 255, 128, 32);
itHandle++->position = it->position;
itHandle->color = sf::Color(0, 255, 0, 128);
itHandle++->position = it->position + it->backHandle;
itHandle->color = sf::Color(255, 255, 128, 32);
itHandle++->position = it->position;
itHandle->color = sf::Color(0, 255, 0, 128);
itHandle++->position = it->position + it->frontHandle;
std::vector<sf::Vertex>::iterator itSfml = m_sfmlVertices.begin() + (it - begin) * pointsPerVertex;
if (it != end - 1)
{
for (unsigned int i{ 0u }; i < pointsPerVertex; ++i)
{
if (m_useBezier)
itSfml->position = bezierInterpolation(it->position, (it + 1)->position, it->frontHandle, (it + 1)->backHandle, static_cast<float>(i) / pointsPerVertex);
else
itSfml->position = linearInterpolation(it->position, (it + 1)->position, static_cast<float>(i) / pointsPerVertex);
itSfml->color = m_color;
++itSfml;
}
}
else
{
itSfml->position = it->position;
itSfml->color = m_color;
}
}
}
/**
* Get the value of the function at x, return a quiet NAN if x is not in the definiton domain.
**/
virtual double _function(double x) const override
{
if ((_tab == nullptr) || (_len == 0)) return std::numeric_limits<double>::quiet_NaN();
if (!((x >= _minDomain) && (x<=_maxDomain))) return std::numeric_limits<double>::quiet_NaN();
double _e = (_maxDomain - _minDomain) / _len;
if (!((_e >= DBL_MIN * 2) && (_e <= DBL_MAX / 2.0))) return std::numeric_limits<double>::quiet_NaN();
int t = interpolationMethod();
if (t == INTERPOLATION_NONE)
{
size_t n = (size_t)((x - _minDomain) / _e);
if (n >= _len) return std::numeric_limits<double>::quiet_NaN();
double y;
try { y = (double)_tab[n]; } catch (...) { y = std::numeric_limits<double>::quiet_NaN(); }
return y;
}
if (t == INTERPOLATION_LINEAR)
{
size_t n = (size_t)((x - _minDomain) / _e);
if (n >= _len) std::numeric_limits<double>::quiet_NaN();
double x1 = _minDomain + n*_e;
double x2 = x1 + _e;
double y1 = std::numeric_limits<double>::quiet_NaN();
double y2 = std::numeric_limits<double>::quiet_NaN();
try { y1 = (double)_tab[n]; } catch (...) { y1 = std::numeric_limits<double>::quiet_NaN(); }
try { y2 = (n+1 >= _len) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n + 1]); } catch (...) { y2 = std::numeric_limits<double>::quiet_NaN(); }
return linearInterpolation(x, fVec2(x1, y1), fVec2(x2, y2));
}
size_t n = (size_t)((x - _minDomain) / _e);
if (n >= _len) std::numeric_limits<double>::quiet_NaN();
double x1 = _minDomain + n*_e;
double x0 = x1 - _e;
double x2 = x1 + _e;
double x3 = x2 + _e;
double y0 = std::numeric_limits<double>::quiet_NaN();
double y1 = std::numeric_limits<double>::quiet_NaN();
double y2 = std::numeric_limits<double>::quiet_NaN();
double y3 = std::numeric_limits<double>::quiet_NaN();
try { y0 = (n == 0) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n - 1]); } catch (...) { y0 = std::numeric_limits<double>::quiet_NaN(); }
try { y1 = (double)_tab[n]; } catch (...) { y1 = std::numeric_limits<double>::quiet_NaN(); }
try { y2 = (n + 1 >= _len) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n + 1]); } catch (...) { y2 = std::numeric_limits<double>::quiet_NaN(); }
try { y3 = (n + 2 >= _len) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n + 2]); } catch (...) { y3 = std::numeric_limits<double>::quiet_NaN(); }
if (t == INTERPOLATION_CUBIC) return cubicInterpolation(x, fVec2(x0, y0), fVec2(x1, y1), fVec2(x2, y2), fVec2(x3, y3));
return monotoneCubicInterpolation(x, fVec2(x0, y0), fVec2(x1, y1), fVec2(x2, y2), fVec2(x3, y3));
}
void MiscibilityLiveOil::evalRDeriv(const double press, const surfvol_t& surfvol,
double& R, double& dRdp) const
{
if (surfvol[Vapour] == 0.0) {
R = 0.0;
dRdp = 0.0;
return;
}
R = linearInterpolation(saturated_oil_table_[0],
saturated_oil_table_[3], press);
double maxR = surfvol[Vapour]/surfvol[Liquid];
if (R < maxR ) {
// Saturated case
dRdp = linearInterpolationDerivative(saturated_oil_table_[0],
saturated_oil_table_[3],
press);
} else {
// Undersaturated case
R = maxR;
dRdp = 0.0;
}
}
float SimpleJetCorrectionUncertainty::uncertaintyBin(unsigned fBin, float fY, bool fDirection) const
{
if (fBin >= mParameters->size())
//throw cms::Exception("SimpleJetCorrectionUncertainty")<<" wrong bin: "<<fBin<<": only "<<mParameters->size()<<" are available";
handleError("SimpleJetCorrectionUncertainty"," wrong bin");
const std::vector<float>& p = mParameters->record(fBin).parameters();
if ((p.size() % 3) != 0)
//throw cms::Exception ("SimpleJetCorrectionUncertainty")<<"wrong # of parameters: multiple of 3 expected, "<<p.size()<< " got";
handleError("SimpleJetCorrectionUncertainty"," wrong # of parameters: multiple of 3 expected");
std::vector<float> yGrid,value;
unsigned int N = p.size()/3;
float result = -1.0;
for(unsigned i=0;i<N;i++)
{
unsigned ind = 3*i;
yGrid.push_back(p[ind]);
if (fDirection)// true = UP
value.push_back(p[ind+1]);
else // false = DOWN
value.push_back(p[ind+2]);
}
if (fY <= yGrid[0])
result = value[0];
else if (fY >= yGrid[N-1])
result = value[N-1];
else
{
int bin = findBin(yGrid,fY);
float vx[2],vy[2];
for(int i=0;i<2;i++)
{
vx[i] = yGrid[bin+i];
vy[i] = value[bin+i];
}
result = linearInterpolation(fY,vx,vy);
}
return result;
}
std::vector<float> PdfTransfer::SinglePdfTransfer(Histogram *input, Histogram *palette) {
/*float *original = new float[ bin_count + 3];
float *target = new float[ bin_count + 3];*/
std::vector<float> original(bin_count + 1);
std::vector<float> target(bin_count + 1);
unsigned int globalIC = input->getGlobalCounter();
unsigned int globalTC = palette->getGlobalCounter();
std::vector<float> finalO(bin_count + 3);
std::vector<float> finalT(bin_count + 3);
std::vector<float> values(bin_count + 3);
//to help maintain the interpolation correct
finalO[0] = 0;
original[0] = (float) input[0].getCounter();
finalO[1] = original[0] / globalIC;
finalO[bin_count + 2] = (float) bin_count + 1;
finalT[0] = 0;
target[0] = (float) palette[0].getCounter();
finalT[1] = target[0] / globalTC;
finalT[bin_count + 2] = (float) bin_count + 1;
for (unsigned int i = 1; i <= bin_count; ++i) {
original[i] = original[i - 1] + input[i].getCounter();
finalO[i + 1] = original[i] / globalIC;
target[i] = target[i - 1] + palette[i].getCounter();
finalT[i + 1] = target[i] / globalTC;
}
//populate values
values[0] = 0.0;
for (unsigned int i = 1; i < bin_count + 3; ++i) {
values[i] = (float) i - 1;
}
return linearInterpolation(finalT, values, finalO);
}
void SprayBrush::paint(KisPaintDeviceSP dab, KisPaintDeviceSP source,
const KisPaintInformation& info, qreal rotation, qreal scale,
const KoColor &color, const KoColor &bgColor)
{
// initializing painter
if (!m_painter) {
m_painter = new KisPainter(dab);
m_painter->setFillStyle(KisPainter::FillStyleForegroundColor);
m_painter->setMaskImageSize(m_shapeProperties->width, m_shapeProperties->height);
m_dabPixelSize = dab->colorSpace()->pixelSize();
if (m_colorProperties->useRandomHSV) {
m_transfo = dab->colorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
}
m_brushQImage = m_shapeProperties->image;
if (!m_brushQImage.isNull()) {
m_brushQImage = m_brushQImage.scaled(m_shapeProperties->width, m_shapeProperties->height);
}
m_imageDevice = new KisPaintDevice(dab->colorSpace());
}
qreal x = info.pos().x();
qreal y = info.pos().y();
KisRandomAccessorSP accessor = dab->createRandomAccessorNG(qRound(x), qRound(y));
Q_ASSERT(color.colorSpace()->pixelSize() == dab->pixelSize());
m_inkColor = color;
KisCrossDeviceColorPicker colorPicker(source, m_inkColor);
// apply size sensor
m_radius = m_properties->radius * scale;
// jitter movement
if (m_properties->jitterMovement) {
x = x + ((2 * m_radius * drand48()) - m_radius) * m_properties->amount;
y = y + ((2 * m_radius * drand48()) - m_radius) * m_properties->amount;
}
// this is wrong for every shape except pixel and anti-aliased pixel
if (m_properties->useDensity) {
m_particlesCount = (m_properties->coverage * (M_PI * m_radius * m_radius));
}
else {
m_particlesCount = m_properties->particleCount;
}
QHash<QString, QVariant> params;
qreal nx, ny;
int ix, iy;
qreal angle;
qreal length;
qreal rotationZ = 0.0;
qreal particleScale = 1.0;
bool shouldColor = true;
if (m_colorProperties->fillBackground) {
m_painter->setPaintColor(bgColor);
paintCircle(m_painter, x, y, m_radius);
}
QTransform m;
m.reset();
m.rotateRadians(-rotation + deg2rad(m_properties->brushRotation));
m.scale(m_properties->scale, m_properties->scale);
for (quint32 i = 0; i < m_particlesCount; i++) {
// generate random angle
angle = drand48() * M_PI * 2;
// generate random length
if (m_properties->gaussian) {
length = qBound<qreal>(0.0, m_rand->nextGaussian(0.0, 0.50) , 1.0);
}
else {
length = drand48();
}
if (m_shapeDynamicsProperties->enabled) {
// rotation
rotationZ = rotationAngle();
if (m_shapeDynamicsProperties->followCursor) {
rotationZ = linearInterpolation(rotationZ, angle, m_shapeDynamicsProperties->followCursorWeigth);
}
if (m_shapeDynamicsProperties->followDrawingAngle) {
rotationZ = linearInterpolation(rotationZ, info.drawingAngle(), m_shapeDynamicsProperties->followDrawingAngleWeight);
}
// random size - scale
if (m_shapeDynamicsProperties->randomSize) {
particleScale = drand48();
}
}
// generate polar coordinate
nx = (m_radius * cos(angle) * length);
ny = (m_radius * sin(angle) * length);
// compute the height of the ellipse
ny *= m_properties->aspect;
// transform
m.map(nx, ny, &nx, &ny);
// color transformation
if (shouldColor) {
if (m_colorProperties->sampleInputColor) {
colorPicker.pickOldColor(nx + x, ny + y, m_inkColor.data());
}
// mix the color with background color
if (m_colorProperties->mixBgColor) {
KoMixColorsOp * mixOp = dab->colorSpace()->mixColorsOp();
const quint8 *colors[2];
colors[0] = m_inkColor.data();
colors[1] = bgColor.data();
qint16 colorWeights[2];
int MAX_16BIT = 255;
qreal blend = info.pressure();
colorWeights[0] = static_cast<quint16>(blend * MAX_16BIT);
colorWeights[1] = static_cast<quint16>((1.0 - blend) * MAX_16BIT);
mixOp->mixColors(colors, colorWeights, 2, m_inkColor.data());
}
if (m_colorProperties->useRandomHSV && m_transfo) {
params["h"] = (m_colorProperties->hue / 180.0) * drand48();
params["s"] = (m_colorProperties->saturation / 100.0) * drand48();
params["v"] = (m_colorProperties->value / 100.0) * drand48();
m_transfo->setParameters(params);
m_transfo->transform(m_inkColor.data(), m_inkColor.data() , 1);
}
if (m_colorProperties->useRandomOpacity) {
quint8 alpha = qRound(drand48() * OPACITY_OPAQUE_U8);
m_inkColor.setOpacity(alpha);
m_painter->setOpacity(alpha);
}
if (!m_colorProperties->colorPerParticle) {
shouldColor = false;
}
m_painter->setPaintColor(m_inkColor);
}
qreal jitteredWidth = qMax(qreal(1.0), m_shapeProperties->width * particleScale);
qreal jitteredHeight = qMax(qreal(1.0), m_shapeProperties->height * particleScale);
if (m_shapeProperties->enabled){
switch (m_shapeProperties->shape){
// ellipse
case 0:
{
if (m_shapeProperties->width == m_shapeProperties->height){
paintCircle(m_painter, nx + x, ny + y, qRound(jitteredWidth * 0.5));
}
else {
paintEllipse(m_painter, nx + x, ny + y, qRound(jitteredWidth * 0.5) , qRound(jitteredHeight * 0.5), rotationZ);
}
break;
}
// rectangle
case 1:
{
paintRectangle(m_painter, nx + x, ny + y, qRound(jitteredWidth) , qRound(jitteredHeight), rotationZ);
break;
}
// wu-particle
case 2: {
paintParticle(accessor, m_inkColor, nx + x, ny + y);
break;
}
// pixel
case 3: {
ix = qRound(nx + x);
iy = qRound(ny + y);
accessor->moveTo(ix, iy);
memcpy(accessor->rawData(), m_inkColor.data(), m_dabPixelSize);
break;
}
case 4: {
if (!m_brushQImage.isNull()) {
QTransform m;
m.rotate(rad2deg(rotationZ));
if (m_shapeDynamicsProperties->randomSize) {
m.scale(particleScale, particleScale);
}
m_transformed = m_brushQImage.transformed(m, Qt::SmoothTransformation);
m_imageDevice->convertFromQImage(m_transformed, 0);
KisRandomAccessorSP ac = m_imageDevice->createRandomAccessorNG(0, 0);
QRect rc = m_transformed.rect();
if (m_colorProperties->useRandomHSV && m_transfo) {
for (int y = rc.y(); y < rc.y() + rc.height(); y++) {
for (int x = rc.x(); x < rc.x() + rc.width(); x++) {
ac->moveTo(x, y);
m_transfo->transform(ac->rawData(), ac->rawData() , 1);
}
}
}
ix = qRound(nx + x - rc.width() * 0.5);
iy = qRound(ny + y - rc.height() * 0.5);
m_painter->bitBlt(QPoint(ix, iy), m_imageDevice, rc);
m_imageDevice->clear();
break;
}
}
}
// Auto-brush
}
else {
QPointF hotSpot = m_brush->hotSpot(particleScale, particleScale, -rotationZ, info);
QPointF pos(nx + x, ny + y);
QPointF pt = pos - hotSpot;
qint32 ix;
qreal xFraction;
qint32 iy;
qreal yFraction;
KisPaintOp::splitCoordinate(pt.x(), &ix, &xFraction);
KisPaintOp::splitCoordinate(pt.y(), &iy, &yFraction);
//KisFixedPaintDeviceSP dab;
if (m_brush->brushType() == IMAGE ||
m_brush->brushType() == PIPE_IMAGE) {
m_fixedDab = m_brush->paintDevice(m_fixedDab->colorSpace(), particleScale, -rotationZ, info, xFraction, yFraction);
if (m_colorProperties->useRandomHSV && m_transfo) {
quint8 * dabPointer = m_fixedDab->data();
int pixelCount = m_fixedDab->bounds().width() * m_fixedDab->bounds().height();
m_transfo->transform(dabPointer, dabPointer, pixelCount);
}
}
else {
m_brush->mask(m_fixedDab, m_inkColor, particleScale, particleScale, -rotationZ, info, xFraction, yFraction);
}
m_painter->bltFixed(QPoint(ix, iy), m_fixedDab, m_fixedDab->bounds());
}
}
// recover from jittering of color,
// m_inkColor.opacity is recovered with every paint
}
double NonlinearTransmission::lookupActuatorPosition(double joint_position){
return linearInterpolation(joint_position_samples_, actuator_position_samples_, joint_position);
}
bool PdfTransfer::NDPdfTransfer(float *input, float *palette, float **rotations) {
clock_t start, end;
FILE *fp = fopen("time.txt", "w");
unsigned long int var_time = 0;
float *finalPic = new float[_projections * _inputSize];
for (unsigned int i = 0; i < _iterations; ++i) {
start = clock();
float * ptrRotation = rotations[i];
assert(ptrRotation);
float *inputRotation = new float[_projections * _inputSize];
float *paletteRotation = new float[_projections * _paletteSize];
_matrixModule->matrix_multiply(ptrRotation, _projections, NUM_CHANNELS,
input, NUM_CHANNELS, _inputSize, inputRotation, _projections, _inputSize);
#ifdef DEBUG
if (!i) {
printMatrix(ptrRotation, _projections, NUM_CHANNELS, "ptrRotation", _height, _width);
printMatrix(input, NUM_CHANNELS, _inputSize, "input", _height, _width);
printMatrix(inputRotation, _projections, _inputSize, "inputRotation", _height, _width);
}
#endif
_matrixModule->matrix_multiply(ptrRotation, _projections, NUM_CHANNELS,
palette, NUM_CHANNELS, _paletteSize, paletteRotation, _projections, _paletteSize);
#ifdef DEBUG
if (!i) {
printMatrix(palette, NUM_CHANNELS, _paletteSize, "palette", _height, _width);
printMatrix(paletteRotation, _projections, _paletteSize, "paletteRotation", _height, _width);
}
#endif
Histogram ** histogramsInput = new Histogram*[_projections];
Histogram ** histogramsPalette = new Histogram*[_projections];
//Step1: Creation of Histograms
CreateHistograms(inputRotation, _inputSize,
paletteRotation, _paletteSize, _projections, histogramsInput, histogramsPalette);
#ifdef DEBUG
printHistogr(histogramsInput, i);
#endif
std::vector<float> *inter = new std::vector<float>[_projections];
for (unsigned int j = 0; j < _projections; ++j) {
std::vector<float> ptr = SinglePdfTransfer(histogramsInput[j], histogramsPalette[j]);
std::vector<float> newPtr(ptr.begin() + 1, ptr.end() - 1);
float scale = bin_count / (histogramsInput[j]->GetOverallMax() -
histogramsInput[j]->GetOverallMin());
//populate X points before interpolation
std::vector<float> X(newPtr.size());
for (unsigned int k = 0; k < X.size(); ++k) {
X[k] = (float) k;
}
std::vector<float> Xq(_inputSize);
unsigned int itr = 0;
for (unsigned k = j * _inputSize; k < (j + 1) * _inputSize; ++k, ++itr) {
Xq[itr] = inputRotation[k];
Xq[itr] = (Xq[itr] - histogramsInput[j]->GetOverallMin()) * scale;
}
inter[j] = linearInterpolation(X, newPtr, Xq);
for (unsigned int k = 0; k < inter[j].size(); ++k) {
inter[j][k] = inter[j][k] / scale + histogramsInput[j]->GetOverallMin();
inter[j][k] -= matrix_access(inputRotation, _projections, _inputSize, j, k);
matrix_access(finalPic, _projections, _inputSize, j, k) = inter[j][k];
}
}
#ifdef DEBUG
char filename2[10];
sprintf(filename2, "finalPic%d", i);
printMatrix(finalPic, _projections, _inputSize, filename2, _height, _width);
#endif
//resolve linear system of ptrRotation*x = inter
_matrixModule->matrix_inverse(ptrRotation, _projections, NUM_CHANNELS);
float *aux = new float[ _projections * _inputSize ];
_matrixModule->matrix_multiply(ptrRotation, _projections, NUM_CHANNELS,
finalPic, _projections, _inputSize,
aux, _projections, _inputSize);
_matrixModule->matrix_add(input, aux, input, _projections, _inputSize);
#ifdef DEBUG
//if(!i)
//{
char filename[10];
sprintf(filename, "iter%d", i);
printMatrix(input, _projections, _inputSize, filename, _height, _width);
//}
#endif
end = clock();
var_time = (end - start) / (CLOCKS_PER_SEC);
fprintf(fp, "It took %lu seconds to complete %d iteration\n", var_time, i);
//freeing memory
delete [] inputRotation;
delete [] paletteRotation;
}
//freeing heap
delete [] finalPic;
//used for logging time
fclose(fp);
return true;
}
double NonlinearTransmission::lookupReductionByInput(double actuator_position){
return linearInterpolation(actuator_position_samples_, mechanical_reduction_samples_, actuator_position);
}
double NonlinearTransmission::lookupReductionByOutput(double joint_position){
return linearInterpolation(joint_position_samples_, mechanical_reduction_samples_, joint_position);
}
double MiscibilityLiveGas::miscible_gas(double press, const surfvol_t& surfvol, int item,
bool deriv) const
{
int section;
double R = linearInterpolation(saturated_gas_table_[0],
saturated_gas_table_[3], press,
section);
double maxR = surfvol[Liquid]/surfvol[Vapour];
if (deriv) {
if (R < maxR ) { // Saturated case
return linearInterpolationDerivative(saturated_gas_table_[0],
saturated_gas_table_[item],
press);
} else { // Undersaturated case
int is = section;
if (undersat_gas_tables_[is][0].size() < 2) {
double val = (saturated_gas_table_[item][is+1]
- saturated_gas_table_[item][is]) /
(saturated_gas_table_[0][is+1] -
saturated_gas_table_[0][is]);
return val;
}
double val1 =
linearInterpolation(undersat_gas_tables_[is][0],
undersat_gas_tables_[is][item],
maxR);
double val2 =
linearInterpolation(undersat_gas_tables_[is+1][0],
undersat_gas_tables_[is+1][item],
maxR);
double val = (val2 - val1)/
(saturated_gas_table_[0][is+1] - saturated_gas_table_[0][is]);
return val;
}
} else {
if (R < maxR ) { // Saturated case
return linearInterpolation(saturated_gas_table_[0],
saturated_gas_table_[item],
press);
} else { // Undersaturated case
int is = section;
// Extrapolate from first table section
if (is == 0 && press < saturated_gas_table_[0][0]) {
return linearInterpolation(undersat_gas_tables_[0][0],
undersat_gas_tables_[0][item],
maxR);
}
// Extrapolate from last table section
int ltp = saturated_gas_table_[0].size() - 1;
if (is+1 == ltp && press > saturated_gas_table_[0][ltp]) {
return linearInterpolation(undersat_gas_tables_[ltp][0],
undersat_gas_tables_[ltp][item],
maxR);
}
// Interpolate between table sections
double w = (press - saturated_gas_table_[0][is]) /
(saturated_gas_table_[0][is+1] -
saturated_gas_table_[0][is]);
if (undersat_gas_tables_[is][0].size() < 2) {
double val = saturated_gas_table_[item][is] +
w*(saturated_gas_table_[item][is+1] -
saturated_gas_table_[item][is]);
return val;
}
double val1 =
linearInterpolation(undersat_gas_tables_[is][0],
undersat_gas_tables_[is][item],
maxR);
double val2 =
linearInterpolation(undersat_gas_tables_[is+1][0],
undersat_gas_tables_[is+1][item],
maxR);
double val = val1 + w*(val2 - val1);
return val;
}
}
}
/**
* Get the value of the function at x, return a quiet NAN if x is not in the definiton domain.
**/
virtual double _function(double x) const override
{
if (_pmap->size() == 0) { return std::numeric_limits<double>::quiet_NaN(); }
_minDomain = (_pmap->begin())->first;
_maxDomain = (_pmap->rbegin())->first;
if ((x < _minDomain)||(x > _maxDomain)) { return std::numeric_limits<double>::quiet_NaN(); }
auto it2 = _pmap->lower_bound(x);
if (it2 == _pmap->end()) { return std::numeric_limits<double>::quiet_NaN(); }
if (it2 == _pmap->begin()) { if (x < (double)(it2->first)) { return std::numeric_limits<double>::quiet_NaN(); } else { return it2->second; } }
double x2 = (double)it2->first;
double y2 = (double)it2->second;
auto it1 = it2; it1--;
double x1 = (double)it1->first;
double y1 = (double)it1->second;
int t = interpolationMethod();
if (t == INTERPOLATION_NONE) { return y1; }
if (t == INTERPOLATION_LINEAR) { return linearInterpolation(x, fVec2(x1, y1), fVec2(x2, y2)); }
double x0 = x1 - 1.0;
double x3 = x2 + 1.0;
double y0 = std::numeric_limits<double>::quiet_NaN();
double y3 = std::numeric_limits<double>::quiet_NaN();
if (it1 != _pmap->begin())
{
it1--;
x0 = (double)it1->first;
y0 = (double)it1->second;
}
it2++;
if (it2 != _pmap->end())
{
x3 = (double)it2->first;
y3 = (double)it2->second;
}
if (t == INTERPOLATION_CUBIC) return cubicInterpolation(x, fVec2(x0, y0), fVec2(x1, y1), fVec2(x2, y2), fVec2(x3, y3));
return monotoneCubicInterpolation(x, fVec2(x0, y0), fVec2(x1, y1), fVec2(x2, y2), fVec2(x3, y3));
/*
if ((_tab == nullptr) || (_len == 0)) return std::numeric_limits<double>::quiet_NaN();
if (!((x >= _minDomain) && (x <= _maxDomain))) return std::numeric_limits<double>::quiet_NaN();
double _e = (_maxDomain - _minDomain) / _len;
if (!((_e >= DBL_MIN * 2) && (_e <= DBL_MAX / 2.0))) return std::numeric_limits<double>::quiet_NaN();
int t = interpolationMethod();
if (t == INTERPOLATION_NONE)
{
size_t n = (size_t)((x - _minDomain) / _e);
if (n >= _len) return std::numeric_limits<double>::quiet_NaN();
double y;
try { y = (double)_tab[n]; }
catch (...) { y = std::numeric_limits<double>::quiet_NaN(); }
return y;
}
if (t == INTERPOLATION_LINEAR)
{
size_t n = (size_t)((x - _minDomain) / _e);
if (n >= _len) std::numeric_limits<double>::quiet_NaN();
double x1 = _minDomain + n*_e;
double x2 = x1 + _e;
double y1 = std::numeric_limits<double>::quiet_NaN();
double y2 = std::numeric_limits<double>::quiet_NaN();
try { y1 = (double)_tab[n]; }
catch (...) { y1 = std::numeric_limits<double>::quiet_NaN(); }
try { y2 = (n + 1 >= _len) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n + 1]); }
catch (...) { y2 = std::numeric_limits<double>::quiet_NaN(); }
return linearInterpolation(x, fVec2(x1, y1), fVec2(x2, y2));
}
size_t n = (size_t)((x - _minDomain) / _e);
if (n >= _len) std::numeric_limits<double>::quiet_NaN();
double x1 = _minDomain + n*_e;
double x0 = x1 - _e;
double x2 = x1 + _e;
double x3 = x2 + _e;
double y0 = std::numeric_limits<double>::quiet_NaN();
double y1 = std::numeric_limits<double>::quiet_NaN();
double y2 = std::numeric_limits<double>::quiet_NaN();
double y3 = std::numeric_limits<double>::quiet_NaN();
try { y0 = (n == 0) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n - 1]); }
catch (...) { y0 = std::numeric_limits<double>::quiet_NaN(); }
try { y1 = (double)_tab[n]; }
catch (...) { y1 = std::numeric_limits<double>::quiet_NaN(); }
try { y2 = (n + 1 >= _len) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n + 1]); }
catch (...) { y2 = std::numeric_limits<double>::quiet_NaN(); }
try { y3 = (n + 2 >= _len) ? (std::numeric_limits<double>::quiet_NaN()) : ((double)_tab[n + 2]); }
catch (...) { y3 = std::numeric_limits<double>::quiet_NaN(); }
if (t == INTERPOLATION_CUBIC) return cubicInterpolation(x, fVec2(x0, y0), fVec2(x1, y1), fVec2(x2, y2), fVec2(x3, y3));
return monotoneCubicInterpolation(x, fVec2(x0, y0), fVec2(x1, y1), fVec2(x2, y2), fVec2(x3, y3));
*/
}