App
Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
app::TLinearFInt< TPIXEL, TCHANNEL > Class Template Reference

#include <TLinearFInt.hpp>

Inheritance diagram for app::TLinearFInt< TPIXEL, TCHANNEL >:
app::TFInterpolator< TPIXEL, TCHANNEL >

Public Member Functions

 TLinearFInt (const TBitmap< TPIXEL, TCHANNEL > &over)
 
virtual int isInitOk () const
 
virtual ~TLinearFInt ()
 
TPIXEL getAt (double x, double y)
 
virtual TPIXEL * getSrcData () const
 
virtual unsigned getSrcWidth () const
 
virtual unsigned getSrcHeight () const
 
virtual int resampleTo (TBitmap< TPIXEL, TCHANNEL > &dst) const
 
virtual int resampleTo_aliased (TBitmap< TPIXEL, TCHANNEL > &dst, double force=1) const
 

Static Public Attributes

static const unsigned chCount = sizeof(TPIXEL) / sizeof(TCHANNEL)
 Počet kanálů bitmapy.
 
static const TCHANNEL maxVal = ~0
 Maximální hodnota kanálu.
 

Protected Member Functions

TPIXEL getAt_4ch (double x, double y)
 
TPIXEL getAt_1ch (double x, double y)
 
virtual int resampleTo_4ch (TBitmap< TPIXEL, TCHANNEL > &dst) const
 Převzorkuje data interpolátoru do cílové bitmapy.
 
virtual int resampleTo_1ch (TBitmap< TPIXEL, TCHANNEL > &dst) const
 Převzorkuje data interpolátoru do cílové bitmapy.
 
virtual TFInterpolator< TPIXEL,
TCHANNEL > * 
newInstance (const TBitmap< TPIXEL, TCHANNEL > &over) const
 

Protected Attributes

TPIXEL * srcData
 
unsigned srcWidth
 
unsigned srcHeight
 
int * xReindex
 
int * yReindex
 
int offset
 
double xNoReindexFrom
 
double xNoReindexTo
 
double yNoReindexFrom
 
double yNoReindexTo
 

Detailed Description

template<typename TPIXEL, typename TCHANNEL>
class app::TLinearFInt< TPIXEL, TCHANNEL >

Definition at line 29 of file TLinearFInt.hpp.

Constructor & Destructor Documentation

template<typename TPIXEL, typename TCHANNEL>
app::TLinearFInt< TPIXEL, TCHANNEL >::TLinearFInt ( const TBitmap< TPIXEL, TCHANNEL > &  over)
inline

Definition at line 217 of file TLinearFInt.hpp.

{
srcData = over.getData();
srcWidth = over.getWidth();
srcHeight = over.getHeight();
int * ptr;
int * ptrEnd;
int i;
xReindex = (int *) malloc((unsigned long int) ((srcWidth + 2) * sizeof(int)));
ptr = xReindex;
ptrEnd = xReindex + srcWidth + 1;
*ptr = 0;
ptr++;
i = 0;
while (ptr < ptrEnd) {
*ptr = i++;
ptr++;
}
*ptr = srcWidth - 1;
yReindex = (int *) malloc((unsigned long int) ((srcHeight + 2) * sizeof(int)));
ptr = yReindex;
ptrEnd = yReindex + srcHeight + 1;
*ptr = 0;
ptr++;
i = 0;
while (ptr < ptrEnd) {
*ptr = i++;
ptr++;
}
*ptr = srcHeight - 1;
}
template<typename TPIXEL , typename TCHANNEL >
TLinearFInt< TPIXEL, TCHANNEL >::~TLinearFInt ( )
virtual

Definition at line 59 of file TLinearFInt.cpp.

{
if (xReindex != NULL) {
free(xReindex);
}
if (yReindex != NULL) {
free(yReindex);
}
}

Member Function Documentation

template<typename TPIXEL, typename TCHANNEL>
TPIXEL app::TLinearFInt< TPIXEL, TCHANNEL >::getAt ( double  x,
double  y 
)
inline

Definition at line 268 of file TLinearFInt.hpp.

{
if (x <= 0 || y <= 0 || x >= srcWidth || y >= srcHeight) {
return 0;
} else if (chCount == 4) {
return getAt_4ch(x, y);
} else if (chCount == 1) {
return getAt_1ch(x, y);
} else {
return 0; // Jen kvůli warningu
}
}
template<typename TPIXEL, typename TCHANNEL>
TPIXEL app::TLinearFInt< TPIXEL, TCHANNEL >::getAt_1ch ( double  x,
double  y 
)
inlineprotected

Využívá 2d verzi interpolace, u bilin je výpočet jednoduchý, rozklad do směrů je zbytečný...

Definition at line 144 of file TLinearFInt.hpp.

{
if (x > xNoReindexFrom && y > yNoReindexFrom && x < xNoReindexTo && y < yNoReindexTo) {
x -= 0.5;
y -= 0.5;
int X = x;
x -= X;
int Y = y;
y -= Y;
TPIXEL retVal = 0;
TPIXEL * px11 = (srcData + (Y) * srcWidth + (X));
TPIXEL * px21 = px11 + 1;
TPIXEL * px12 = px11 + srcWidth;
TPIXEL * px22 = px12 + 1;
TPIXEL p11, p12, p21, p22;
p11 = *(px11);
p12 = *(px12);
p21 = *(px21);
p22 = *(px22);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, retVal)
return retVal;
} else {
x += 0.5;
y += 0.5;
int X = x;
x -= X;
int Y = y;
y -= Y;
TPIXEL retVal = 0;
TPIXEL * px11 = (srcData + yReindex[Y] * srcWidth + xReindex[X]);
TPIXEL * px21 = (srcData + yReindex[Y] * srcWidth + xReindex[X + 1]);
TPIXEL * px12 = (srcData + yReindex[Y + 1] * srcWidth + xReindex[X]);
TPIXEL * px22 = (srcData + yReindex[Y + 1] * srcWidth + xReindex[X + 1]);
px_1x8bit p11, p12, p21, p22;
p11 = *(px11);
p12 = *(px12);
p21 = *(px21);
p22 = *(px22);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, retVal)
return retVal;
}
}
template<typename TPIXEL, typename TCHANNEL>
TPIXEL app::TLinearFInt< TPIXEL, TCHANNEL >::getAt_4ch ( double  x,
double  y 
)
inlineprotected

Využívá 2d verzi interpolace, u bilin je výpočet jednoduchý, rozklad do směrů je zbytečný...

Definition at line 46 of file TLinearFInt.hpp.

{
if (x > xNoReindexFrom && y > yNoReindexFrom && x < xNoReindexTo && y < yNoReindexTo) {
x -= 0.5;
y -= 0.5;
int X = x;
x -= X;
int Y = y;
y -= Y;
TPIXEL retVal = 0;
TCHANNEL * ptr = (TCHANNEL *) &retVal;
TCHANNEL * px11 = (TCHANNEL *) (srcData + (Y) * srcWidth + (X));
TCHANNEL * px21 = px11 + 4;
TCHANNEL * px12 = px11 + offset;
TCHANNEL * px22 = px12 + 4;
TCHANNEL p11, p12, p21, p22;
p11 = *(px11++);
p12 = *(px12++);
p21 = *(px21++);
p22 = *(px22++);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
ptr++;
p11 = *(px11++);
p12 = *(px12++);
p21 = *(px21++);
p22 = *(px22++);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
ptr++;
p11 = *(px11++);
p12 = *(px12++);
p21 = *(px21++);
p22 = *(px22++);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
ptr++;
p11 = *(px11);
p12 = *(px12);
p21 = *(px21);
p22 = *(px22);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
return retVal;
} else {
x -= 0.5;
y -= 0.5;
int X = x;
x -= X;
int Y = y;
y -= Y;
TPIXEL retVal = 0;
TCHANNEL * ptr = (TCHANNEL *) &retVal;
TCHANNEL * px11 = (TCHANNEL *) (srcData + yReindex[Y] * srcWidth + xReindex[X]);
TCHANNEL * px21 = (TCHANNEL *) (srcData + yReindex[Y] * srcWidth + xReindex[X + 1]);
TCHANNEL * px12 = (TCHANNEL *) (srcData + yReindex[Y + 1] * srcWidth + xReindex[X]);
TCHANNEL * px22 = (TCHANNEL *) (srcData + yReindex[Y + 1] * srcWidth + xReindex[X + 1]);
TCHANNEL p11, p12, p21, p22;
p11 = *(px11++);
p12 = *(px12++);
p21 = *(px21++);
p22 = *(px22++);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
ptr++;
p11 = *(px11++);
p12 = *(px12++);
p21 = *(px21++);
p22 = *(px22++);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
ptr++;
p11 = *(px11++);
p12 = *(px12++);
p21 = *(px21++);
p22 = *(px22++);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
ptr++;
p11 = *(px11);
p12 = *(px12);
p21 = *(px21);
p22 = *(px22);
INTERPOLATE_BILINEAR(p11, p12, p21, p22, x, y, *ptr)
return retVal;
}
}
template<typename TPIXEL, typename TCHANNEL>
virtual TPIXEL* app::TLinearFInt< TPIXEL, TCHANNEL >::getSrcData ( ) const
inlinevirtual

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 280 of file TLinearFInt.hpp.

{
return srcData;
}
template<typename TPIXEL, typename TCHANNEL>
virtual unsigned app::TLinearFInt< TPIXEL, TCHANNEL >::getSrcHeight ( ) const
inlinevirtual

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 287 of file TLinearFInt.hpp.

{
return srcHeight;
}
template<typename TPIXEL, typename TCHANNEL>
virtual unsigned app::TLinearFInt< TPIXEL, TCHANNEL >::getSrcWidth ( ) const
inlinevirtual

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 284 of file TLinearFInt.hpp.

{
return srcWidth;
}
template<typename TPIXEL, typename TCHANNEL>
virtual int app::TLinearFInt< TPIXEL, TCHANNEL >::isInitOk ( ) const
inlinevirtual

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 258 of file TLinearFInt.hpp.

{
if (xReindex != NULL && yReindex != NULL) {
return 1;
} else {
return 0;
}
}
template<typename TPIXEL, typename TCHANNEL>
virtual TFInterpolator<TPIXEL, TCHANNEL>* app::TLinearFInt< TPIXEL, TCHANNEL >::newInstance ( const TBitmap< TPIXEL, TCHANNEL > &  over) const
inlineprotectedvirtual

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 209 of file TLinearFInt.hpp.

{
}
template<typename TPIXEL , typename TCHANNEL >
int TFInterpolator< TPIXEL, TCHANNEL >::resampleTo ( TBitmap< TPIXEL, TCHANNEL > &  dst) const
virtualinherited

Definition at line 13 of file TFInterpolator.cpp.

{
if (chCount == 1) {
return resampleTo_1ch(dst);
} else if (chCount == 4) {
return resampleTo_4ch(dst);
} else {
return 100;
}
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFInt< TPIXEL, TCHANNEL >::resampleTo_1ch ( TBitmap< TPIXEL, TCHANNEL > &  dst) const
protectedvirtual

Převzorkuje data interpolátoru do cílové bitmapy.

Parameters
dst
Returns

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 152 of file TLinearFInt.cpp.

{
if (srcData == NULL) {
return 1;
}
TPIXEL * const dstData = dst.getData();
if (dstData == NULL) {
return 2;
}
if (!isInitOk()) {
return 3;
}
unsigned origWidth = srcWidth;
unsigned origHeight = srcHeight;
unsigned dstWidth = dst.getWidth();
unsigned dstHeight = dst.getHeight();
unsigned tmpWidth = srcHeight;
unsigned tmpHeight = dstWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc((unsigned long) (tmpWidth * tmpHeight * sizeof(TPIXEL)));
if (tmpData == NULL) {
return 3;
}
double xDelta = srcWidth / (double) dstWidth;
double xMin = xDelta / 2.0;
double yDelta = srcHeight / (double) dstHeight;
double yMin = yDelta / 2.0;
TPIXEL * sData = srcData; int sWidth = origWidth; int sHeight = origHeight; TPIXEL * dData = tmpData; int dWidth = tmpWidth; int dHeight = tmpHeight; double x0 = xMin; double dx = xDelta; int * reindexer = xReindex; double noReindexFrom = xNoReindexFrom; double noReindexTo = xNoReindexTo; TCHANNEL p1; TCHANNEL p2; int X; double nx;,
nx = x + 0.5; X = nx; nx -= X; p1 = sPtrRowBgn[reindexer[X++]]; p2 = sPtrRowBgn[reindexer[X]]; INTERPOLATE_LINEAR(p1, p2, nx, *dPtr);,
nx = x - 0.5; X = nx; nx -= X; sPtr = sPtrRowBgn + X; p1 = *(sPtr++); p2 = *(sPtr); INTERPOLATE_LINEAR(p1, p2, nx, *dPtr);)
TPIXEL * sData = tmpData; int sWidth = tmpWidth; int sHeight = tmpHeight; TPIXEL * dData = dstData; int dWidth = dstWidth; int dHeight = dstHeight; double x0 = yMin; double dx = yDelta; int * reindexer = yReindex; double noReindexFrom = yNoReindexFrom; double noReindexTo = yNoReindexTo; TCHANNEL p1; TCHANNEL p2; int X; double nx;,
nx = x + 0.5; X = nx; nx -= X; p1 = sPtrRowBgn[reindexer[X++]]; p2 = sPtrRowBgn[reindexer[X]]; INTERPOLATE_LINEAR(p1, p2, nx, *dPtr);,
nx = x - 0.5; X = nx; nx -= X; sPtr = sPtrRowBgn + X; p1 = *(sPtr++); p2 = *(sPtr); INTERPOLATE_LINEAR(p1, p2, nx, *dPtr);)
free(tmpData);
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFInt< TPIXEL, TCHANNEL >::resampleTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  dst) const
protectedvirtual

Převzorkuje data interpolátoru do cílové bitmapy.

Parameters
dst
Returns

Implements app::TFInterpolator< TPIXEL, TCHANNEL >.

Definition at line 69 of file TLinearFInt.cpp.

{
if (srcData == NULL) {
return 1;
}
TPIXEL * const dstData = dst.getData();
if (dstData == NULL) {
return 2;
}
if (!isInitOk()) {
return 3;
}
unsigned origWidth = srcWidth;
unsigned origHeight = srcHeight;
unsigned dstWidth = dst.getWidth();
unsigned dstHeight = dst.getHeight();
unsigned tmpWidth = srcHeight;
unsigned tmpHeight = dstWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc((unsigned long) (tmpWidth * tmpHeight * sizeof(TPIXEL)));
if (tmpData == NULL) {
return 3;
}
double xDelta = srcWidth / (double) dstWidth;
double xMin = xDelta / 2.0;
double yDelta = srcHeight / (double) dstHeight;
double yMin = yDelta / 2.0;
TPIXEL * sData = srcData; int sWidth = origWidth; int sHeight = origHeight; TPIXEL * dData = tmpData; int dWidth = tmpWidth; int dHeight = tmpHeight; double x0 = xMin; double dx = xDelta; int * reindexer = xReindex; double noReindexFrom = xNoReindexFrom; double noReindexTo = xNoReindexTo; TCHANNEL * px1; TCHANNEL * px2; TCHANNEL * dpx; TCHANNEL p1; TCHANNEL p2; int X; double nx;,
nx = x + 0.5; X = nx; nx -= X; px1 = (TCHANNEL *)(sPtrRowBgn + reindexer[X++]); px2 = (TCHANNEL *)(sPtrRowBgn + reindexer[X]); dpx = (TCHANNEL *)dPtr;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1); p2 = *(px2); INTERPOLATE_LINEAR(p1, p2, nx, *dpx);,
nx = x - 0.5; X = nx; nx -= X; sPtr = sPtrRowBgn + X; px1 = (TCHANNEL *) sPtr++; px2 = (TCHANNEL *) sPtr; dpx = (TCHANNEL *)dPtr;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1); p2 = *(px2); INTERPOLATE_LINEAR(p1, p2, nx, *dpx);)
TPIXEL * sData = tmpData; int sWidth = tmpWidth; int sHeight = tmpHeight; TPIXEL * dData = dstData; int dWidth = dstWidth; int dHeight = dstHeight; double x0 = yMin; double dx = yDelta; int * reindexer = yReindex; double noReindexFrom = yNoReindexFrom; double noReindexTo = yNoReindexTo; TCHANNEL * px1; TCHANNEL * px2; TCHANNEL * dpx; TCHANNEL p1; TCHANNEL p2; int X; double nx;,
nx = x + 0.5; X = nx; nx -= X; px1 = (TCHANNEL *)(sPtrRowBgn + reindexer[X++]); px2 = (TCHANNEL *)(sPtrRowBgn + reindexer[X]); dpx = (TCHANNEL *)dPtr;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1); p2 = *(px2); INTERPOLATE_LINEAR(p1, p2, nx, *dpx);,
nx = x - 0.5; X = nx; nx -= X; sPtr = sPtrRowBgn + X; px1 = (TCHANNEL *) sPtr++; px2 = (TCHANNEL *) sPtr; dpx = (TCHANNEL *)dPtr;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1++); p2 = *(px2++); INTERPOLATE_LINEAR(p1, p2, nx, *dpx); dpx++;
p1 = *(px1); p2 = *(px2); INTERPOLATE_LINEAR(p1, p2, nx, *dpx);)
free(tmpData);
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TFInterpolator< TPIXEL, TCHANNEL >::resampleTo_aliased ( TBitmap< TPIXEL, TCHANNEL > &  dst,
double  force = 1 
) const
virtualinherited

Definition at line 24 of file TFInterpolator.cpp.

{
if (getSrcData() == NULL) {
return 1;
}
TPIXEL * const dstData = dst.getData();
if (dstData == NULL) {
return 2;
}
if (!isInitOk()) {
return 3;
}
unsigned origWidth = getSrcWidth();
unsigned origHeight = getSrcHeight();
unsigned dstWidth = dst.getWidth();
unsigned dstHeight = dst.getHeight();
// Jako sigmu bereme poloměr pixeli, pokud tento po násobení sílou je větší než hraniční, provede se filtrace, ta je ale možná zbytečně agresivní
// a vztah pro určení sigmy je jen od oka... Každopádně filtruje se pro zmenšní o více než 1%, filtrace ale nenaskakuje na nejmenší míře (ta je 0.35, nikoliv 0.505
double xSigma = force * origWidth / (2.0 * dstWidth);
double ySigma = force * origHeight / (2.0 * dstHeight);
xSigma = (xSigma < 0.505) ? 0 : xSigma;
ySigma = (ySigma < 0.505) ? 0 : ySigma;
if (xSigma > 0.35 || ySigma > 0.35) {
TBitmap<TPIXEL, TCHANNEL> * source = new TBitmap<TPIXEL, TCHANNEL>(getSrcData(), getSrcWidth(), getSrcHeight(), dst.getType(), false); // Wrapper
if (source == NULL) {
return 4;
}
if (preBlurred == NULL) {
delete source;
return 5;
}
TGaussianBlur<TPIXEL, TCHANNEL> preBlur(xSigma, ySigma);
preBlur.applyTo(*preBlurred, preBlurred->getRect());
if (i == NULL) {
delete source;
delete preBlurred;
return 6;
}
int retVal = 7;
if (i->isInitOk()) {
retVal = i->resampleTo(dst);
}
delete source;
delete preBlurred;
delete i;
return retVal;
} else {
return resampleTo(dst);
}
}

Member Data Documentation

template<typename TPIXEL, typename TCHANNEL>
const unsigned TLinearFInt< TPIXEL, TCHANNEL >::chCount = sizeof(TPIXEL) / sizeof(TCHANNEL)
static

Počet kanálů bitmapy.

Definition at line 214 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
const TCHANNEL TLinearFInt< TPIXEL, TCHANNEL >::maxVal = ~0
static

Maximální hodnota kanálu.

Definition at line 215 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
int app::TLinearFInt< TPIXEL, TCHANNEL >::offset
protected

Definition at line 37 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
TPIXEL* app::TLinearFInt< TPIXEL, TCHANNEL >::srcData
protected

Definition at line 31 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
unsigned app::TLinearFInt< TPIXEL, TCHANNEL >::srcHeight
protected

Definition at line 33 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
unsigned app::TLinearFInt< TPIXEL, TCHANNEL >::srcWidth
protected

Definition at line 32 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
double app::TLinearFInt< TPIXEL, TCHANNEL >::xNoReindexFrom
protected

Definition at line 38 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
double app::TLinearFInt< TPIXEL, TCHANNEL >::xNoReindexTo
protected

Definition at line 39 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
int* app::TLinearFInt< TPIXEL, TCHANNEL >::xReindex
protected

Definition at line 35 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
double app::TLinearFInt< TPIXEL, TCHANNEL >::yNoReindexFrom
protected

Definition at line 40 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
double app::TLinearFInt< TPIXEL, TCHANNEL >::yNoReindexTo
protected

Definition at line 41 of file TLinearFInt.hpp.

template<typename TPIXEL, typename TCHANNEL>
int* app::TLinearFInt< TPIXEL, TCHANNEL >::yReindex
protected

Definition at line 36 of file TLinearFInt.hpp.


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