App

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

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 >:

## 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;
LINEAR_FILTER_ALGORITHM_GENERAL( 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;
Blender::blendTo(BLEND_MODE_NORMAL, *(TBitmap<px_4x8bit, px_1x8bit> *) dst, *(TBitmap<px_4x8bit, px_1x8bit> *) tmp, crop, crop.tl, alpha);
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:

- /home/xxx/eclipse_workspaces/app/appcore/jni/app/filters/TLinearFilter.hpp
- /home/xxx/eclipse_workspaces/app/appcore/jni/app/filters/TLinearFilter.cpp