ossimplugins::HermiteInterpolator Class Reference

Abstract interpolator. More...

#include <HermiteInterpolator.h>

Public Member Functions
	HermiteInterpolator ()
	Constructor. More...
	HermiteInterpolator (int nbrPoints, double *x, double *y, double *dy)
	Constructor with initializations. More...
	~HermiteInterpolator ()
	Destructor. More...
	HermiteInterpolator (const HermiteInterpolator &rhs)
	Copy constructor. More...
HermiteInterpolator &	operator= (const HermiteInterpolator &rhs)
	Affectation operator. More...
int	Interpolate (double x, double &y, double &dy) const
	This function performs the interpolation for the abscissa x. More...
int	Interpolate (double x, double &y) const
	This function performs the interpolation for the abscissa x. More...

Protected Member Functions
void	Clear ()
int	Precompute () const

Protected Attributes
int	theNPointsAvailable
double *	theXValues
double *	theYValues
double *	thedYValues
double *	prodC
double *	sumC
bool	isComputed

Detailed Description

Abstract interpolator.

See also

Interpolate

Definition at line 26 of file HermiteInterpolator.h.

Constructor & Destructor Documentation

HermiteInterpolator() [1/3]

ossimplugins::HermiteInterpolator::HermiteInterpolator

(

)

Constructor.

Definition at line 22 of file HermiteInterpolator.cpp.

                                        :
  theNPointsAvailable(0),
  theXValues(NULL),
  theYValues(NULL),
  thedYValues(NULL),
  prodC(NULL),
  sumC(NULL),
  isComputed(false)
{
}

HermiteInterpolator() [2/3]

ossimplugins::HermiteInterpolator::HermiteInterpolator	(	int	nbrPoints,
		double *	x,
		double *	y,
		double *	dy
	)

Constructor with initializations.

Parameters

nbrPoints	Number of points used to perform the interpolation
x	Values of the points abscissa
y	Values of the points
dy	Values of the differential coefficients

Todo:

Verifier que l'interpolateur n'ai pas besoin ques les abscisses soitent strictement croissantes

Definition at line 33 of file HermiteInterpolator.cpp.

References thedYValues, theNPointsAvailable, theXValues, theYValues, x, and y.

                                                                                       :
  theNPointsAvailable(nbrPoints),
   prodC(NULL),
   sumC(NULL),
  isComputed(false)
{
  if(x != NULL)
  {
    theXValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      theXValues[i] = x[i];
    }
  }
  else
  {
    theXValues = NULL;
  }

  if(y != NULL)
  {
    theYValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      theYValues[i] = y[i];
    }
  }
  else
  {
    theYValues = NULL;
  }

  if(dy != NULL)
  {
    thedYValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      thedYValues[i] = dy[i];
    }
  }
  else
  {
    thedYValues = NULL;
  }

  for (int i = 1 ; i < theNPointsAvailable ; i++)
  {
    /*
     * Les abscisses ne sont pas croissantes
     */
//    if (theXValues[i] <= theXValues[i-1])
//      std::cerr << "WARNING: Hermite interpolation assumes increasing x values" << std::endl;
    assert(theXValues[i] > theXValues[i-1]);
  }
}

~HermiteInterpolator()

ossimplugins::HermiteInterpolator::~HermiteInterpolator

(

)

Destructor.

Definition at line 93 of file HermiteInterpolator.cpp.

References Clear().

{
  Clear();
}

HermiteInterpolator() [3/3]

ossimplugins::HermiteInterpolator::HermiteInterpolator

(

const HermiteInterpolator &

rhs

)

Copy constructor.

Definition at line 98 of file HermiteInterpolator.cpp.

References thedYValues, theNPointsAvailable, theXValues, and theYValues.

                                                                      :
  theNPointsAvailable(rhs.theNPointsAvailable),
  prodC(NULL),
  sumC(NULL),
  isComputed(false)
{
  if(rhs.theXValues != NULL)
  {
    theXValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      theXValues[i] = rhs.theXValues[i];
    }
  }
  else
  {
    theXValues = NULL;
  }

  if(rhs.theYValues != NULL)
  {
    theYValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      theYValues[i] = rhs.theYValues[i];
    }
  }
  else
  {
    theYValues = NULL;
  }

  if(rhs.thedYValues != NULL)
  {
    thedYValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      thedYValues[i] = rhs.thedYValues[i];
    }
  }
  else
  {
    thedYValues = NULL;
  }
}

Member Function Documentation

Clear()

void ossimplugins::HermiteInterpolator::Clear ( )

protected

Definition at line 320 of file HermiteInterpolator.cpp.

References isComputed, prodC, sumC, thedYValues, theNPointsAvailable, theXValues, and theYValues.

Referenced by operator=(), and ~HermiteInterpolator().

{
  if (theXValues != NULL)
  {
    delete[] theXValues;
    theXValues = NULL;
  }

  if (theYValues != NULL)
  {
    delete[] theYValues;
    theYValues = NULL;
  }

  if (thedYValues != NULL)
  {
    delete[] thedYValues;
    thedYValues = NULL;
  }

  if (prodC != NULL)
  {
    delete[] prodC;
    prodC = NULL;
  }

  if (sumC != NULL)
  {
    delete[] sumC;
    prodC = NULL;
  }
  isComputed = false;
  theNPointsAvailable = 0;
}

Interpolate() [1/2]

int ossimplugins::HermiteInterpolator::Interpolate	(	double	x,
		double &	y,
		double &	dy
	)		const

This function performs the interpolation for the abscissa x.

Parameters

x	Abscissa of the interpolation
y	[out] value of the point at the abscissa x
dy	[out] value of the differential coefficient at abscissa x

Returns

Different of 0 if an error occurs

Definition at line 194 of file HermiteInterpolator.cpp.

References abs, isComputed, Precompute(), prodC, sumC, thedYValues, theNPointsAvailable, theXValues, theYValues, x, and y.

Referenced by ossimplugins::PlatformPosition::Interpolate().

{
  //NOTE assume that x is increasing

  // Not enough points to interpolate
  if (theNPointsAvailable < 2) return -1;

  y = 0.0;
  dy = 0.0;

  double epsilon = 0.0000000000001;

  //Precompute useful value if they are not available
  if (!isComputed)
  {
    Precompute();
  }

  for (int i = 0; i < theNPointsAvailable; i++)
  {
    double si = 0.0;
    double hi = 1.0;
    double ui = 0; //derivative computation
    double r = x - theXValues[i];

    // check if the point is on the list
    if ( std::abs(r) < epsilon )
    {
      y = theYValues[i];
      dy = thedYValues[i];
      return 0;
    }

    for (int j = 0; j < theNPointsAvailable; j++)
    {
      if (j != i)
      {
        hi = hi * (x - theXValues[j]);
        ui = ui + 1 / (x - theXValues[j]);//derivative computation
      }
    }
    hi *= prodC[i];
    si = sumC[i];

    double f = 1.0 - 2.0 * r * si;

    y += (theYValues[i] * f + thedYValues[i] * r) * hi * hi;

    ui *= hi;//derivative computation

    double fp = 2.0 * hi * (ui * (1.0 - 2.0 * si * r) - hi * si);//derivative computation
    double d = hi * (hi + 2.0 * r * ui);//derivative computation

    dy += fp * theYValues[i] + d * thedYValues[i];//derivative computation

  }

  return 0;
}

Interpolate() [2/2]

int ossimplugins::HermiteInterpolator::Interpolate	(	double	x,
		double &	y
	)		const

This function performs the interpolation for the abscissa x.

Parameters

x	Abscissa of the interpolation
y	[out] value of the point at the abscissa x

Returns

Different of 0 if an error occurs

Definition at line 257 of file HermiteInterpolator.cpp.

References isComputed, Precompute(), prodC, sumC, thedYValues, theNPointsAvailable, theXValues, theYValues, x, and y.

{
  //NOTE assume that x is increasing

  // Not enough points to interpolate
  if (theNPointsAvailable < 2) return -1;

  y = 0.0;

  //Precompute useful value if they are not available
  if (!isComputed)
  {
    Precompute();
  }

  for (int i = 0; i < theNPointsAvailable; i++)
  {
    double si = 0.0;
    double hi = 1.0;
    double r = x - theXValues[i];

    for (int j = 0; j < theNPointsAvailable; j++)
    {
      if (j != i)
      {
        hi = hi * (x - theXValues[j]);
      }
    }
    hi *= prodC[i];
    si = sumC[i];

    double f = 1.0 - 2.0 * r * si;

    y += (theYValues[i] * f + thedYValues[i] * r) * hi * hi;

  }

  return 0;
}

operator=()

HermiteInterpolator & ossimplugins::HermiteInterpolator::operator=

(

const HermiteInterpolator &

rhs

)

Affectation operator.

Definition at line 144 of file HermiteInterpolator.cpp.

References Clear(), isComputed, prodC, sumC, thedYValues, theNPointsAvailable, theXValues, and theYValues.

{
  Clear();
  theNPointsAvailable = rhs.theNPointsAvailable;
  isComputed = false;
  if(rhs.theXValues != NULL)
  {
    theXValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      theXValues[i] = rhs.theXValues[i];
    }
  }
  else
  {
    theXValues = NULL;
  }

  if(rhs.theYValues != NULL)
  {
    theYValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      theYValues[i] = rhs.theYValues[i];
    }
  }
  else
  {
    theYValues = NULL;
  }

  if(rhs.thedYValues != NULL)
  {
    thedYValues = new double[theNPointsAvailable];
    for (int i=0;i<theNPointsAvailable;i++)
    {
      thedYValues[i] = rhs.thedYValues[i];
    }
  }
  else
  {
    thedYValues = NULL;
  }
  prodC = NULL; 
  sumC = NULL;
   
  return *this;
}

Precompute()

int ossimplugins::HermiteInterpolator::Precompute ( ) const

protected

Definition at line 297 of file HermiteInterpolator.cpp.

References isComputed, prodC, sumC, theNPointsAvailable, and theXValues.

Referenced by Interpolate().

{
  prodC = new double[theNPointsAvailable];
  sumC= new double[theNPointsAvailable];

  for (int i = 0; i < theNPointsAvailable; i++)
  {
    prodC[i] = 1;
    sumC[i] = 0;
    for (int j = 0; j < theNPointsAvailable; j++)
    {
      if (j != i)
      {
        double v = 1.0 / (theXValues[i] - theXValues[j]);
        prodC[i] *= v;
        sumC[i]  += v;
      }
    }
  }
  isComputed = true;
  return 0;
}

Member Data Documentation

isComputed

bool ossimplugins::HermiteInterpolator::isComputed

mutableprotected

Definition at line 85 of file HermiteInterpolator.h.

Referenced by Clear(), Interpolate(), operator=(), and Precompute().

prodC

double* ossimplugins::HermiteInterpolator::prodC

mutableprotected

Definition at line 83 of file HermiteInterpolator.h.

Referenced by Clear(), Interpolate(), operator=(), and Precompute().

sumC

double* ossimplugins::HermiteInterpolator::sumC

mutableprotected

Definition at line 84 of file HermiteInterpolator.h.

Referenced by Clear(), Interpolate(), operator=(), and Precompute().

thedYValues

double* ossimplugins::HermiteInterpolator::thedYValues

protected

Definition at line 81 of file HermiteInterpolator.h.

Referenced by Clear(), HermiteInterpolator(), Interpolate(), and operator=().

theNPointsAvailable

int ossimplugins::HermiteInterpolator::theNPointsAvailable

protected

Definition at line 78 of file HermiteInterpolator.h.

Referenced by Clear(), HermiteInterpolator(), Interpolate(), operator=(), and Precompute().

theXValues

double* ossimplugins::HermiteInterpolator::theXValues

protected

Definition at line 79 of file HermiteInterpolator.h.

Referenced by Clear(), HermiteInterpolator(), Interpolate(), operator=(), and Precompute().

theYValues

double* ossimplugins::HermiteInterpolator::theYValues

protected

Definition at line 80 of file HermiteInterpolator.h.

Referenced by Clear(), HermiteInterpolator(), Interpolate(), and operator=().

---

The documentation for this class was generated from the following files:

• HermiteInterpolator.h
• HermiteInterpolator.cpp