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

#include <QwInterpolator.h>

Inheritance diagram for QwInterpolator< value_t, value_n >:

Public Member Functions
	QwInterpolator (const unsigned int ndim=1)
	Constructor with number of dimensions. More...

	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. More...

	QwInterpolator (const std::string &filename)
	Constructor with file name. More...

virtual	~QwInterpolator ()
	Destructor. More...

void	SetDimensions (const unsigned int ndim)
	Set the number of coordinate dimensions and resize vectors. More...

void	SetMinimumMaximumStep (const coord_t min, const coord_t max, const coord_t step)
	Set minimum, maximum, and step size to single values. More...

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. More...

coord_t	GetMinimum (const unsigned int dim) const
	Get minimum in dimension. More...

coord_t	GetMaximum (const unsigned int dim) const
	Get maximum in dimension. More...

coord_t	GetStepSize (const unsigned int dim) const
	Get minimum in dimension. More...

unsigned int	GetMaximumEntries () const
	Get the maximum number of entries. More...

unsigned int	GetCurrentEntries () const
	Get the current number of entries. More...

unsigned int	GetWrapCoordinate (const unsigned int dim) const
	Get wrapping coordinate. More...

void	SetWrapCoordinate (const unsigned int dim, const size_t wrap=1)
	Set wrapping coordinate. More...

void	SetWrapCoordinate (const std::vector< size_t > &wrap)

int	GetDataReductionFactor (const unsigned int dim) const
	Get data reduction factor. More...

void	SetDataReductionFactor (const unsigned int dim, const unsigned int redux)
	Set data reduction factor. More...

void	SetDataReductionFactor (const unsigned int redux)

void	SetDataReductionFactor (const std::vector< unsigned int > &redux)

void	SetInterpolationMethod (const EQwInterpolationMethod method)
	Set the interpolation method. More...

EQwInterpolationMethod	GetInterpolationMethod () const
	Get the interpolation method. More...

void	PrintCoverage (const unsigned int dim)
	Print coverage map for all bins in one dimension. More...

bool	InBounds (const coord_t *coord) const
	Return true if the coordinate is in bounds. More...

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) More...

bool	Set (const coord_t *coord, const value_t &value)
	Set a single value at a coordinate (false if not possible) More...

bool	Set (const coord_t coord, const value_t value)
	Set a set of values at a coordinate (false if not possible) More...

bool	Set (const unsigned int linear_index, const value_t &value)
	Set a single value at a linearized index (false if not possible) More...

bool	Set (const unsigned int linear_index, const value_t *value)
	Set a set of values at a linearized index (false if not possible) More...

bool	Set (const unsigned int *cell_index, const value_t &value)
	Set a single value at a grid point (false if out of bounds) More...

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) More...

Functions to retrieve interpolated values
value_t	GetValue (const coord_t &coord) const
	Get the interpolated value at coordinate (zero if out of bounds) More...

value_t	GetValue (const coord_t *coord) const
	Get the interpolated value at coordinate (zero if out of bounds) More...

bool	GetValue (const coord_t *coord, double &value) const
	Get the interpolated value at coordinate (zero if out of bounds) More...

bool	GetValue (const coord_t coord, double value) const
	Get the interpolated value at coordinate (zero if out of bounds) More...

File reading and writing
bool	WriteText (std::ostream &stream) const
	Write the grid as text. More...

bool	WriteTextFile (const std::string &filename) const
	Write the grid to text file. More...

bool	WriteTextScreen () const
	Write the grid to screen. More...

bool	ReadText (std::istream &stream)
	Read the grid from text. More...

bool	ReadTextFile (const std::string &filename)
	Read the grid from text file. More...

bool	WriteBinaryFile (const std::string &filename) const
	Write the grid values to binary file. More...

bool	ReadBinaryFile (const std::string &filename)
	Read the grid values from binary file. More...

Indexing functions (publicly available and unchecked)
unsigned int	Index (const coord_t *coord) const
	Return the linearized index based on the point coordinates (unchecked) More...

unsigned int	Index (const unsigned int *cell_index) const
	Return the linearized index based on the cell indices (unchecked) More...

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) More...

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) More...

void	Cell (const coord_t coord, unsigned int cell_index, double *cell_local) const
	Return the cell index and local coordinates (unchecked) More...

void	Cell (const coord_t coord, unsigned int cell_index) const
	Return the cell index (unchecked) More...

void	Cell (unsigned int linear_index, unsigned int *cell_index) const
	Return the cell index based on the linearized index (unchecked) More...

void	Coord (const unsigned int cell_index, coord_t coord) const
	Return the coordinates based on the cell index (unchecked) More...

void	Coord (const unsigned int linear_index, coord_t *coord) const
	Return the coordinates based on the linearized index (unchecked) More...

Private Member Functions
void	Nearest (const coord_t coord, unsigned int cell_index) const
	Return the cell index closest to the coordinate (could be above) (unchecked) More...

bool	Linear (const coord_t coord, value_t value) const
	Linear interpolation (unchecked) More...

bool	NearestNeighbor (const coord_t coord, value_t value) const
	Nearest-neighbor (unchecked) More...

bool	Check (const coord_t *coord) const
	Check for boundaries with coordinate argument. More...

bool	Check (const unsigned int *cell_index) const
	Check for boundaries with cell index argument. More...

bool	Check (const unsigned int linear_index) const
	Check for boundaries with linearized index argument. More...

value_t	Get (const unsigned int *cell_index) const
	Get a single value by cell index (unchecked) More...

value_t	Get (const unsigned int index) const
	Get a single value by linearized index (unchecked) More...

bool	Get (const unsigned int index, value_t *value) const
	Get a vector value by linearized index (unchecked) More...

Private Attributes
unsigned int	fNDim
	Number of dimensions in coordinates. More...

std::vector< coord_t >	fMin
	Minimum in each dimension. More...

std::vector< coord_t >	fMax
	Maximum in each dimension. More...

std::vector< coord_t >	fStep
	Step size in each dimension. More...

std::vector< size_t >	fSize
	Number of points in each dimension. More...

std::vector< size_t >	fWrap
	Wrap around this coordinate. More...

std::vector< size_t >	fRedux
	Data reduction factor. More...

std::vector< size_t >	fExtent

std::vector< value_t >	fValues [value_n]
	Table with pointers to arrays of values. More...

unsigned int	fCurrentEntries
	Number of values read in. More...

unsigned int	fMaximumEntries
	Maximum number of values. More...

unsigned int *	f_cell_index
	Pre-allocated cell index. More...

double *	f_cell_local
	Pre-allocated local coordinates. More...

EQwInterpolationMethod	fInterpolationMethod
	Interpolation method. More...

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 51 of file QwInterpolator.h.

Constructor & Destructor Documentation

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 56 of file QwInterpolator.h.

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

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 63 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];
     };

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 73 of file QwInterpolator.h.

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

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

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

inlinevirtual

Destructor.

Definition at line 80 of file QwInterpolator.h.

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

Member Function Documentation

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)

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 609 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::Index(), QwInterpolator< float, 4 >::Nearest(), and QwInterpolator< float, 4 >::PrintCoverage().

 {
   // 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]);
 }

Here is the caller graph for this function:

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)

Parameters

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

Definition at line 633 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);
 }

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)

Parameters

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

Definition at line 649 of file QwInterpolator.h.

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

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)

Parameters

linear_index	Linearized index
cell_index	Cell index (reference)

Definition at line 663 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];
   }
 }

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 525 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::GetValue(), QwInterpolator< float, 4 >::InBounds(), and QwInterpolator< float, 4 >::Set().

 {
   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;
 }

Here is the caller graph for this function:

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 540 of file QwInterpolator.h.

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

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 555 of file QwInterpolator.h.

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

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)

Parameters

cell_index	Cell index
coord	Point coordinates (reference)

Definition at line 680 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::PrintCoverage(), and QwMatrixLookup::WriteTrajMatrix().

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

Here is the caller graph for this function:

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)

Parameters

linear_index	Linearized index
coord	Point coordinates (reference)

Definition at line 694 of file QwInterpolator.h.

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

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 454 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::PrintCoverage().

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

Here is the caller graph for this function:

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 460 of file QwInterpolator.h.

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

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 464 of file QwInterpolator.h.

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

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 178 of file QwInterpolator.h.

Referenced by QwMatrixLookup::LoadTrajMatrix(), QwMagneticField::ReadFieldMapStream(), and QwMatrixLookup::WriteTrajMatrix().

178 { return fCurrentEntries; };

QwInterpolator::fCurrentEntries

unsigned int fCurrentEntries

Number of values read in.

Definition: QwInterpolator.h:112

Here is the caller graph for this function:

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 192 of file QwInterpolator.h.

193 { return fRedux.at(dim); }

QwInterpolator::fRedux

std::vector< size_t > fRedux

Data reduction factor.

Definition: QwInterpolator.h:101

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 210 of file QwInterpolator.h.

Referenced by QwMagneticField::GetInterpolationMethod().

211 { return fInterpolationMethod; };

QwInterpolator::fInterpolationMethod

EQwInterpolationMethod fInterpolationMethod

Interpolation method.

Definition: QwInterpolator.h:123

Here is the caller graph for this function:

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 172 of file QwInterpolator.h.

Referenced by QwMatrixLookup::Bridge().

172 { return fMax.at(dim); };

QwInterpolator::fMax

std::vector< coord_t > fMax

Maximum in each dimension.

Definition: QwInterpolator.h:93

Here is the caller graph for this function:

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 176 of file QwInterpolator.h.

Referenced by QwMatrixLookup::LoadTrajMatrix(), QwMagneticField::ReadFieldMapStream(), and QwMatrixLookup::WriteTrajMatrix().

176 { return fMaximumEntries; };

QwInterpolator::fMaximumEntries

unsigned int fMaximumEntries

Maximum number of values.

Definition: QwInterpolator.h:114

Here is the caller graph for this function:

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 170 of file QwInterpolator.h.

Referenced by QwMatrixLookup::Bridge().

170 { return fMin.at(dim); };

QwInterpolator::fMin

std::vector< coord_t > fMin

Minimum in each dimension.

Definition: QwInterpolator.h:91

Here is the caller graph for this function:

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 174 of file QwInterpolator.h.

Referenced by QwMatrixLookup::Bridge().

174 { return fStep.at(dim); };

QwInterpolator::fStep

std::vector< coord_t > fStep

Step size in each dimension.

Definition: QwInterpolator.h:95

Here is the caller graph for this function:

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 329 of file QwInterpolator.h.

Referenced by QwMatrixLookup::Bridge(), QwMagneticField::GetFieldValue(), and QwInterpolator< float, 4 >::GetValue().

                                                  {
       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
     };

Here is the caller graph for this function:

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 337 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
     };

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 344 of file QwInterpolator.h.

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

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 349 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;
     };

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 181 of file QwInterpolator.h.

182 { return fWrap.at(dim); }

QwInterpolator::fWrap

std::vector< size_t > fWrap

Wrap around this coordinate.

Definition: QwInterpolator.h:99

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 245 of file QwInterpolator.h.

Referenced by QwMatrixLookup::Bridge(), and QwMagneticField::GetFieldValue().

                                               {
       return Check(coord);
     };

Here is the caller graph for this function:

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 406 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::Get(), QwInterpolator< float, 4 >::Index(), and QwInterpolator< float, 4 >::Set().

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

Here is the caller graph for this function:

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)

Parameters

cell_index Index in each dimension

Returns: Linearized index

Definition at line 569 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;
 }

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)

Parameters

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

Returns: Linearized index

Definition at line 587 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;
 }

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 480 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::GetValue().

 {
   // 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;
 }

Here is the caller graph for this function:

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 434 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::Set().

                                                                        {
       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]++;
     };

Here is the caller graph for this function:

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 510 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::GetValue().

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

Here is the caller graph for this function:

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 215 of file QwInterpolator.h.

Referenced by QwMagneticField::ReadFieldMapStream().

                                                {
       // 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;
     }

Here is the caller graph for this function:

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 837 of file QwInterpolator.h.

References QwLog::flush(), mycout, and myendl.

Referenced by QwInterpolator< float, 4 >::QwInterpolator(), and QwMagneticField::ReadFieldMap().

 {
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 743 of file QwInterpolator.h.

References QwLog::flush(), mycout, and myendl.

Referenced by QwInterpolator< float, 4 >::ReadTextFile().

 {
   // 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 389 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;
     };

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 253 of file QwInterpolator.h.

Referenced by QwMatrixLookup::LoadTrajMatrix(), QwMagneticField::ReadFieldMapStream(), QwInterpolator< float, 4 >::Set(), and QwMatrixLookup::WriteTrajMatrix().

                                                          {
       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);
     };

Here is the caller graph for this function:

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 259 of file QwInterpolator.h.

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

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 264 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;
     };

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 300 of file QwInterpolator.h.

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

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 305 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;
     };

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 314 of file QwInterpolator.h.

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

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 319 of file QwInterpolator.h.

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

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 195 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::SetDataReductionFactor().

196 { fRedux.at(dim) = redux; }

QwInterpolator::fRedux

std::vector< size_t > fRedux

Data reduction factor.

Definition: QwInterpolator.h:101

Here is the caller graph for this function:

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 197 of file QwInterpolator.h.

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

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 201 of file QwInterpolator.h.

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

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 128 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::QwInterpolator(), and QwInterpolator< float, 4 >::SetMinimumMaximumStep().

                                                 {
       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);
     };

Here is the caller graph for this function:

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 207 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::QwInterpolator(), QwMatrixLookup::QwMatrixLookup(), and QwMagneticField::SetInterpolationMethod().

208 { fInterpolationMethod = method; };

QwInterpolator::fInterpolationMethod

EQwInterpolationMethod fInterpolationMethod

Interpolation method.

Definition: QwInterpolator.h:123

Here is the caller graph for this function:

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 138 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::QwInterpolator(), QwMatrixLookup::QwMatrixLookup(), and QwInterpolator< float, 4 >::SetMinimumMaximumStep().

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

Here is the caller graph for this function:

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 144 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;
         }
       }
     };

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 184 of file QwInterpolator.h.

Referenced by QwMagneticField::ReadFieldMap().

185 { fWrap.at(dim) = wrap; }

QwInterpolator::fWrap

std::vector< size_t > fWrap

Wrap around this coordinate.

Definition: QwInterpolator.h:99

Here is the caller graph for this function:

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 186 of file QwInterpolator.h.

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

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 792 of file QwInterpolator.h.

References QwLog::flush(), mycout, and myendl.

Referenced by QwMagneticField::WriteBinaryFile().

 {
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 707 of file QwInterpolator.h.

References QwLog::flush(), mycout, and myendl.

Referenced by QwInterpolator< float, 4 >::WriteTextFile(), and QwInterpolator< float, 4 >::WriteTextScreen().

 {
   // 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 374 of file QwInterpolator.h.

Referenced by QwMagneticField::WriteTextFile().

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

Here is the caller graph for this function:

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 382 of file QwInterpolator.h.

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

Field Documentation

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 117 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::Index(), QwInterpolator< float, 4 >::PrintCoverage(), QwInterpolator< float, 4 >::QwInterpolator(), QwInterpolator< float, 4 >::Set(), and QwInterpolator< float, 4 >::~QwInterpolator().

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 119 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::Nearest(), QwInterpolator< float, 4 >::QwInterpolator(), and QwInterpolator< float, 4 >::~QwInterpolator().

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 112 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::GetCurrentEntries(), QwInterpolator< float, 4 >::Set(), and QwInterpolator< float, 4 >::SetMinimumMaximumStep().

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 106 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::SetDimensions(), and QwInterpolator< float, 4 >::SetMinimumMaximumStep().

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

EQwInterpolationMethod QwInterpolator< value_t, value_n >::fInterpolationMethod

private

Interpolation method.

Definition at line 123 of file QwInterpolator.h.

Referenced by QwInterpolator< float, 4 >::GetInterpolationMethod(), QwInterpolator< float, 4 >::GetValue(), and QwInterpolator< float, 4 >::SetInterpolationMethod().

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.