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

Bázová třída pro rychlé oddělitelné filtry. More...

#include <TSeparableFilter.hpp>

Inheritance diagram for app::TSeparableFilter< TPIXEL, TCHANNEL >:
app::TFilter< TPIXEL, TCHANNEL > app::TGaussianBlur< TPIXEL, TCHANNEL >

Public Member Functions

virtual int isInitOk ()
 
virtual ~TSeparableFilter ()
 Destruktor, uvolňuje paměť pro jádra.
 
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

 TSeparableFilter ()
 Konstruktor, vytvářet instance nejde.
 
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 * xKernel
 Jádro použité v prvním průchodu - horizontální směr.
 
int xKernelWidth
 Šířka horizontálního jádra.
 
int xKernelCenter
 Souřadnice prvku přesně uprostřed horizontálního jádra.
 
double * yKernel
 Jádro použité v druhém průchodu - vertikální směr.
 
int yKernelWidth
 Šířka vertikálního jádra.
 
int yKernelCenter
 Souřadnice prvku přesně uprostřed vertikálního jádra.
 

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::TSeparableFilter< TPIXEL, TCHANNEL >

Bázová třída pro rychlé oddělitelné filtry.

Bázová třída pro rychlé oddělitelné filtry, pro které platí, že lze jejich výpočet provést pomocí konvoluce s využitím dvou jader, kdy jedno je tvořeno jediným řádkem a druhé jediným sloupcem. Odvozené třídy se starají o inicializaci těchto jader, mechanismus výpočtu je plně v režii této třídy stejně jako uvolňování paměti po jádrech

Při prvním kroku výpočtu dochází k transpozici bitmapy do dočasné, v druhém kroku výpočtu se opět provádí transtpozice do původní a provádí se blending dle potřeby.

Definition at line 35 of file TSeparableFilter.hpp.

Constructor & Destructor Documentation

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

Konstruktor, vytvářet instance nejde.

Definition at line 48 of file TSeparableFilter.hpp.

{
xKernel = NULL;
yKernel = NULL;
}
template<typename TPIXEL , typename TCHANNEL >
TSeparableFilter< TPIXEL, TCHANNEL >::~TSeparableFilter ( )
virtual

Destruktor, uvolňuje paměť pro jádra.

Definition at line 123 of file TSeparableFilter.cpp.

{
// Ikdyž nealokoval, uvolňuje, protože ukazatele jsou v jeho kompetanci.
if (xKernel != NULL) {
free(xKernel);
}
if (yKernel != NULL) {
free(yKernel);
}
}

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 TSeparableFilter< TPIXEL, TCHANNEL >::applyTo_1ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstArea 
)
protectedvirtual

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

Definition at line 135 of file TSeparableFilter.cpp.

{
if (this->chCount != 1) {
return 1;
}
if (xKernel == NULL || yKernel == NULL) { // Kontrola 1 vlastne neni potreba
return 2;
}
TPIXEL * const srcData = bitmap.getData();
if (srcData == NULL) {
return 3;
}
unsigned origWidth = bitmap.getWidth();
unsigned origHeight = bitmap.getHeight();
unsigned tmpWidth = origHeight;
unsigned tmpHeight = origWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc(tmpWidth * tmpHeight * sizeof(TPIXEL));
if (tmpData == NULL) {
delete tmpData;
return 4;
}
Rect crop = Rect::getIntersection(srcRect, bitmap.getRect());
int wasOk = 0;
{
/* JMENNÉ KONVENCE PRO PROMĚNNÉ FILTRU.
TPIXEL * src, *dst;
TCHANNEL * msk;
double alpha;
int srcWidth, srcHeight;
int dstWidth, dstHeight;
int mskWidth, mskHeight;
int xSrcMin, xSrcMax, ySrcMin, ySrcMax;
int xDstMin, xDstMax, yDstMin, yDstMax;
int xMskMin, xMskMax, yMskMin, yMskMax;
double * kernel;
int kernelCenter;
int kernelWidth;
*/
TPIXEL * src = srcData;
int srcWidth = origWidth;
int xSrcMin = crop.tl.x;
int xSrcMax = crop.br.x;
int ySrcMin = crop.tl.y - yKernelCenter;
ySrcMin = (ySrcMin < 0) ? 0 : ySrcMin;
int ySrcMax = crop.br.y + yKernelCenter;
ySrcMax = (ySrcMax > origHeight) ? origHeight : ySrcMax;
TPIXEL * dst = tmpData;
int dstWidth = tmpWidth;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
int xDstMin = ySrcMin;
int yDstMin = xSrcMin;
double * kernel = xKernel;
int kernelCenter = xKernelCenter;
int kernelWidth = xKernelWidth;
double sum;
SEPARABLE_FILTER_ALGORITHM_GENERAL(dPtr = dPtrColBgn++;, sum = 0;, sum += *sTmpPtr * *kernelPtr;, *dPtr = sum + 0.5;, dPtr += dstWidth;)
wasOk = initOk;
}
if (wasOk) {
TPIXEL * src = tmpData;
int srcWidth = tmpWidth;
int xSrcMin = crop.tl.y;
int xSrcMax = crop.br.y;
int ySrcMin = crop.tl.x;
int ySrcMax = crop.br.x;
TPIXEL * dst = srcData;
int dstWidth = origWidth;
int xDstMin = crop.tl.x;
int yDstMin = crop.tl.y;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
double * kernel = yKernel;
int kernelCenter = yKernelCenter;
int kernelWidth = yKernelWidth;
double sum;
SEPARABLE_FILTER_ALGORITHM_GENERAL(dPtr = dPtrColBgn++;, sum = 0;, sum += *sTmpPtr * *kernelPtr;, *dPtr = sum + 0.5;, dPtr += dstWidth;)
}
free(tmpData);
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TSeparableFilter< TPIXEL, TCHANNEL >::applyTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect 
)
protectedvirtual

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

Definition at line 249 of file TSeparableFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
if (xKernel == NULL || yKernel == NULL) {
return 2;
} // pro mensi nez 2 se nepodari vytvorit reindexer, zkolabuje, navic je cely nesmysl - bodova operace v danem smeru
TPIXEL * const srcData = bitmap.getData();
if (srcData == NULL) {
return 3;
}
unsigned origWidth = bitmap.getWidth();
unsigned origHeight = bitmap.getHeight();
unsigned tmpWidth = origHeight;
unsigned tmpHeight = origWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc(tmpWidth * tmpHeight * sizeof(TPIXEL)); // Dočasná bitmapa, do které se provede filtr dle řádků a ze které se filtruje dle sloupců do původní bitmapy.
if (tmpData == NULL) {
delete tmpData;
return 4;
}
Rect crop = Rect::getIntersection(srcRect, bitmap.getRect());
int wasOk = 0;
{
TPIXEL * src = srcData;
int srcWidth = origWidth;
int xSrcMin = crop.tl.x;
int xSrcMax = crop.br.x;
int ySrcMin = crop.tl.y - yKernelCenter;
ySrcMin = (ySrcMin < 0) ? 0 : ySrcMin;
int ySrcMax = crop.br.y + yKernelCenter;
ySrcMax = (ySrcMax > origHeight) ? origHeight : ySrcMax;
TPIXEL * dst = tmpData;
int dstWidth = tmpWidth;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
int xDstMin = ySrcMin;
int yDstMin = xSrcMin;
double * kernel = xKernel;
int kernelCenter = xKernelCenter;
int kernelWidth = xKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
dPtr = dPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
*chPtr = sumR / (sumA) + 0.5; chPtr++;
*chPtr = sumG / (sumA) + 0.5; chPtr++;
*chPtr = sumB / (sumA) + 0.5; chPtr++;
*chPtr = sumA + 0.5;,
dPtr += dstWidth;
)
wasOk = initOk; // Pokud ne, v tmp jsou nahodna data.
}
if (wasOk) {
TPIXEL * src = tmpData;
int srcWidth = tmpWidth;
int xSrcMin = crop.tl.y;
int xSrcMax = crop.br.y;
int ySrcMin = crop.tl.x;
int ySrcMax = crop.br.x;
TPIXEL * dst = srcData;
int dstWidth = origWidth;
int xDstMin = crop.tl.x;
int yDstMin = crop.tl.y;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
double * kernel = yKernel;
int kernelCenter = yKernelCenter;
int kernelWidth = yKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
dPtr = dPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
*chPtr = sumR / (sumA) + 0.5; chPtr++;
*chPtr = sumG / (sumA) + 0.5; chPtr++;
*chPtr = sumB / (sumA) + 0.5; chPtr++;
*chPtr = sumA + 0.5;,
dPtr += dstWidth;
)
}
free(tmpData);
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TSeparableFilter< TPIXEL, TCHANNEL >::applyTo_4ch ( TBitmap< TPIXEL, TCHANNEL > &  bitmap,
Rect  dstRect,
double  alpha 
)
protectedvirtual

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

Definition at line 400 of file TSeparableFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
if (xKernel == NULL || yKernel == NULL) {
return 2;
} // pro mensi nez 2 se nepodari vytvorit reindexer, zkolabuje, navic je cely nesmysl - bodova operace v danem smeru
TPIXEL * const srcData = bitmap.getData();
if (srcData == NULL) {
return 3;
}
unsigned origWidth = bitmap.getWidth();
unsigned origHeight = bitmap.getHeight();
unsigned tmpWidth = origHeight;
unsigned tmpHeight = origWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc(tmpWidth * tmpHeight * sizeof(TPIXEL)); // Dočasná bitmapa, do které se provede filtr dle řádků a ze které se filtruje dle sloupců do původní bitmapy.
if (tmpData == NULL) {
delete tmpData;
return 4;
}
Rect crop = Rect::getIntersection(srcRect, bitmap.getRect());
int wasOk = 0;
{
TPIXEL * src = srcData;
int srcWidth = origWidth;
int xSrcMin = crop.tl.x;
int xSrcMax = crop.br.x;
int ySrcMin = crop.tl.y - yKernelCenter;
ySrcMin = (ySrcMin < 0) ? 0 : ySrcMin;
int ySrcMax = crop.br.y + yKernelCenter;
ySrcMax = (ySrcMax > origHeight) ? origHeight : ySrcMax;
TPIXEL * dst = tmpData;
int dstWidth = tmpWidth;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
int xDstMin = ySrcMin;
int yDstMin = xSrcMin;
double * kernel = xKernel;
int kernelCenter = xKernelCenter;
int kernelWidth = xKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
dPtr = dPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
*chPtr = sumR / (sumA) + 0.5; chPtr++;
*chPtr = sumG / (sumA) + 0.5; chPtr++;
*chPtr = sumB / (sumA) + 0.5; chPtr++;
*chPtr = sumA + 0.5;,
dPtr += dstWidth;
)
wasOk = initOk; // Pokud ne, v tmp jsou nahodna data.
}
if (wasOk) {
TPIXEL * src = tmpData;
int srcWidth = tmpWidth;
int xSrcMin = crop.tl.y;
int xSrcMax = crop.br.y;
int ySrcMin = crop.tl.x;
int ySrcMax = crop.br.x;
TPIXEL * dst = srcData;
int dstWidth = origWidth;
int xDstMin = crop.tl.x;
int yDstMin = crop.tl.y;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
double * kernel = yKernel;
int kernelCenter = yKernelCenter;
int kernelWidth = yKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
TCHANNEL doa;
double da;
double sa;
double sac;
double ra;
dPtr = dPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
doa = *(chPtr + 3);
da = doa / 255.0;
sa = sumA * alpha / 255.0;
sac = 1 - sa;
ra = sa + da * sac;
*chPtr = ((sumR / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ((sumG / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ((sumB / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ra * 255 + 0.5;,
dPtr += dstWidth;
)
}
free(tmpData);
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TSeparableFilter< 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 564 of file TSeparableFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
if (xKernel == NULL || yKernel == NULL) {
return 2;
} // pro mensi nez 2 se nepodari vytvorit reindexer, zkolabuje, navic je cely nesmysl - bodova operace v danem smeru
TPIXEL * const srcData = bitmap.getData();
if (srcData == NULL) {
return 3;
}
unsigned origWidth = bitmap.getWidth();
unsigned origHeight = bitmap.getHeight();
unsigned tmpWidth = origHeight;
unsigned tmpHeight = origWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc(tmpWidth * tmpHeight * sizeof(TPIXEL)); // Dočasná bitmapa, do které se provede filtr dle řádků a ze které se filtruje dle sloupců do původní bitmapy.
if (tmpData == NULL) {
delete tmpData;
return 4;
}
PointerArea mskArea(mask.getData(), mask.getRect(), mskRect, mask.getBpp());
PointerArea dstArea = bitmap.getPointerArea();
int err = PointerArea::makeCommon(dstArea, mskArea, mskOrig);
if (err) {
return 100 + err;
}
Rect crop = dstArea.getArea();
Rect mskCrop = mskArea.getArea();
int wasOk = 0;
{
TPIXEL * src = srcData;
int srcWidth = origWidth;
int xSrcMin = crop.tl.x;
int xSrcMax = crop.br.x;
int ySrcMin = crop.tl.y - yKernelCenter;
ySrcMin = (ySrcMin < 0) ? 0 : ySrcMin;
int ySrcMax = crop.br.y + yKernelCenter;
ySrcMax = (ySrcMax > origHeight) ? origHeight : ySrcMax;
TPIXEL * dst = tmpData;
int dstWidth = tmpWidth;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
int xDstMin = ySrcMin;
int yDstMin = xSrcMin;
double * kernel = xKernel;
int kernelCenter = xKernelCenter;
int kernelWidth = xKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
dPtr = dPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
*chPtr = sumR / (sumA) + 0.5; chPtr++;
*chPtr = sumG / (sumA) + 0.5; chPtr++;
*chPtr = sumB / (sumA) + 0.5; chPtr++;
*chPtr = sumA + 0.5;,
dPtr += dstWidth;
)
wasOk = initOk; // Pokud ne, v tmp jsou nahodna data.
}
if (wasOk) {
TPIXEL * src = tmpData;
int srcWidth = tmpWidth;
int xSrcMin = crop.tl.y;
int xSrcMax = crop.br.y;
int ySrcMin = crop.tl.x;
int ySrcMax = crop.br.x;
TPIXEL * dst = srcData;
int dstWidth = origWidth;
int xDstMin = crop.tl.x;
int yDstMin = crop.tl.y;
TCHANNEL * msk = mask.getData();
int mskWidth = mask.getWidth();
int xMskMin = mskCrop.tl.x;
int yMskMin = mskCrop.tl.y;
double * kernel = yKernel;
int kernelCenter = yKernelCenter;
int kernelWidth = yKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
TCHANNEL doa;
double da;
double sa;
double sac;
double ra;
dPtr = dPtrColBgn++;
mPtr = mPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
doa = *(chPtr + 3);
da = doa / 255.0;
sa = sumA * *mPtr/ 65025.0;
sac = 1 - sa;
ra = sa + da * sac;
*chPtr = ((sumR / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ((sumG / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ((sumB / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ra * 255 + 0.5;,
dPtr += dstWidth;
mPtr += mskWidth;
)
}
free(tmpData);
return 0;
}
template<typename TPIXEL , typename TCHANNEL >
int TSeparableFilter< 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 739 of file TSeparableFilter.cpp.

{
if (this->chCount != 4) {
return 1;
}
if (xKernel == NULL || yKernel == NULL) {
return 2;
} // pro mensi nez 2 se nepodari vytvorit reindexer, zkolabuje, navic je cely nesmysl - bodova operace v danem smeru
TPIXEL * const srcData = bitmap.getData();
if (srcData == NULL) {
return 3;
}
unsigned origWidth = bitmap.getWidth();
unsigned origHeight = bitmap.getHeight();
unsigned tmpWidth = origHeight;
unsigned tmpHeight = origWidth;
TPIXEL * const tmpData = (TPIXEL *) malloc(tmpWidth * tmpHeight * sizeof(TPIXEL)); // Dočasná bitmapa, do které se provede filtr dle řádků a ze které se filtruje dle sloupců do původní bitmapy.
if (tmpData == NULL) {
delete tmpData;
return 4;
}
PointerArea mskArea(mask.getData(), mask.getRect(), mskRect, mask.getBpp());
PointerArea dstArea = bitmap.getPointerArea();
int err = PointerArea::makeCommon(dstArea, mskArea, mskOrig);
if (err) {
return 100 + err;
}
Rect crop = dstArea.getArea();
Rect mskCrop = mskArea.getArea();
int wasOk = 0;
{
TPIXEL * src = srcData;
int srcWidth = origWidth;
int xSrcMin = crop.tl.x;
int xSrcMax = crop.br.x;
int ySrcMin = crop.tl.y - yKernelCenter;
ySrcMin = (ySrcMin < 0) ? 0 : ySrcMin;
int ySrcMax = crop.br.y + yKernelCenter;
ySrcMax = (ySrcMax > origHeight) ? origHeight : ySrcMax;
TPIXEL * dst = tmpData;
int dstWidth = tmpWidth;
TCHANNEL * msk = NULL;
int mskWidth = 0;
int xMskMin = 0;
int yMskMin = 0;
int xDstMin = ySrcMin;
int yDstMin = xSrcMin;
double * kernel = xKernel;
int kernelCenter = xKernelCenter;
int kernelWidth = xKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
dPtr = dPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
*chPtr = sumR / (sumA) + 0.5; chPtr++;
*chPtr = sumG / (sumA) + 0.5; chPtr++;
*chPtr = sumB / (sumA) + 0.5; chPtr++;
*chPtr = sumA + 0.5;,
dPtr += dstWidth;
)
wasOk = initOk; // Pokud ne, v tmp jsou nahodna data.
}
if (wasOk) {
TPIXEL * src = tmpData;
int srcWidth = tmpWidth;
int xSrcMin = crop.tl.y;
int xSrcMax = crop.br.y;
int ySrcMin = crop.tl.x;
int ySrcMax = crop.br.x;
TPIXEL * dst = srcData;
int dstWidth = origWidth;
int xDstMin = crop.tl.x;
int yDstMin = crop.tl.y;
TCHANNEL * msk = mask.getData();
int mskWidth = mask.getWidth();
int xMskMin = mskCrop.tl.x;
int yMskMin = mskCrop.tl.y;
double * kernel = yKernel;
int kernelCenter = yKernelCenter;
int kernelWidth = yKernelWidth;
double sumR;
double sumG;
double sumB;
double sumA;
double A;
TCHANNEL * chPtr;
double kv;
TCHANNEL doa;
double da;
double sa;
double sac;
double ra;
dPtr = dPtrColBgn++;
mPtr = mPtrColBgn++;,
sumR = 0; sumG = 0; sumB = 0; sumA = 0;,
kv = *kernelPtr;
chPtr = (TCHANNEL *) sTmpPtr;
A = *(chPtr + 3) * kv;
sumR += *(chPtr++) * A;
sumG += *(chPtr++) * A;
sumB += *chPtr * A;
sumA += A;,
chPtr = (TCHANNEL *) dPtr;
doa = *(chPtr + 3);
da = doa / 255.0;
sa = sumA * *mPtr * alpha / 65025.0;
sac = 1 - sa;
ra = sa + da * sac;
*chPtr = ((sumR / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ((sumG / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ((sumB / (sumA)) * sa + *chPtr * da * sac) / ra + 0.5; chPtr++;
*chPtr = ra * 255 + 0.5;,
dPtr += dstWidth;
mPtr += mskWidth;
)
}
free(tmpData);
return 0;
}
template<typename TPIXEL, typename TCHANNEL>
virtual int app::TSeparableFilter< TPIXEL, TCHANNEL >::isInitOk ( )
inlinevirtual

Implements app::TFilter< TPIXEL, TCHANNEL >.

Definition at line 62 of file TSeparableFilter.hpp.

{
if (xKernel != NULL && yKernel != NULL) {
return 1;
} else {
return 0;
}
}

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>
const TCHANNEL TFilter< TPIXEL, TCHANNEL >::maxVal = ~0
staticprotectedinherited

Maximální hodnota kanálu.

Definition at line 26 of file TFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
double* app::TSeparableFilter< TPIXEL, TCHANNEL >::xKernel
protected

Jádro použité v prvním průchodu - horizontální směr.

Definition at line 39 of file TSeparableFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
int app::TSeparableFilter< TPIXEL, TCHANNEL >::xKernelCenter
protected

Souřadnice prvku přesně uprostřed horizontálního jádra.

Definition at line 41 of file TSeparableFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
int app::TSeparableFilter< TPIXEL, TCHANNEL >::xKernelWidth
protected

Šířka horizontálního jádra.

Definition at line 40 of file TSeparableFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
double* app::TSeparableFilter< TPIXEL, TCHANNEL >::yKernel
protected

Jádro použité v druhém průchodu - vertikální směr.

Definition at line 43 of file TSeparableFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
int app::TSeparableFilter< TPIXEL, TCHANNEL >::yKernelCenter
protected

Souřadnice prvku přesně uprostřed vertikálního jádra.

Definition at line 45 of file TSeparableFilter.hpp.

template<typename TPIXEL, typename TCHANNEL>
int app::TSeparableFilter< TPIXEL, TCHANNEL >::yKernelWidth
protected

Šířka vertikálního jádra.

Definition at line 44 of file TSeparableFilter.hpp.


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