QwInterpolator< value_t, value_n > Class Template Reference

A multi-dimensional grid of values with interpolation methods. More...

#include <QwInterpolator.h>

Collaboration diagram for QwInterpolator< value_t, value_n >:

Public Member Functions
	QwInterpolator (const unsigned int ndim=1)
	Constructor with number of dimensions.
	QwInterpolator (const std::vector< coord_t > &min, const std::vector< coord_t > &max, const std::vector< coord_t > &step)
	Constructor with minimum, maximum, and step size.
	QwInterpolator (const std::string &filename)
	Constructor with file name.
virtual	~QwInterpolator ()
	Destructor.
void	SetDimensions (const unsigned int ndim)
	Set the number of coordinate dimensions and resize vectors.
void	SetMinimumMaximumStep (const coord_t min, const coord_t max, const coord_t step)
	Set minimum, maximum, and step size to single values.
void	SetMinimumMaximumStep (const std::vector< coord_t > &min, const std::vector< coord_t > &max, const std::vector< coord_t > &step)
	Set minimum, maximum, and step size to different values.
coord_t	GetMinimum (const unsigned int dim) const
	Get minimum in dimension.
coord_t	GetMaximum (const unsigned int dim) const
	Get maximum in dimension.
coord_t	GetStepSize (const unsigned int dim) const
	Get minimum in dimension.
unsigned int	GetMaximumEntries () const
	Get the maximum number of entries.
unsigned int	GetCurrentEntries () const
	Get the current number of entries.
unsigned int	GetWrapCoordinate (const unsigned int dim) const
	Get wrapping coordinate.
void	SetWrapCoordinate (const unsigned int dim, const size_t wrap=1)
	Set wrapping coordinate.
void	SetWrapCoordinate (const std::vector< size_t > &wrap)
int	GetDataReductionFactor (const unsigned int dim) const
	Get data reduction factor.
void	SetDataReductionFactor (const unsigned int dim, const unsigned int redux)
	Set data reduction factor.
void	SetDataReductionFactor (const unsigned int redux)
void	SetDataReductionFactor (const std::vector< unsigned int > &redux)
void	SetInterpolationMethod (const EQwInterpolationMethod method)
	Set the interpolation method.
EQwInterpolationMethod	GetInterpolationMethod () const
	Get the interpolation method.
void	PrintCoverage (const unsigned int dim)
	Print coverage map for all bins in one dimension.
bool	InBounds (const coord_t *coord) const
	Return true if the coordinate is in bounds.
Functions to write grid values
bool	Set (const coord_t &coord, const value_t &value)
	Set a single value at a coordinate (false if not possible)
bool	Set (const coord_t *coord, const value_t &value)
	Set a single value at a coordinate (false if not possible)
bool	Set (const coord_t *coord, const value_t *value)
	Set a set of values at a coordinate (false if not possible)
bool	Set (const unsigned int linear_index, const value_t &value)
	Set a single value at a linearized index (false if not possible)
bool	Set (const unsigned int linear_index, const value_t *value)
	Set a set of values at a linearized index (false if not possible)
bool	Set (const unsigned int *cell_index, const value_t &value)
	Set a single value at a grid point (false if out of bounds)
bool	Set (const unsigned int *cell_index, const value_t *value)
	Set a set of values at a grid point (false if out of bounds)
Functions to retrieve interpolated values
value_t	GetValue (const coord_t &coord) const
	Get the interpolated value at coordinate (zero if out of bounds)
value_t	GetValue (const coord_t *coord) const
	Get the interpolated value at coordinate (zero if out of bounds)
bool	GetValue (const coord_t *coord, double &value) const
	Get the interpolated value at coordinate (zero if out of bounds)
bool	GetValue (const coord_t *coord, double *value) const
	Get the interpolated value at coordinate (zero if out of bounds)
File reading and writing
bool	WriteText (std::ostream &stream) const
	Write the grid as text.
bool	WriteTextFile (const std::string &filename) const
	Write the grid to text file.
bool	WriteTextScreen () const
	Write the grid to screen.
bool	ReadText (std::istream &stream)
	Read the grid from text.
bool	ReadTextFile (const std::string &filename)
	Read the grid from text file.
bool	WriteBinaryFile (const std::string &filename) const
	Write the grid values to binary file.
bool	ReadBinaryFile (const std::string &filename)
	Read the grid values from binary file.

Private Attributes
unsigned int	fNDim
	Number of dimensions in coordinates.
std::vector< coord_t >	fMin
	Minimum in each dimension.
std::vector< coord_t >	fMax
	Maximum in each dimension.
std::vector< coord_t >	fStep
	Step size in each dimension.
std::vector< size_t >	fSize
	Number of points in each dimension.
std::vector< size_t >	fWrap
	Wrap around this coordinate.
std::vector< size_t >	fRedux
	Data reduction factor.
std::vector< size_t >	fExtent
std::vector< value_t >	fValues [value_n]
	Table with pointers to arrays of values.
unsigned int	fCurrentEntries
	Number of values read in.
unsigned int	fMaximumEntries
	Maximum number of values.
unsigned int *	f_cell_index
	Pre-allocated cell index.
double *	f_cell_local
	Pre-allocated local coordinates.
EQwInterpolationMethod	fInterpolationMethod
	Interpolation method.

Indexing functions (publicly available and unchecked)
unsigned int	Index (const coord_t *coord) const
	Return the linearized index based on the point coordinates (unchecked)
unsigned int	Index (const unsigned int *cell_index) const
	Return the linearized index based on the cell indices (unchecked)
unsigned int	Index (const unsigned int *cell_index, const unsigned int offset) const
	Return the linearized index based on the cell indices and offset (unchecked)
void	Cell (const coord_t coord, unsigned int &cell_index, double &cell_local, const unsigned int dim) const
	Return the cell index and local coordinates in one dimension (unchecked)
void	Cell (const coord_t *coord, unsigned int *cell_index, double *cell_local) const
	Return the cell index and local coordinates (unchecked)
void	Cell (const coord_t *coord, unsigned int *cell_index) const
	Return the cell index (unchecked)
void	Cell (unsigned int linear_index, unsigned int *cell_index) const
	Return the cell index based on the linearized index (unchecked)
void	Coord (const unsigned int *cell_index, coord_t *coord) const
	Return the coordinates based on the cell index (unchecked)
void	Coord (const unsigned int linear_index, coord_t *coord) const
	Return the coordinates based on the linearized index (unchecked)
void	Nearest (const coord_t *coord, unsigned int *cell_index) const
	Return the cell index closest to the coordinate (could be above) (unchecked)
bool	Linear (const coord_t *coord, value_t *value) const
	Linear interpolation (unchecked)
bool	NearestNeighbor (const coord_t *coord, value_t *value) const
	Nearest-neighbor (unchecked)
bool	Check (const coord_t *coord) const
	Check for boundaries with coordinate argument.
bool	Check (const unsigned int *cell_index) const
	Check for boundaries with cell index argument.
bool	Check (const unsigned int linear_index) const
	Check for boundaries with linearized index argument.
value_t	Get (const unsigned int *cell_index) const
	Get a single value by cell index (unchecked)
value_t	Get (const unsigned int index) const
	Get a single value by linearized index (unchecked)
bool	Get (const unsigned int index, value_t *value) const
	Get a vector value by linearized index (unchecked)

Detailed Description

template<class value_t = float, unsigned int value_n = 1>
class QwInterpolator< value_t, value_n >

A multi-dimensional grid of values with interpolation methods.

This class provides various interpolation methods on a multi-dimensional grid of multi-dimensional values. Linear interpolation and nearest-neighbor are implemented for all dimensions.

The template arguments are the internal storage data type (defaults to float) and the number of dimensions of the stored data at each grid point (defaults to one). The dimension of the grid itself is set through the constructor. To describe a double vector field with 5 components on a 3-dimensional grid, you would write

QwInterpolate<float,5> *field = new QwInterpolator<float,5>(3);

The minimum, maximum, and step size of the grid have to be known before the values are filled.

Definition at line 54 of file QwInterpolator.h.

Constructor & Destructor Documentation

QwInterpolator() [1/3]

template<class value_t = float, unsigned int value_n = 1>

QwInterpolator< value_t, value_n >::QwInterpolator ( const unsigned int ndim = 1 )

inline

Constructor with number of dimensions.

Definition at line 59 of file QwInterpolator.h.

                                                {
      SetDimensions(ndim);
      SetInterpolationMethod(kMultiLinear);
      f_cell_index = new unsigned int[fNDim];
      f_cell_local = new double[fNDim];
    };

References f_cell_index, f_cell_local, fNDim, kMultiLinear, SetDimensions(), and SetInterpolationMethod().

Here is the call graph for this function:

QwInterpolator() [2/3]

template<class value_t = float, unsigned int value_n = 1>

QwInterpolator< value_t, value_n >::QwInterpolator ( const std::vector< coord_t > & min, const std::vector< coord_t > & max, const std::vector< coord_t > & step )

inline

Constructor with minimum, maximum, and step size.

Definition at line 66 of file QwInterpolator.h.

                                        {
      SetDimensions(min.size());
      SetInterpolationMethod(kMultiLinear);
      SetMinimumMaximumStep(min,max,step);
      f_cell_index = new unsigned int[fNDim];
      f_cell_local = new double[fNDim];
    };

References f_cell_index, f_cell_local, fNDim, kMultiLinear, SetDimensions(), SetInterpolationMethod(), and SetMinimumMaximumStep().

Here is the call graph for this function:

QwInterpolator() [3/3]

template<class value_t = float, unsigned int value_n = 1>

QwInterpolator< value_t, value_n >::QwInterpolator ( const std::string & filename )

inline

Constructor with file name.

Definition at line 76 of file QwInterpolator.h.

                                              {
      ReadBinaryFile(filename);
      SetInterpolationMethod(kMultiLinear);
      f_cell_index = new unsigned int[fNDim];
      f_cell_local = new double[fNDim];
    };

References f_cell_index, f_cell_local, fNDim, kMultiLinear, ReadBinaryFile(), and SetInterpolationMethod().

Here is the call graph for this function:

~QwInterpolator()

template<class value_t = float, unsigned int value_n = 1>

virtual QwInterpolator< value_t, value_n >::~QwInterpolator ( )

inlinevirtual

Destructor.

Definition at line 83 of file QwInterpolator.h.

                              {
      delete[] f_cell_index;
      delete[] f_cell_local;
    };

References f_cell_index, and f_cell_local.

Member Function Documentation

Cell() [1/4]

template<class value_t, unsigned int value_n>

void QwInterpolator< value_t, value_n >::Cell ( const coord_t * coord, unsigned int * cell_index ) const

inline

Return the cell index (unchecked)

Return the cell index (unchecked)

Parameters

coord	Point coordinates
cell_index	Cell index of the point (reference)

Definition at line 652 of file QwInterpolator.h.

{
  // Get cell index and ignore local coordinates
  Cell(coord, cell_index, f_cell_local);
}

References Cell(), and f_cell_local.

Here is the call graph for this function:

Cell() [2/4]

template<class value_t, unsigned int value_n>

void QwInterpolator< value_t, value_n >::Cell ( const coord_t * coord, unsigned int * cell_index, double * cell_local ) const

inline

Return the cell index and local coordinates (unchecked)

Return the cell index and local coordinates (unchecked)

Parameters

coord	Point coordinates
cell_index	Cell index of the point (reference)
cell_local	Local coordinates in cell (reference)

Definition at line 636 of file QwInterpolator.h.

{
  // Get cell index and local coordinates in each dimension
  for (unsigned int dim = 0; dim < fNDim; dim++)
    Cell(coord[dim], cell_index[dim], cell_local[dim], dim);
}

References Cell(), and fNDim.

Here is the call graph for this function:

Cell() [3/4]

template<class value_t, unsigned int value_n>

void QwInterpolator< value_t, value_n >::Cell ( const coord_t coord, unsigned int & cell_index, double & cell_local, const unsigned int dim ) const

inline

Return the cell index and local coordinates in one dimension (unchecked)

Return the cell index and local coordinates in one dimension (unchecked)

Parameters

coord	Point coordinate in one dimension
cell_index	Cell index of the point (reference)
cell_local	Local coordinates in cell (reference)
dim	Dimension

Definition at line 612 of file QwInterpolator.h.

{
  // Normalize coordinate (positive, with integers on grid points)
  double norm_coord = (coord - fMin[dim]) / fStep[dim];
  // Split in fractional and integer part
  double frac_part, int_part;
  frac_part = modf(norm_coord, &int_part);
  cell_local = frac_part;
  cell_index = static_cast<int>(int_part); // cast to integer
  // Wrap index
  if (fWrap[dim] > 0) cell_index %= (fSize[dim] - fWrap[dim]);
}

References fMin, fSize, fStep, and fWrap.

Referenced by Cell(), Cell(), Coord(), Index(), Linear(), Nearest(), and PrintCoverage().

Here is the caller graph for this function:

Cell() [4/4]

template<class value_t, unsigned int value_n>

void QwInterpolator< value_t, value_n >::Cell ( unsigned int linear_index, unsigned int * cell_index ) const

inline

Return the cell index based on the linearized index (unchecked)

Return the cell index based on the linearized index (unchecked)

Parameters

linear_index	Linearized index
cell_index	Cell index (reference)

Definition at line 666 of file QwInterpolator.h.

{
  // This does not work with unsigned int, because that is always >= 0 and wraps
  for (int dim = fNDim-1; dim >= 0; dim--) {
    cell_index[dim] = linear_index / fExtent[dim];
    linear_index -= cell_index[dim] * fExtent[dim];
  }
}

References fExtent, and fNDim.

Check() [1/3]

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::Check ( const coord_t * coord ) const

inlineprivate

Check for boundaries with coordinate argument.

Check whether the point is inside the valid region

Parameters

coord

Point coordinates

Returns

True if the coordinates are in the valid region

Definition at line 528 of file QwInterpolator.h.

{
  for (unsigned int dim = 0; dim < fNDim; dim++)
    if (fWrap[dim] == 0 && (coord[dim] < fMin[dim] || coord[dim] > fMax[dim]))
      return false;
  // Otherwise
  return true;
}

References fMax, fMin, fNDim, and fWrap.

Referenced by GetValue(), InBounds(), Set(), Set(), and Set().

Here is the caller graph for this function:

Check() [2/3]

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::Check ( const unsigned int * cell_index ) const

inlineprivate

Check for boundaries with cell index argument.

Check whether the cell index is inside the valid region

Parameters

cell_index

Cell index

Returns

True if the cell index is in the valid region

Definition at line 543 of file QwInterpolator.h.

{
  for (unsigned int dim = 0; dim < fNDim; dim++)
    if (cell_index[dim] >= fSize[dim])
      return false;
  // Otherwise
  return true;
}

References fNDim, and fSize.

Check() [3/3]

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::Check ( const unsigned int linear_index ) const

inlineprivate

Check for boundaries with linearized index argument.

Check whether the linearized index is inside the valid region

Parameters

linear_index

Linearized index

Returns

True if the cell index is in the valid region

Definition at line 558 of file QwInterpolator.h.

{
  if (linear_index >= fMaximumEntries)
    return false;
  // Otherwise
  return true;
}

References fMaximumEntries.

Coord() [1/2]

template<class value_t, unsigned int value_n>

void QwInterpolator< value_t, value_n >::Coord ( const unsigned int * cell_index, coord_t * coord ) const

inline

Return the coordinates based on the cell index (unchecked)

Return the coordinates based on the cell index (unchecked)

Parameters

cell_index	Cell index
coord	Point coordinates (reference)

Definition at line 683 of file QwInterpolator.h.

{
  for (unsigned int dim = 0; dim < fNDim; dim++)
    coord[dim] = fMin[dim] + cell_index[dim] * fStep[dim];
}

References fMin, fNDim, and fStep.

Referenced by Coord(), and PrintCoverage().

Here is the caller graph for this function:

Coord() [2/2]

template<class value_t, unsigned int value_n>

void QwInterpolator< value_t, value_n >::Coord ( const unsigned int linear_index, coord_t * coord ) const

inline

Return the coordinates based on the linearized index (unchecked)

Return the coordinates based on the linearized index (unchecked)

Parameters

linear_index	Linearized index
coord	Point coordinates (reference)

Definition at line 697 of file QwInterpolator.h.

{
  Cell(linear_index,f_cell_index);
  Coord(f_cell_index,coord);
}

References Cell(), Coord(), and f_cell_index.

Here is the call graph for this function:

Get() [1/3]

template<class value_t = float, unsigned int value_n = 1>

value_t QwInterpolator< value_t, value_n >::Get ( const unsigned int * cell_index ) const

inlineprivate

Get a single value by cell index (unchecked)

Definition at line 457 of file QwInterpolator.h.

                                                      {
      if (value_n != 1) return 0; // only for one-dimensional values
      return fValues[0][Index(cell_index)];
    };

References fValues, and Index().

Referenced by Linear(), NearestNeighbor(), and PrintCoverage().

Here is the call graph for this function:

Here is the caller graph for this function:

Get() [2/3]

template<class value_t = float, unsigned int value_n = 1>

value_t QwInterpolator< value_t, value_n >::Get ( const unsigned int index ) const

inlineprivate

Get a single value by linearized index (unchecked)

Definition at line 463 of file QwInterpolator.h.

                                                {
      return fValues[0][index];
    };

References fValues.

Get() [3/3]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Get ( const unsigned int index, value_t * value ) const

inlineprivate

Get a vector value by linearized index (unchecked)

Definition at line 467 of file QwInterpolator.h.

                                                             {
      for (unsigned int i = 0; i < value_n; i++)
        value[i] = fValues[i][index];
      return true;
    };

References fValues.

GetCurrentEntries()

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::GetCurrentEntries ( ) const

inline

Get the current number of entries.

Definition at line 181 of file QwInterpolator.h.

{ return fCurrentEntries; };

References fCurrentEntries.

GetDataReductionFactor()

template<class value_t = float, unsigned int value_n = 1>

int QwInterpolator< value_t, value_n >::GetDataReductionFactor ( const unsigned int dim ) const

inline

Get data reduction factor.

Definition at line 195 of file QwInterpolator.h.

      { return fRedux.at(dim); }

References fRedux.

GetInterpolationMethod()

template<class value_t = float, unsigned int value_n = 1>

EQwInterpolationMethod QwInterpolator< value_t, value_n >::GetInterpolationMethod ( ) const

inline

Get the interpolation method.

Definition at line 213 of file QwInterpolator.h.

      { return fInterpolationMethod; };

References fInterpolationMethod.

GetMaximum()

template<class value_t = float, unsigned int value_n = 1>

coord_t QwInterpolator< value_t, value_n >::GetMaximum ( const unsigned int dim ) const

inline

Get maximum in dimension.

Definition at line 175 of file QwInterpolator.h.

{ return fMax.at(dim); };

References fMax.

GetMaximumEntries()

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::GetMaximumEntries ( ) const

inline

Get the maximum number of entries.

Definition at line 179 of file QwInterpolator.h.

{ return fMaximumEntries; };

References fMaximumEntries.

GetMinimum()

template<class value_t = float, unsigned int value_n = 1>

coord_t QwInterpolator< value_t, value_n >::GetMinimum ( const unsigned int dim ) const

inline

Get minimum in dimension.

Definition at line 173 of file QwInterpolator.h.

{ return fMin.at(dim); };

References fMin.

GetStepSize()

template<class value_t = float, unsigned int value_n = 1>

coord_t QwInterpolator< value_t, value_n >::GetStepSize ( const unsigned int dim ) const

inline

Get minimum in dimension.

Definition at line 177 of file QwInterpolator.h.

{ return fStep.at(dim); };

References fStep.

GetValue() [1/4]

template<class value_t = float, unsigned int value_n = 1>

value_t QwInterpolator< value_t, value_n >::GetValue ( const coord_t & coord ) const

inline

Get the interpolated value at coordinate (zero if out of bounds)

Definition at line 332 of file QwInterpolator.h.

                                                 {
      if (value_n != 1) return false; // only for one-dimensional values
      if (fNDim != 1)   return false; // only for one-dimensional grids
      value_t value;
      if (GetValue(&coord, &value)) return value;
      else return 0; // interpolation failed
    };

References fNDim, and GetValue().

Referenced by GetValue(), GetValue(), and GetValue().

Here is the call graph for this function:

Here is the caller graph for this function:

GetValue() [2/4]

template<class value_t = float, unsigned int value_n = 1>

value_t QwInterpolator< value_t, value_n >::GetValue ( const coord_t * coord ) const

inline

Get the interpolated value at coordinate (zero if out of bounds)

Definition at line 340 of file QwInterpolator.h.

                                                 {
      if (value_n != 1) return 0; // only for one-dimensional values
      value_t value;
      if (GetValue(coord, &value)) return value;
      else return 0; // interpolation failed
    };

References GetValue().

Here is the call graph for this function:

GetValue() [3/4]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::GetValue ( const coord_t * coord, double & value ) const

inline

Get the interpolated value at coordinate (zero if out of bounds)

Definition at line 347 of file QwInterpolator.h.

                                                             {
      if (value_n != 1) return false; // only for one-dimensional values
      return GetValue(coord, &value);
    };

References GetValue().

Here is the call graph for this function:

GetValue() [4/4]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::GetValue ( const coord_t * coord, double * value ) const

inline

Get the interpolated value at coordinate (zero if out of bounds)

Definition at line 352 of file QwInterpolator.h.

                                                             {
      for (unsigned int i = 0; i < value_n; i++) value[i] = 0.0; // zero
      if (! Check(coord)) return false; // out of bounds
      value_t result[value_n]; // we need a local copy of type value_t
      switch (fInterpolationMethod) {
        // return interpolation status
        case kMultiLinear:
          if (! Linear(coord, result)) return false;
          break;
        case kNearestNeighbor:
          if (! NearestNeighbor(coord, result)) return false;
          break;
        default: return false;
      }
      for (unsigned int i = 0; i < value_n; i++) value[i] = result[i]; // cast
      return true;
    };

References Check(), fInterpolationMethod, kMultiLinear, kNearestNeighbor, Linear(), and NearestNeighbor().

Here is the call graph for this function:

GetWrapCoordinate()

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::GetWrapCoordinate ( const unsigned int dim ) const

inline

Get wrapping coordinate.

Definition at line 184 of file QwInterpolator.h.

      { return fWrap.at(dim); }

References fWrap.

InBounds()

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::InBounds ( const coord_t * coord ) const

inline

Return true if the coordinate is in bounds.

Definition at line 248 of file QwInterpolator.h.

                                              {
      return Check(coord);
    };

References Check().

Here is the call graph for this function:

Index() [1/3]

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::Index ( const coord_t * coord ) const

inline

Return the linearized index based on the point coordinates (unchecked)

Definition at line 409 of file QwInterpolator.h.

                                                   {
      Cell(coord, f_cell_index);
      return Index(f_cell_index);
    };

References Cell(), f_cell_index, and Index().

Referenced by Get(), Index(), Linear(), NearestNeighbor(), Set(), and Set().

Here is the call graph for this function:

Here is the caller graph for this function:

Index() [2/3]

template<class value_t, unsigned int value_n>

unsigned int QwInterpolator< value_t, value_n >::Index ( const unsigned int * cell_index ) const

inline

Return the linearized index based on the cell indices (unchecked)

Return the linearized index based on the cell indices (unchecked)

Parameters

cell_index

Index in each dimension

Returns

Linearized index

Definition at line 572 of file QwInterpolator.h.

{
  unsigned int linear_index = 0;
  // Loop over dimensions
  for (unsigned int dim = 0; dim < fNDim; dim++)
    // ... and use the stored extents for every dimensions
    linear_index += fExtent[dim] * cell_index[dim];
  return linear_index;
}

References fExtent, and fNDim.

Index() [3/3]

template<class value_t, unsigned int value_n>

unsigned int QwInterpolator< value_t, value_n >::Index ( const unsigned int * cell_index, const unsigned int pattern ) const

inline

Return the linearized index based on the cell indices and offset (unchecked)

Return the linearized index based on the cell indices and offset (unchecked)

Parameters

cell_index	Index in each dimension
pattern	Bit pattern with offsets in each dimension

Returns

Linearized index

Definition at line 590 of file QwInterpolator.h.

{
  unsigned int linear_index = 0;
  // Loop over dimensions
  for (unsigned int dim = 0; dim < fNDim; dim++) {
    // Add offset of one based on the bit at position dim
    unsigned int offset = (pattern >> dim) & 0x1;
    linear_index += fExtent[dim] * (cell_index[dim] + offset);
  }
  return linear_index;
}

References fExtent, and fNDim.

Linear()

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::Linear ( const coord_t * coord, value_t * value ) const

inlineprivate

Linear interpolation (unchecked)

Perform the multi-dimensional linear interpolation (unchecked)

Parameters

coord	Point coordinates
value	Interpolated value (reference)

Definition at line 483 of file QwInterpolator.h.

{
  // Get cell and local normalized coordinates
  Cell(coord, f_cell_index, f_cell_local);
  // Initialize to zero
  for (unsigned int i = 0; i < value_n; i++) value[i] = 0.0;
  // Calculate the interpolated value
  // by summing the 2^fNDim = 1 << fNDim neighbor points (1U is unsigned one)
  for (unsigned int offset = 0; offset < (1U << fNDim); offset++) {
    value_t neighbor[value_n];
    if (! Get(Index(f_cell_index,offset), neighbor)) return false;
    // ... with appropriate weighting factors (1 - cell_local or cell_local)
    double fac = 1.0;
    for (unsigned int dim = 0; dim < fNDim; dim++)
      fac *= ((offset >> dim) & 0x1)? f_cell_local[dim] : (1 - f_cell_local[dim]);
    // ... for all vector components
    for (unsigned int i = 0; i < value_n; i++)
      value[i] += fac * neighbor[i];
  }
  return true;
}

References Cell(), f_cell_index, f_cell_local, fNDim, Get(), and Index().

Referenced by GetValue().

Here is the call graph for this function:

Here is the caller graph for this function:

Nearest()

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::Nearest ( const coord_t * coord, unsigned int * cell_index ) const

inlineprivate

Return the cell index closest to the coordinate (could be above) (unchecked)

Definition at line 437 of file QwInterpolator.h.

                                                                       {
      Cell(coord, cell_index, f_cell_local);
      // Loop over all dimensions and add one if larger than 0.5
      for (unsigned int dim = 0; dim < fNDim; dim++)
        if (f_cell_local[dim] > 0.5) cell_index[dim]++;
    };

References Cell(), f_cell_local, and fNDim.

Referenced by NearestNeighbor(), and Set().

Here is the call graph for this function:

Here is the caller graph for this function:

NearestNeighbor()

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::NearestNeighbor ( const coord_t * coord, value_t * value ) const

inlineprivate

Nearest-neighbor (unchecked)

Perform the nearest-neighbor interpolation (unchecked)

Parameters

coord	Point coordinates
value	Interpolated value (reference)

Definition at line 513 of file QwInterpolator.h.

{
  // Get nearest cell
  Nearest(coord, f_cell_index);
  return Get(Index(f_cell_index), value);
}

References f_cell_index, Get(), Index(), and Nearest().

Referenced by GetValue().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintCoverage()

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::PrintCoverage ( const unsigned int dim )

inline

Print coverage map for all bins in one dimension.

Definition at line 218 of file QwInterpolator.h.

                                               {
      // Initialize coverage
      unsigned int* cover = new unsigned int[fSize[dim]];
      unsigned int* total = new unsigned int[fSize[dim]];
      for (unsigned int i = 0; i < fSize[dim]; i++) {
        cover[i] = 0;
        total[i] = 0;
      }
      // Loop over all entries
      value_t value[value_n];
      for (unsigned int linear_index = 0; linear_index < fMaximumEntries; linear_index++) {
        Cell(linear_index,f_cell_index);
        total[f_cell_index[dim]]++;
        if (Get(linear_index,value) && value[0] != 0)
          cover[f_cell_index[dim]]++; // non-zero field
      }
      // Print coverage
      coord_t* coord = new coord_t[fNDim];
      for (size_t i = 0; i < fSize[dim]; i++) {
        f_cell_index[dim] = i;
        Coord(f_cell_index,coord);
        mycout << "bin " << i << ", coord " << coord[dim] << ": "
            << double(cover[i]) / double(total[i]) * 100 << "%"<< myendl;
      }
      delete[] coord;
      delete[] cover;
      delete[] total;
    }

References Cell(), Coord(), f_cell_index, fMaximumEntries, fNDim, fSize, Get(), mycout, and myendl.

Here is the call graph for this function:

ReadBinaryFile()

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::ReadBinaryFile ( const std::string & filename )

inline

Read the grid values from binary file.

Read the grid values from binary file (should be 64-bit safe, untested)

Parameters

filename

File name

Returns

True if read successfully

Definition at line 840 of file QwInterpolator.h.

{
  std::ifstream file(filename.c_str(), std::ios::binary);
  if (! file.is_open()) return false;
  // Informational message
  mycout << "Reading binary file: ";
  // Go to end and store length (could also use std::ios::ate)
  file.seekg(0, std::ios::end);
  // Go to begin and start reading template parameters
  file.seekg(0, std::ios::beg);
  uint32_t n, size;
  file.read(reinterpret_cast<char*>(&n), sizeof(n));
  file.read(reinterpret_cast<char*>(&size), sizeof(size));
  if (n != value_n) return false; // not same dimensionality
  if (size != sizeof(value_t)) return false; // not same type
  // Read grid parameters
  uint32_t ndim;
  file.read(reinterpret_cast<char*>(&ndim), sizeof(ndim));
  SetDimensions(ndim);
  // Read sizes
  for (unsigned int dim = 0; dim < fNDim; dim++) {
    file.read(reinterpret_cast<char*>(&fMin[dim]),sizeof(fMin[dim]));
    file.read(reinterpret_cast<char*>(&fMax[dim]),sizeof(fMax[dim]));
    file.read(reinterpret_cast<char*>(&fStep[dim]),sizeof(fStep[dim]));
  }
  SetMinimumMaximumStep(fMin, fMax, fStep); // calculates fMaximumEntries
  // Read values
  uint32_t maximum_entries;
  file.read(reinterpret_cast<char*>(&maximum_entries),sizeof(maximum_entries));
  if (maximum_entries != fMaximumEntries) return false; // not expected number of entries
  int value_size = sizeof(value_t);
  unsigned int entries = fValues[0].size();
  for (unsigned int index = 0; index < entries; index++) {
    // Read values
    for (unsigned int i = 0; i < value_n; i++) {
      file.read((char*)(&fValues[i][index]),value_size);
    }
    // Progress bar
    if (index % (entries / 10) == 0)
      mycout << index / (entries / 100) << "%" << QwLog::flush;
    if (index % (entries / 10) != 0
     && index % (entries / 40) == 0)
      mycout << "." << QwLog::flush;
  }
  mycout << myendl;
  file.close();
  return true;
}

References QwLog::flush(), fMax, fMaximumEntries, fMin, fNDim, fStep, fValues, mycout, myendl, SetDimensions(), and SetMinimumMaximumStep().

Referenced by QwInterpolator().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadText()

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::ReadText ( std::istream & stream )

inline

Read the grid from text.

Read the grid values from a text stream

Parameters

stream

Input stream

Returns

True if successfully read all values

Definition at line 746 of file QwInterpolator.h.

{
  // Informational message
  mycout << "Reading text stream: ";
  // Read the dimensions
  unsigned int n;
  stream >> fNDim >> n;
  if (n != value_n) return false; // not same dimensionality
  SetDimensions(fNDim);
  // Read the grid parameters
  for (unsigned int dim = 0; dim < fNDim; dim++)
    stream >> dim >> fMin[dim] >> fMax[dim] >> fStep[dim];
  SetMinimumMaximumStep(fMin, fMax, fStep);
  // Read the grid values
  unsigned int entries;
  stream >> entries;
  for (unsigned int index = 0; index < entries; index++) {
    // Read values
    for (unsigned int i = 0; i < value_n; i++) {
      stream >> fValues[i][index];
    }
    // Progress bar
    if (index % (entries / 10) == 0)
      mycout << index / (entries / 100) << "%" << QwLog::flush;
    if (index % (entries / 10) != 0
     && index % (entries / 40) == 0)
      mycout << "." << QwLog::flush;
  }
  // Check for end of file
  std::string end;
  stream >> end;
  // Informational message
  mycout << myendl;
  if (end == "end") return true;
  else return false;
}

References QwLog::flush(), fMax, fMin, fNDim, fStep, fValues, mycout, myendl, SetDimensions(), and SetMinimumMaximumStep().

Referenced by ReadTextFile().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadTextFile()

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::ReadTextFile ( const std::string & filename )

inline

Read the grid from text file.

Definition at line 392 of file QwInterpolator.h.

                                                 {
      std::ifstream file(filename.c_str());
      if (! file.is_open()) return false;
      if (! ReadText(file)) return false;
      file.close();
      return true;
    };

References ReadText().

Here is the call graph for this function:

Set() [1/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const coord_t & coord, const value_t & value )

inline

Set a single value at a coordinate (false if not possible)

Definition at line 256 of file QwInterpolator.h.

                                                         {
      if (value_n != 1) return false; // only for one-dimensional values
      if (fNDim != 1) return false; // only for one-dimensional grids
      return Set(&coord, &value);
    };

References fNDim, and Set().

Referenced by Set(), Set(), Set(), Set(), Set(), and Set().

Here is the call graph for this function:

Here is the caller graph for this function:

Set() [2/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const coord_t * coord, const value_t & value )

inline

Set a single value at a coordinate (false if not possible)

Definition at line 262 of file QwInterpolator.h.

                                                         {
      if (value_n != 1) return false; // only for one-dimensional values
      return Set(coord, &value);
    };

References Set().

Here is the call graph for this function:

Set() [3/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const coord_t * coord, const value_t * value )

inline

Set a set of values at a coordinate (false if not possible)

Definition at line 267 of file QwInterpolator.h.

                                                         {
      Nearest(coord, f_cell_index); // nearest cell
      if (! Check(f_cell_index)) return false; // out of bounds
      bool status = true;
      bool written = false;
      unsigned int linear_index;
      for (unsigned int dim = 0; dim < fNDim; dim++) {
        // skip dimensions that are not wrapped around
        if (fWrap[dim] == 0) continue;
        // FIXME only one wrapping coordinate correctly supported in Set()
        if ((f_cell_index[dim] < fWrap[dim]) ||
            (fSize[dim] - f_cell_index[dim] - 1 < fWrap[dim])) {
          // there are equivalent grid points
          for (size_t wrap = 0; wrap < fWrap[dim]; wrap++) {
            // at the minimum
            f_cell_index[dim] = wrap;
            linear_index = Index(f_cell_index);
            status &= Set(linear_index, value);
            // at the maximum
            f_cell_index[dim] = fSize[dim] - wrap - 1;
            linear_index = Index(f_cell_index);
            status &= Set(linear_index, value);
            // set flag
            written = true;
          }
        }
      }
      if (not written) {
        // this is an unambiguous grid point
        linear_index = Index(f_cell_index);
        status &= Set(linear_index, value);
      }
      return status;
    };

References Check(), f_cell_index, fNDim, fSize, fWrap, Index(), Nearest(), and Set().

Here is the call graph for this function:

Set() [4/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const unsigned int * cell_index, const value_t & value )

inline

Set a single value at a grid point (false if out of bounds)

Definition at line 317 of file QwInterpolator.h.

                                                                   {
      if (value_n != 1) return false; // only for one-dimensional values
      return Set(cell_index, &value);
    };

References Set().

Here is the call graph for this function:

Set() [5/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const unsigned int * cell_index, const value_t * value )

inline

Set a set of values at a grid point (false if out of bounds)

Definition at line 322 of file QwInterpolator.h.

                                                                   {
      if (! Check(cell_index)) return false; // out of bounds
      return Set(Index(cell_index),value);
    };

References Check(), Index(), and Set().

Here is the call graph for this function:

Set() [6/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const unsigned int linear_index, const value_t & value )

inline

Set a single value at a linearized index (false if not possible)

Definition at line 303 of file QwInterpolator.h.

                                                                    {
      if (value_n != 1) return false; // only for one-dimensional values
      return Set(linear_index, &value);
    };

References Set().

Here is the call graph for this function:

Set() [7/7]

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::Set ( const unsigned int linear_index, const value_t * value )

inline

Set a set of values at a linearized index (false if not possible)

Definition at line 308 of file QwInterpolator.h.

                                                                    {
      if (! Check(linear_index)) return false; // out of bounds
      for (unsigned int i = 0; i < value_n; i++)
        fValues[i][linear_index] = value[i];
      fCurrentEntries++;
      return true;
    };

References Check(), fCurrentEntries, and fValues.

Here is the call graph for this function:

SetDataReductionFactor() [1/3]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetDataReductionFactor ( const std::vector< unsigned int > & redux )

inline

Definition at line 204 of file QwInterpolator.h.

                                                                      {
      if (redux.size() != fNDim) return;
      fRedux = redux;
    }

References fNDim, and fRedux.

SetDataReductionFactor() [2/3]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetDataReductionFactor ( const unsigned int dim, const unsigned int redux )

inline

Set data reduction factor.

Definition at line 198 of file QwInterpolator.h.

      { fRedux.at(dim) = redux; }

References fRedux.

Referenced by SetDataReductionFactor().

Here is the caller graph for this function:

SetDataReductionFactor() [3/3]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetDataReductionFactor ( const unsigned int redux )

inline

Definition at line 200 of file QwInterpolator.h.

                                                          {
      for (unsigned int dim = 0; dim < fNDim; dim++)
        SetDataReductionFactor(dim,redux);
    }

References fNDim, and SetDataReductionFactor().

Here is the call graph for this function:

SetDimensions()

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetDimensions ( const unsigned int ndim )

inline

Set the number of coordinate dimensions and resize vectors.

Definition at line 131 of file QwInterpolator.h.

                                                {
      if (ndim == 0) {
        mycerr << "Dimensions of the grid should be strictly positive!" << myendl;
        return;
      }
      fNDim = ndim;
      fMin.resize(fNDim); fMax.resize(fNDim); fStep.resize(fNDim); fWrap.resize(fNDim);
      fSize.resize(fNDim); fExtent.resize(fNDim+1);
    };

References fExtent, fMax, fMin, fNDim, fSize, fStep, fWrap, mycerr, and myendl.

Referenced by QwInterpolator(), QwInterpolator(), ReadBinaryFile(), ReadText(), and SetMinimumMaximumStep().

Here is the caller graph for this function:

SetInterpolationMethod()

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetInterpolationMethod ( const EQwInterpolationMethod method )

inline

Set the interpolation method.

Definition at line 210 of file QwInterpolator.h.

      { fInterpolationMethod = method; };

References fInterpolationMethod.

Referenced by QwInterpolator(), QwInterpolator(), and QwInterpolator().

Here is the caller graph for this function:

SetMinimumMaximumStep() [1/2]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetMinimumMaximumStep ( const coord_t min, const coord_t max, const coord_t step )

inline

Set minimum, maximum, and step size to single values.

Definition at line 141 of file QwInterpolator.h.

                                                                                         {
      SetMinimumMaximumStep(std::vector<coord_t>(fNDim,min),
          std::vector<coord_t>(fNDim,max),
          std::vector<coord_t>(fNDim,step));
    };

References fNDim, and SetMinimumMaximumStep().

Referenced by QwInterpolator(), ReadBinaryFile(), ReadText(), and SetMinimumMaximumStep().

Here is the call graph for this function:

Here is the caller graph for this function:

SetMinimumMaximumStep() [2/2]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetMinimumMaximumStep ( const std::vector< coord_t > & min, const std::vector< coord_t > & max, const std::vector< coord_t > & step )

inline

Set minimum, maximum, and step size to different values.

Definition at line 147 of file QwInterpolator.h.

                                        {
      // Set the dimensionality
      if (min.size() != fNDim) SetDimensions(min.size());
      // Check the dimensionality and assign boundaries and step size vectors
      if (min.size() != fNDim || min.size() != fNDim || step.size() != fNDim) return;
      fMin = min; fMax = max; fStep = step;
      fExtent[0] = 1;
      for (size_t i = 0; i < fMin.size(); i++) {
        coord_t int_part; // safer to use modf than a direct static cast
        coord_t frac_part = modf((fMax[i] - fMin[i]) / fStep[i] + 1.0, &int_part);
        fSize[i] = static_cast<unsigned int>(int_part) + (frac_part > 0.5 ? 1 : 0);
        fExtent[i+1] = fExtent[i] * fSize[i];
      }
      // Try resizing to allocate memory and initialize with zeroes
      fMaximumEntries = fExtent[fNDim]; fCurrentEntries = 0; // no entries read yet
      for (unsigned int i = 0; i < value_n; i++) {
        try {
          fValues[i].resize(fMaximumEntries,0);
        } catch (std::bad_alloc& e) {
          mycerr << "QwInterpolator could not allocate memory for values!" << myendl;
        }
      }
    };

References fCurrentEntries, fExtent, fMax, fMaximumEntries, fMin, fNDim, fSize, fStep, fValues, mycerr, myendl, and SetDimensions().

Here is the call graph for this function:

SetWrapCoordinate() [1/2]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetWrapCoordinate ( const std::vector< size_t > & wrap )

inline

Definition at line 189 of file QwInterpolator.h.

                                                          {
      if (wrap.size() != fNDim) return;
      fWrap = wrap;
    }

References fNDim, and fWrap.

SetWrapCoordinate() [2/2]

template<class value_t = float, unsigned int value_n = 1>

void QwInterpolator< value_t, value_n >::SetWrapCoordinate ( const unsigned int dim, const size_t wrap = 1 )

inline

Set wrapping coordinate.

Definition at line 187 of file QwInterpolator.h.

      { fWrap.at(dim) = wrap; }

References fWrap.

WriteBinaryFile()

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::WriteBinaryFile ( const std::string & filename ) const

inline

Write the grid values to binary file.

Write the grid values to binary file (should be 64-bit safe, untested)

Integer data types can be stored differently on 32-bit and 64-bit systems. Fixed-length types uint32_t and u_int32_t are provided in stdint.h and sys/types.h, respectively. The floating point types float and double will always have a length of 32 and 64 bit, per the IEEE convention.

Parameters

filename

File name

Returns

True if written successfully

Definition at line 795 of file QwInterpolator.h.

{
  std::ofstream file(filename.c_str(), std::ios::binary);
  if (! file.is_open()) return false;
  // Informational message
  mycout << "Writing binary file: ";
  // Write template parameters
  uint32_t n = value_n; // uint32_t has length of 32 bits on any system
  uint32_t size = sizeof(value_t);
  file.write(reinterpret_cast<const char*>(&n), sizeof(n));
  file.write(reinterpret_cast<const char*>(&size), sizeof(size));
  // Write grid parameters
  uint32_t ndim = fNDim;
  file.write(reinterpret_cast<const char*>(&ndim), sizeof(ndim));
  for (unsigned int dim = 0; dim < fNDim; dim++) {
    file.write(reinterpret_cast<const char*>(&fMin[dim]),sizeof(fMin[dim]));
    file.write(reinterpret_cast<const char*>(&fMax[dim]),sizeof(fMax[dim]));
    file.write(reinterpret_cast<const char*>(&fStep[dim]),sizeof(fStep[dim]));
  }
  uint32_t entries = fValues[0].size();
  file.write(reinterpret_cast<const char*>(&entries),sizeof(entries));
  for (unsigned int index = 0; index < entries; index++) {
    // Write values
    for (unsigned int i = 0; i < value_n; i++) {
      value_t value = fValues[i][index];
      file.write(reinterpret_cast<const char*>(&value),sizeof(value));
    }
    // Progress bar
    if (index % (entries / 10) == 0)
      mycout << index / (entries / 100) << "%" << QwLog::flush;
    if (index % (entries / 10) != 0
     && index % (entries / 40) == 0)
      mycout << "." << QwLog::flush;
  }
  mycout << myendl;
  file.close();
  return true;
}

References QwLog::flush(), fMax, fMin, fNDim, fStep, fValues, mycout, and myendl.

Here is the call graph for this function:

WriteText()

template<class value_t, unsigned int value_n>

bool QwInterpolator< value_t, value_n >::WriteText ( std::ostream & stream ) const

inline

Write the grid as text.

Write the grid values to a text stream

Parameters

stream

Output stream

Definition at line 710 of file QwInterpolator.h.

{
  // Informational message
  mycout << "Writing text stream: ";
  // Write the dimensions
  stream << fNDim << "\t" << value_n << std::endl;
  // Write the grid parameters
  for (unsigned int dim = 0; dim < fNDim; dim++)
    stream << dim << "\t" << fMin[dim] << "\t" << fMax[dim] << "\t" << fStep[dim] << std::endl;
  // Write the values
  stream << fValues[0].size() << std::endl;
  unsigned int entries = fValues[0].size();
  for (unsigned int index = 0; index < entries; index++) {
    // Write values
    for (unsigned int i = 0; i < value_n; i++) {
      stream << fValues[i][index] << "\t";
    }
    stream << std::endl;
    // Progress bar
    if (index % (entries / 10) == 0)
      mycout << index / (entries / 100) << "%" << QwLog::flush;
    if (index % (entries / 10) != 0
     && index % (entries / 40) == 0)
      mycout << "." << QwLog::flush;
  }
  stream << "end" << std::endl;
  mycout << myendl;
  return true;
}

References QwLog::flush(), fMax, fMin, fNDim, fStep, fValues, mycout, and myendl.

Referenced by WriteTextFile(), and WriteTextScreen().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteTextFile()

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::WriteTextFile ( const std::string & filename ) const

inline

Write the grid to text file.

Definition at line 377 of file QwInterpolator.h.

                                                        {
      std::ofstream file(filename.c_str());
      if (! file.is_open()) return false;
      WriteText(file);
      file.close();
      return true;
    };

References WriteText().

Here is the call graph for this function:

WriteTextScreen()

template<class value_t = float, unsigned int value_n = 1>

bool QwInterpolator< value_t, value_n >::WriteTextScreen ( ) const

inline

Write the grid to screen.

Definition at line 385 of file QwInterpolator.h.

                                 {
      WriteText(std::cout);
      return true;
    };

References WriteText().

Here is the call graph for this function:

Field Documentation

f_cell_index

template<class value_t = float, unsigned int value_n = 1>

unsigned int* QwInterpolator< value_t, value_n >::f_cell_index

private

Pre-allocated cell index.

Definition at line 120 of file QwInterpolator.h.

Referenced by Coord(), Index(), Linear(), NearestNeighbor(), PrintCoverage(), QwInterpolator(), QwInterpolator(), QwInterpolator(), Set(), and ~QwInterpolator().

f_cell_local

template<class value_t = float, unsigned int value_n = 1>

double* QwInterpolator< value_t, value_n >::f_cell_local

private

Pre-allocated local coordinates.

Definition at line 122 of file QwInterpolator.h.

Referenced by Cell(), Linear(), Nearest(), QwInterpolator(), QwInterpolator(), QwInterpolator(), and ~QwInterpolator().

fCurrentEntries

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::fCurrentEntries

private

Number of values read in.

Definition at line 115 of file QwInterpolator.h.

Referenced by GetCurrentEntries(), Set(), and SetMinimumMaximumStep().

fExtent

template<class value_t = float, unsigned int value_n = 1>

std::vector<size_t> QwInterpolator< value_t, value_n >::fExtent

private

Linear extent between neighbor points in each dimension (e.g. for the least significant index this will be 1, for the next index the number of points in the first index, etc...)

Definition at line 109 of file QwInterpolator.h.

Referenced by Cell(), Index(), Index(), SetDimensions(), and SetMinimumMaximumStep().

fInterpolationMethod

template<class value_t = float, unsigned int value_n = 1>

EQwInterpolationMethod QwInterpolator< value_t, value_n >::fInterpolationMethod

private

Interpolation method.

Definition at line 126 of file QwInterpolator.h.

Referenced by GetInterpolationMethod(), GetValue(), and SetInterpolationMethod().

fMax

template<class value_t = float, unsigned int value_n = 1>

std::vector<coord_t> QwInterpolator< value_t, value_n >::fMax

private

Maximum in each dimension.

Definition at line 96 of file QwInterpolator.h.

Referenced by Check(), GetMaximum(), ReadBinaryFile(), ReadText(), SetDimensions(), SetMinimumMaximumStep(), WriteBinaryFile(), and WriteText().

fMaximumEntries

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::fMaximumEntries

private

Maximum number of values.

Definition at line 117 of file QwInterpolator.h.

Referenced by Check(), GetMaximumEntries(), PrintCoverage(), ReadBinaryFile(), and SetMinimumMaximumStep().

fMin

template<class value_t = float, unsigned int value_n = 1>

std::vector<coord_t> QwInterpolator< value_t, value_n >::fMin

private

Minimum in each dimension.

Definition at line 94 of file QwInterpolator.h.

Referenced by Cell(), Check(), Coord(), GetMinimum(), ReadBinaryFile(), ReadText(), SetDimensions(), SetMinimumMaximumStep(), WriteBinaryFile(), and WriteText().

fNDim

template<class value_t = float, unsigned int value_n = 1>

unsigned int QwInterpolator< value_t, value_n >::fNDim

private

Number of dimensions in coordinates.

Definition at line 91 of file QwInterpolator.h.

Referenced by Cell(), Cell(), Check(), Check(), Coord(), GetValue(), Index(), Index(), Linear(), Nearest(), PrintCoverage(), QwInterpolator(), QwInterpolator(), QwInterpolator(), ReadBinaryFile(), ReadText(), Set(), Set(), SetDataReductionFactor(), SetDataReductionFactor(), SetDimensions(), SetMinimumMaximumStep(), SetMinimumMaximumStep(), SetWrapCoordinate(), WriteBinaryFile(), and WriteText().

fRedux

template<class value_t = float, unsigned int value_n = 1>

std::vector<size_t> QwInterpolator< value_t, value_n >::fRedux

private

Data reduction factor.

Definition at line 104 of file QwInterpolator.h.

Referenced by GetDataReductionFactor(), SetDataReductionFactor(), and SetDataReductionFactor().

fSize

template<class value_t = float, unsigned int value_n = 1>

std::vector<size_t> QwInterpolator< value_t, value_n >::fSize

private

Number of points in each dimension.

Definition at line 100 of file QwInterpolator.h.

Referenced by Cell(), Check(), PrintCoverage(), Set(), SetDimensions(), and SetMinimumMaximumStep().

fStep

template<class value_t = float, unsigned int value_n = 1>

std::vector<coord_t> QwInterpolator< value_t, value_n >::fStep

private

Step size in each dimension.

Definition at line 98 of file QwInterpolator.h.

Referenced by Cell(), Coord(), GetStepSize(), ReadBinaryFile(), ReadText(), SetDimensions(), SetMinimumMaximumStep(), WriteBinaryFile(), and WriteText().

fValues

template<class value_t = float, unsigned int value_n = 1>

std::vector<value_t> QwInterpolator< value_t, value_n >::fValues[value_n]

private

Table with pointers to arrays of values.

Definition at line 112 of file QwInterpolator.h.

Referenced by Get(), Get(), Get(), ReadBinaryFile(), ReadText(), Set(), SetMinimumMaximumStep(), WriteBinaryFile(), and WriteText().

fWrap

template<class value_t = float, unsigned int value_n = 1>

std::vector<size_t> QwInterpolator< value_t, value_n >::fWrap

private

Wrap around this coordinate.

Definition at line 102 of file QwInterpolator.h.

Referenced by Cell(), Check(), GetWrapCoordinate(), Set(), SetDimensions(), SetWrapCoordinate(), and SetWrapCoordinate().

---

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

• QwInterpolator.h