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

Bázová třída pro lineární filtry. More...

#include <TLinearFilter.hpp>

Inheritance diagram for app::TLinearFilter< TPIXEL, TCHANNEL >:
app::TFilter< TPIXEL, TCHANNEL > app::TDoGSharpen< TPIXEL, TCHANNEL > app::TGSharpen< TPIXEL, TCHANNEL > app::TLaplaceSharpen< TPIXEL, TCHANNEL > app::TLoGSharpen< TPIXEL, TCHANNEL >

Public Member Functions

virtual ~TLinearFilter ()
 Destruktor, dealokuje jádro.
 
double * getKernel () const
 Vrátí ukazatel na jádro.
 
int getKernelHCenter () const
 Vrátí vertikální souřadnici středu jádra.
 
int getKernelHeight () const
 Vrátí výšku jádra.
 
int getKernelWCenter () const
 Vrátí horizontální souřadnici středu jádra.
 
int getKernelWidth () const
 Vrátí šířku jádra.
 
virtual int isInitOk ()
 
virtual int applyTo (TBitmap< TPIXEL, TCHANNEL > &bitmap, Rect dstRect)
 
virtual int applyTo (TBitmap< TPIXEL, TCHANNEL > &bitmap, Rect dstRect, double alpha)
 
virtual int applyTo (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TCHANNEL, TCHANNEL > &msk, Rect mskRect, Point mskOrig)
 
virtual int applyTo (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TCHANNEL, TCHANNEL > &msk, Rect mskRect, Point mskOrig, double alpha)
 

Protected Member Functions

 TLinearFilter ()
 Konstruktor, udělat protected, jen nastavení na NULL.
 
int filterResult_4ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TPIXEL, TCHANNEL > &dst, Rect dstArea)
 
virtual int applyTo_1ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, Rect dstArea)
 
virtual int applyTo_4ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, Rect dstRect)
 
virtual int applyTo_4ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, Rect dstRect, double alpha)
 
virtual int applyTo_4ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TCHANNEL, TCHANNEL > &msk, Rect mskRect, Point mskOrig)
 
virtual int applyTo_4ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TCHANNEL, TCHANNEL > &msk, Rect mskRect, Point mskOrig, double alpha)
 
virtual int applyTo_1ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, Rect dstRect, double alpha)
 
virtual int applyTo_1ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TCHANNEL, TCHANNEL > &msk, Rect mskRect, Point mskOrig)
 
virtual int applyTo_1ch (TBitmap< TPIXEL, TCHANNEL > &bitmap, TBitmap< TCHANNEL, TCHANNEL > &msk, Rect mskRect, Point mskOrig, double alpha)
 

Protected Attributes

double * kernel
 Ukazatel na pole s jádrem konvoluce, uvažuje se dvourozměrné pole uložené jako jeden segment.
 
int kernelWidth
 Šířka jádra konvoluce.
 
int kernelWCenter
 Horizontální souřadnice středu jádra konvoluce.
 
int kernelHeight
 Výška jádra konvoluce.
 
int kernelHCenter
 Vertikální souřadnice středu jádra konvoluce.
 
int initOk
 Udává jestli je inicializace OK.
 

Static Protected Attributes

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

Detailed Description

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

Bázová třída pro lineární filtry.

Bázová třída pro lineární filtry, které lze počítat pomocí konvoluce. O inicializace odpovídajícího jádra konvoluce se starají odvozené třídy, tato třída se stará o uvolnění paměti.

Definition at line 31 of file TLinearFilter.hpp.

Constructor & Destructor Documentation

template<typename TPIXEL , typename TCHANNEL >
app::TLinearFilter< TPIXEL, TCHANNEL >::TLinearFilter ( )
inlineprotected

Konstruktor, udělat protected, jen nastavení na NULL.

Definition at line 43 of file TLinearFilter.hpp.

{
kernel = NULL;
initOk = 0;
}
template<typename TPIXEL , typename TCHANNEL >
TLinearFilter< TPIXEL, TCHANNEL >::~TLinearFilter ( )
virtual

Destruktor, dealokuje jádro.

Definition at line 664 of file TLinearFilter.cpp.

{
if (kernel != NULL) {
free (kernel);
}
}

Member Function Documentation

template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect 
)
virtualinherited

Definition at line 52 of file TFilter.cpp.

{
if (chCount == 1) {
return applyTo_1ch(bitmap, dstRect);
} else if (chCount == 4) {
return applyTo_4ch(bitmap, dstRect);
} else {
return 888;
}
}
template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect,
double  alpha 
)
virtualinherited

Definition at line 62 of file TFilter.cpp.

{
if (chCount == 1) {
return applyTo_1ch(bitmap, dstRect, alpha);
} else if (chCount == 4) {
return applyTo_4ch(bitmap, dstRect, alpha);
} else {
return 888;
}
}
template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TCHANNEL, TCHANNEL > &  msk,
Rect  mskRect,
Point  mskOrig 
)
virtualinherited

Definition at line 72 of file TFilter.cpp.

{
if (chCount == 1) {
return applyTo_1ch(bitmap, msk, mskRect, mskOrig);
} else if (chCount == 4) {
return applyTo_4ch(bitmap, msk, mskRect, mskOrig);
} else {
return 888;
}
}
template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TCHANNEL, TCHANNEL > &  msk,
Rect  mskRect,
Point  mskOrig,
double  alpha 
)
virtualinherited

Definition at line 82 of file TFilter.cpp.

{
if (chCount == 1) {
return applyTo_1ch(bitmap, msk, mskRect, mskOrig, alpha);
} else if (chCount == 4) {
return applyTo_4ch(bitmap, msk, mskRect, mskOrig, alpha);
} else {
return 888;
}
}
template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo_1ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect,
double  alpha 
)
protectedvirtualinherited

Definition at line 22 of file TFilter.cpp.

{
return 999;
}
template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo_1ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TCHANNEL, TCHANNEL > &  msk,
Rect  mskRect,
Point  mskOrig 
)
protectedvirtualinherited

Definition at line 26 of file TFilter.cpp.

{
return 999;
}
template<typename TPIXEL , typename TCHANNEL >
int TFilter< TPIXEL, TCHANNEL >::applyTo_1ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TCHANNEL, TCHANNEL > &  msk,
Rect  mskRect,
Point  mskOrig,
double  alpha 
)
protectedvirtualinherited

Definition at line 30 of file TFilter.cpp.

{
return 999;
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFilter< TPIXEL, TCHANNEL >::applyTo_1ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstArea 
)
protectedvirtual

Reimplemented from app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 289 of file TLinearFilter.cpp.

{
if (this->chCount != 1) {
return 1;
}
if (kernel == NULL || kernelWidth < 2 || kernelHeight < 2) {
return 2;
}
TPIXEL * const src = bitmap.getData();
if (src == NULL) {
return 3;
}
unsigned width = bitmap.getWidth();
unsigned height = bitmap.getHeight();
TPIXEL * const dst = (TPIXEL *) malloc(width * height * sizeof(TPIXEL));
if (dst == NULL) {
return 4;
}
PointerArea tmpArea(dst, bitmap.getRect(), dstArea, sizeof(TPIXEL));
Rect crop = tmpArea.getArea();
PointerArea srcArea = bitmap.getPointerArea();
int xMin = crop.tl.x;
int yMin = crop.tl.y;
int xMax = crop.br.x;
int yMax = crop.br.y;
int xNoReindexFrom = kernelWCenter < width ? kernelWCenter : width;
int xNoReindexTo = width - kernelWCenter;
int yNoReindexFrom = kernelHCenter < height ? kernelHCenter : height;
int yNoReindexTo = height - kernelHCenter;
MirroredReindexer *xLo = NULL, *xHi = NULL, *yLo = NULL, *yHi = NULL;
int initOk = 1;
if (xMin < xNoReindexFrom) {
xLo = new MirroredReindexer(-kernelWCenter, kernelWidth - 1, width);
if (xLo == NULL) {
initOk = 0;
} else if (xLo->getVals() == NULL) {
initOk = 0;
}
}
if (xNoReindexTo < xMax && initOk) {
xHi = new MirroredReindexer(width - kernelWidth - 1, width + kernelWCenter, width);
if (xHi == NULL) {
initOk = 0;
} else if (xHi->getVals() == NULL) {
initOk = 0;
}
}
if (yMin < yNoReindexFrom && initOk) {
yLo = new MirroredReindexer(-kernelHCenter, kernelHeight - 1, height);
if (yLo == NULL) {
initOk = 0;
} else if (yLo->getVals() == NULL) {
initOk = 0;
}
}
if (yNoReindexTo < yMax && initOk) {
yHi = new MirroredReindexer(height - kernelHeight - 1, height + kernelHCenter, height);
if (yHi == NULL) {
initOk = 0;
} else if (yHi->getVals() == NULL) {
initOk = 0;
}
}
if (initOk) {
TPIXEL * dPtr = dst + yMin * width + xMin;
int dPtrOffset = width - xMax + xMin;
double sum = 0;
sum += *sPtr * *kernelPtr;,
sum += 0.5; *dPtr = (sum < 0) ? 0 : (sum > maxVal) ? maxVal : sum;,
dPtr++;,
dPtr += dPtrOffset;)
PointerArea::copy(srcArea, tmpArea, crop.tl);
}
if (xLo != NULL) {
delete xLo;
}
if (xHi != NULL) {
delete xHi;
}
if (yLo != NULL) {
delete yLo;
}
if (yHi != NULL) {
delete yHi;
}
free(dst);
if (initOk) {
return 0;
} else {
return 5;
}
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFilter< TPIXEL, TCHANNEL >::applyTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect 
)
protectedvirtual

Reimplemented from app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 539 of file TLinearFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
TBitmap<TPIXEL, TCHANNEL> * tmp = new TBitmap<TPIXEL, TCHANNEL>(bitmap.getWidth(), bitmap.getHeight(), bitmap.getType(), bitmap.isPremultiplied());
if (tmp == NULL) {
return 2;
}
PointerArea tmpArea(tmp->getData(), tmp->getRect(), dstRect, sizeof(TPIXEL));
Rect crop = tmpArea.getArea();
PointerArea srcArea = bitmap.getPointerArea();
int err = filterResult_4ch(bitmap, *tmp, crop);
if (err) {
delete tmp;
return 100 + err;
}
PointerArea::copy(srcArea, tmpArea, crop.tl);
delete tmp;
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFilter< TPIXEL, TCHANNEL >::applyTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect,
double  alpha 
)
protectedvirtual

Reimplemented from app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 563 of file TLinearFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
TBitmap<TPIXEL, TCHANNEL> * tmp = new TBitmap<TPIXEL, TCHANNEL>(bitmap.getWidth(), bitmap.getHeight(), bitmap.getType(), bitmap.isPremultiplied());
if (tmp == NULL) {
return 2;
}
PointerArea tmpArea(tmp->getData(), tmp->getRect(), dstRect, sizeof(TPIXEL));
Rect crop = tmpArea.getArea();
PointerArea srcArea = bitmap.getPointerArea();
int err = filterResult_4ch(bitmap, *tmp, crop);
if (err) {
delete tmp;
return 100 + err;
}
TBitmap<TPIXEL, TCHANNEL> * dst = &bitmap;
delete tmp;
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFilter< TPIXEL, TCHANNEL >::applyTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TCHANNEL, TCHANNEL > &  msk,
Rect  mskRect,
Point  mskOrig 
)
protectedvirtual

Reimplemented from app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 591 of file TLinearFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
TBitmap<TPIXEL, TCHANNEL> * tmp = new TBitmap<TPIXEL, TCHANNEL>(bitmap.getWidth(), bitmap.getHeight(), bitmap.getType(), bitmap.isPremultiplied());
if (tmp == NULL) {
return 2;
}
PointerArea mskArea(msk.getData(), msk.getRect(), mskRect, sizeof(TCHANNEL));
PointerArea srcArea = bitmap.getPointerArea();
int err = PointerArea::makeCommon(srcArea, mskArea, mskOrig);
if (err) {
return 200 + err;
}
Rect crop = srcArea.getArea();
Rect mskCrop = mskArea.getArea();
err = filterResult_4ch(bitmap, *tmp, crop);
if (err) {
delete tmp;
return 100 + err;
}
TBitmap<TPIXEL, TCHANNEL> * dst = &bitmap;
Blender::drawTo(BLEND_MODE_NORMAL, *(TBitmap<px_4x8bit, px_1x8bit> *) dst, msk, *(TBitmap<px_4x8bit, px_1x8bit> *) tmp, mskCrop, Point(0, 0), crop.tl);
delete tmp;
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFilter< TPIXEL, TCHANNEL >::applyTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TCHANNEL, TCHANNEL > &  msk,
Rect  mskRect,
Point  mskOrig,
double  alpha 
)
protectedvirtual

Reimplemented from app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 627 of file TLinearFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
TBitmap<TPIXEL, TCHANNEL> * tmp = new TBitmap<TPIXEL, TCHANNEL>(bitmap.getWidth(), bitmap.getHeight(), bitmap.getType(), bitmap.isPremultiplied());
if (tmp == NULL) {
return 2;
}
PointerArea mskArea(msk.getData(), msk.getRect(), mskRect, sizeof(TCHANNEL));
PointerArea srcArea = bitmap.getPointerArea();
int err = PointerArea::makeCommon(srcArea, mskArea, mskOrig);
if (err) {
return 200 + err;
}
Rect crop = srcArea.getArea();
Rect mskCrop = mskArea.getArea();
err = filterResult_4ch(bitmap, *tmp, crop);
if (err) {
delete tmp;
return 100 + err;
}
TBitmap<TPIXEL, TCHANNEL> * dst = &bitmap;
Blender::drawTo(BLEND_MODE_NORMAL, *(TBitmap<px_4x8bit, px_1x8bit> *) dst, msk, *(TBitmap<px_4x8bit, px_1x8bit> *) tmp, mskCrop, Point(0, 0), crop.tl, alpha);
delete tmp;
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TLinearFilter< TPIXEL, TCHANNEL >::filterResult_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
TBitmap< TPIXEL, TCHANNEL > &  dst,
Rect  dstArea 
)
protected

Definition at line 407 of file TLinearFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
if (kernel == NULL || kernelWidth < 2 || kernelHeight < 2) {
return 2;
}
TPIXEL * const src = bitmap.getData();
if (src == NULL) {
return 3;
}
unsigned width = bitmap.getWidth();
unsigned height = bitmap.getHeight();
TPIXEL * const dst = dstBitmap.getData();
if (dst == NULL) {
return 4;
}
// PointerArea tmpArea(dst, bitmap.getRect(), dstArea, sizeof(TPIXEL));
// Rect crop = tmpArea.getArea();
// PointerArea srcArea = bitmap.getPointerArea();
int xMin = dstArea.tl.x;
int yMin = dstArea.tl.y;
int xMax = dstArea.br.x;
int yMax = dstArea.br.y;
int xNoReindexFrom = kernelWCenter < width ? kernelWCenter : width;
int xNoReindexTo = width - kernelWCenter;
int yNoReindexFrom = kernelHCenter < height ? kernelHCenter : height;
int yNoReindexTo = height - kernelHCenter;
MirroredReindexer *xLo = NULL, *xHi = NULL, *yLo = NULL, *yHi = NULL;
int initOk = 1;
if (xMin < xNoReindexFrom) {
xLo = new MirroredReindexer(-kernelWCenter, kernelWidth - 1, width);
if (xLo == NULL) {
initOk = 0;
} else if (xLo->getVals() == NULL) {
initOk = 0;
}
}
if (xNoReindexTo < xMax && initOk) {
xHi = new MirroredReindexer(width - kernelWidth - 1, width + kernelWCenter, width);
if (xHi == NULL) {
initOk = 0;
} else if (xHi->getVals() == NULL) {
initOk = 0;
}
}
if (yMin < yNoReindexFrom && initOk) {
yLo = new MirroredReindexer(-kernelHCenter, kernelHeight - 1, height);
if (yLo == NULL) {
initOk = 0;
} else if (yLo->getVals() == NULL) {
initOk = 0;
}
}
if (yNoReindexTo < yMax && initOk) {
yHi = new MirroredReindexer(height - kernelHeight - 1, height + kernelHCenter, height);
if (yHi == NULL) {
initOk = 0;
} else if (yHi->getVals() == NULL) {
initOk = 0;
}
}
if (initOk) {
TPIXEL * dPtr = dst + yMin * width + xMin;
int dPtrOffset = width - xMax + xMin;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
LINEAR_FILTER_ALGORITHM_GENERAL( sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr; chPtr = (TCHANNEL *) sPtr; A = *(chPtr + 3) * kv; sumR += *(chPtr++) * A; sumG += *(chPtr++) * A; sumB += *chPtr * A; sumA += A;,
chPtr = (TCHANNEL *) dPtr;
sumR += 0.5; sumG += 0.5; sumB += 0.5; sumA += 0.5;
sumA = (sumA < 0) ? 0 : (sumA > maxVal) ? maxVal : sumA;
sumR = sumR / sumA + 0.5; sumG = sumG / sumA + 0.5; sumB = sumB / sumA + 0.5;
*chPtr = (sumR < 0) ? 0 : (sumR > maxVal) ? maxVal : sumR; chPtr++; *chPtr = (sumG < 0) ? 0 : (sumG > maxVal) ? maxVal : sumG; chPtr++; *chPtr = (sumB < 0) ? 0 : (sumB > maxVal) ? maxVal : sumB; chPtr++; *chPtr = sumA;,
dPtr++;,
dPtr += dPtrOffset;)
// PointerArea::copy(srcArea, tmpArea, crop.tl);
}
if (xLo != NULL) {
delete xLo;
}
if (xHi != NULL) {
delete xHi;
}
if (yLo != NULL) {
delete yLo;
}
if (yHi != NULL) {
delete yHi;
}
if (initOk) {
return 0;
} else {
return 5;
}
}
template<typename TPIXEL , typename TCHANNEL >
double* app::TLinearFilter< TPIXEL, TCHANNEL >::getKernel ( ) const
inline

Vrátí ukazatel na jádro.

Definition at line 63 of file TLinearFilter.hpp.

{
return kernel;
}
template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::getKernelHCenter ( ) const
inline

Vrátí vertikální souřadnici středu jádra.

Definition at line 68 of file TLinearFilter.hpp.

{
return kernelHCenter;
}
template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::getKernelHeight ( ) const
inline

Vrátí výšku jádra.

Definition at line 73 of file TLinearFilter.hpp.

{
return kernelHeight;
}
template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::getKernelWCenter ( ) const
inline

Vrátí horizontální souřadnici středu jádra.

Definition at line 78 of file TLinearFilter.hpp.

{
return kernelWCenter;
}
template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::getKernelWidth ( ) const
inline

Vrátí šířku jádra.

Definition at line 83 of file TLinearFilter.hpp.

{
return kernelWidth;
}
template<typename TPIXEL , typename TCHANNEL >
virtual int app::TLinearFilter< TPIXEL, TCHANNEL >::isInitOk ( )
inlinevirtual

Implements app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 87 of file TLinearFilter.hpp.

{
return initOk;
}

Member Data Documentation

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

Počet kanálů bitmapy.

Definition at line 27 of file TFilter.hpp.

template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::initOk
protected

Udává jestli je inicializace OK.

Definition at line 38 of file TLinearFilter.hpp.

template<typename TPIXEL , typename TCHANNEL >
double* app::TLinearFilter< TPIXEL, TCHANNEL >::kernel
protected

Ukazatel na pole s jádrem konvoluce, uvažuje se dvourozměrné pole uložené jako jeden segment.

Definition at line 33 of file TLinearFilter.hpp.

template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::kernelHCenter
protected

Vertikální souřadnice středu jádra konvoluce.

Definition at line 37 of file TLinearFilter.hpp.

template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::kernelHeight
protected

Výška jádra konvoluce.

Definition at line 36 of file TLinearFilter.hpp.

template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::kernelWCenter
protected

Horizontální souřadnice středu jádra konvoluce.

Definition at line 35 of file TLinearFilter.hpp.

template<typename TPIXEL , typename TCHANNEL >
int app::TLinearFilter< TPIXEL, TCHANNEL >::kernelWidth
protected

Šířka jádra konvoluce.

Definition at line 34 of file TLinearFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
const TCHANNEL TFilter< TPIXEL, TCHANNEL >::maxVal = ~0
staticprotectedinherited

Maximální hodnota kanálu.

Definition at line 26 of file TFilter.hpp.


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