Position-sorted indexable objects. More...

Functions
template<class T1 , class T2 , class T3 >
T3	indexOf (const T1 &arr, T3 sz, const T2 &val, T3 notfoundval)

template<class T1 , class T2 , class T3 >
T3	derefIndexOf (const T1 &arr, T3 sz, const T2 &val, T3 notfoundval)

template<class T1 , class T2 , class T3 >
bool	findPos (const T1 &posarr, T3 sz, T2 pos, T3 beforefirst, T3 &idx)

template<class T1 , class T2 , class T3 >
bool	findFPPos (const T1 &posarr, T3 sz, T2 pos, T3 beforefirst, T3 &idx, T2 eps=mDefEps)

template<class X >
int	getLowIdx (const X &x, int sz, double pos)

template<class X >
int	getUpperIdx (const X &x, int sz, double pos)

template<class X , class Y , class RT >
void	interpolatePositioned (const X &x, const Y &y, int sz, float desiredx, RT &ret, bool extrapolate=false)

template<class X , class Y >
float	interpolatePositioned (const X &x, const Y &y, int sz, float pos, bool extrapolate=false)

template<class T >
int	getInterpolateIdxsWithOff (const T &idxabl, od_int64 sz, od_int64 offset, float pos, bool extrap, float snapdist, od_int64 p[4])

template<class T >
int	getInterpolateIdxs (const T &idxabl, int sz, float pos, bool extrap, float snapdist, od_int64 p[4])

template<class T , class RT >
bool	interpolateReg (const T &idxabl, int sz, float pos, RT &ret, bool extrapolate=false, float snapdist=mDefEps)

template<class T , class RT >
bool	interpolateRegWithUdfWithOff (const T &idxabl, od_int64 sz, od_int64 offset, float pos, RT &ret, bool extrapolate=false, float snapdist=mDefEps)

template<class T , class RT >
bool	interpolateRegWithUdf (const T &idxabl, int sz, float pos, RT &ret, bool extrapolate=false, float snapdist=mDefEps)

template<class T >
float	interpolateReg (const T &idxabl, int sz, float pos, bool extrapolate=false, float snapdist=mDefEps)

template<class T >
float	interpolateRegWithUdf (const T &idxabl, int sz, float pos, bool extrapolate=false, float snapdist=mDefEps)

template<class T >
void	calibrateArray (const T input, int sz, const T controlpts, const int controlsamples, int nrcontrols, bool usefactor, T output, float *calibrationcurve=0)

template<class T , class RT >
void	interpolateYPeriodicReg (const T &idxabl, int sz, float pos, RT &ret, RT period, bool extrapolate=false)

template<class T >
float	interpolateYPeriodicReg (const T &idxabl, int sz, float pos, float period, bool extrapolate=false)

template<class T , class RT >
void	interpolateXPeriodicReg (const T &idxabl, int sz, float pos, RT &ret)

Detailed Description

Position-sorted indexable objects.

These are objects that return a value of type T when the [] operator is applied. Can range from simple arrays and TypeSets to whatever supports the [] operator. The goal is to interpolate between the values. Therefore, the position of the values must be known from either the fact that the values are regular samples or by specifying another indexable object that provides the positions (in float or double).

Function Documentation

template<class T >

void IdxAble::calibrateArray	(	const T *	input,
		int	sz,
		const T *	controlpts,
		const int *	controlsamples,
		int	nrcontrols,
		bool	usefactor,
		T *	output,
		float *	calibrationcurve = `0`
	)

inline

template<class T1 , class T2 , class T3 >

T3 IdxAble::derefIndexOf	(	const T1 &	arr,
		T3	sz,
		const T2 &	val,
		T3	notfoundval
	)

inline

Find value in indexable filled with pointers.

template<class T1 , class T2 , class T3 >

bool IdxAble::findFPPos	(	const T1 &	posarr,
		T3	sz,
		T2	pos,
		T3	beforefirst,
		T3 &	idx,
		T2	eps = `mDefEps`
	)

Find value in sorted array of floating point positions. Equality is tested by mIsZero. The 'arr' indexable object must return the positions. The return par 'idx' may be beforefirst, which means that 'pos' is before the first position. Return value tells whether there is an exact match. If false, index of array member below pos is returned.

template<class T1 , class T2 , class T3 >

bool IdxAble::findPos	(	const T1 &	posarr,
		T3	sz,
		T2	pos,
		T3	beforefirst,
		T3 &	idx
	)

Find value in sorted array of positions. Equality is tested by == operator -> not for float/double! The 'arr' indexable object must return the positions. The return par 'idx' may be -1, which means that 'pos' is before the first position. Return value tells whether there is an exact match. If false, index of array member below pos is returned.

template<class T >

int IdxAble::getInterpolateIdxs	(	const T &	idxabl,
		int	sz,
		float	pos,
		bool	extrap,
		float	snapdist,
		od_int64	p[4]
	)

inline

template<class T >

int IdxAble::getInterpolateIdxsWithOff	(	const T &	idxabl,
		od_int64	sz,
		od_int64	offset,
		float	pos,
		bool	extrap,
		float	snapdist,
		od_int64	p[4]
	)

inline

If pos is large, it will loose it's precision. Therefore the target position in the array is pos+offset.

template<class X >

int IdxAble::getLowIdx	(	const X &	x,
		int	sz,
		double	pos
	)

inline

Find index of nearest point below a given position. The 'x' must return the positions. The return value may be -1, which means that 'pos' is before the first position.

template<class X >

int IdxAble::getUpperIdx	(	const X &	x,
		int	sz,
		double	pos
	)

inline

Find index of nearest point above a given position. The 'x' must return the positions. The return value will be 1 if 'pos' is before the second The return value will be equal to sz if 'pos' if after the last position.

template<class T1 , class T2 , class T3 >

T3 IdxAble::indexOf	(	const T1 &	arr,
		T3	sz,
		const T2 &	val,
		T3	notfoundval
	)

inline

Find value in indexable

template<class X , class Y , class RT >

void IdxAble::interpolatePositioned	(	const X &	x,
		const Y &	y,
		int	sz,
		float	desiredx,
		RT &	ret,
		bool	extrapolate = `false`
	)

inline

Irregular interpolation. The 'x' must return the X-positions of the 'y' values.

template<class X , class Y >

float IdxAble::interpolatePositioned	(	const X &	x,
		const Y &	y,
		int	sz,
		float	pos,
		bool	extrapolate = `false`
	)

inline

template<class T , class RT >

bool IdxAble::interpolateReg	(	const T &	idxabl,
		int	sz,
		float	pos,
		RT &	ret,
		bool	extrapolate = `false`,
		float	snapdist = `mDefEps`
	)

inline

template<class T >

float IdxAble::interpolateReg	(	const T &	idxabl,
		int	sz,
		float	pos,
		bool	extrapolate = `false`,
		float	snapdist = `mDefEps`
	)

inline

template<class T , class RT >

bool IdxAble::interpolateRegWithUdf	(	const T &	idxabl,
		int	sz,
		float	pos,
		RT &	ret,
		bool	extrapolate = `false`,
		float	snapdist = `mDefEps`
	)

inline

template<class T >

float IdxAble::interpolateRegWithUdf	(	const T &	idxabl,
		int	sz,
		float	pos,
		bool	extrapolate = `false`,
		float	snapdist = `mDefEps`
	)

inline

template<class T , class RT >

bool IdxAble::interpolateRegWithUdfWithOff	(	const T &	idxabl,
		od_int64	sz,
		od_int64	offset,
		float	pos,
		RT &	ret,
		bool	extrapolate = `false`,
		float	snapdist = `mDefEps`
	)

inline

If pos is large, it will loose it's precision. Therefore the target position in the array is pos+offset.

template<class T , class RT >

void IdxAble::interpolateXPeriodicReg	(	const T &	idxabl,
		int	sz,
		float	pos,
		RT &	ret
	)

inline

interpolateXPeriodicReg interpolates in an periodic indexable ( where the position is periodic ), defined by y(x) = x(x+n*P). The period is equal to the size of the given idxabl.

template<class T , class RT >

void IdxAble::interpolateYPeriodicReg	(	const T &	idxabl,
		int	sz,
		float	pos,
		RT &	ret,
		RT	period,
		bool	extrapolate = `false`
	)

inline

interpolateYPeriodicReg interpolates in an indexable storage with periodic entities ( defined by y(x) = y(x) + N*P )

template<class T >

float IdxAble::interpolateYPeriodicReg	(	const T &	idxabl,
		int	sz,
		float	pos,
		float	period,
		bool	extrapolate = `false`
	)

inline

Functions

Detailed Description

Function Documentation