8 #define LINEAR_FILTER_ALGORITHM_GENERAL(PX_INIT, KERNEL_ACTION, PX_COMMIT, PX_INCREMENT, ROW_INCREMENT) \
10 const int xKernelCenter = this->kernelWCenter;\
11 const int yKernelCenter = this->kernelHCenter;\
14 double * kernelPtrRowEnd;\
15 double * const kernelFirstRowEnd = kernel + kernelWidth;\
16 double * const kernelEnd = kernel + kernelWidth * kernelHeight;\
21 tmp = (yNoReindexFrom < yMax) ? yNoReindexFrom : yMax;\
22 TPIXEL * dPtrInitReindexVerticalLimit = dst + tmp * width;\
23 tmp = (yNoReindexTo < yMax) ? yNoReindexTo : yMax;\
24 TPIXEL * dPtrNoReindexVerticalLimit = dst + tmp * width;\
25 tmp = (height < yMax) ? height : yMax;\
26 TPIXEL * dPtrVerticalLimit = dst + width * tmp;\
28 tmp = (xNoReindexFrom < xMax) ? xNoReindexFrom : xMax;\
29 TPIXEL * dPtrInitReindexHorizontalLimit = dst + yMin * width + tmp;\
30 tmp = (xNoReindexTo < xMax) ? xNoReindexTo : xMax;\
31 TPIXEL * dPtrNoReindexHorizontalLimit = dst + yMin * width + tmp;\
32 tmp = (width < xMax) ? width : xMax;\
33 TPIXEL * dPtrHorizontalLimit = dst + yMin * width + tmp;\
35 TCHANNEL maxVal = this->maxVal;\
38 int xStart, xStartStart, yStart;\
40 yStart = yMin - yKernelCenter;\
41 xStartStart = xMin - xKernelCenter;\
42 while (dPtr < dPtrInitReindexVerticalLimit) {\
45 xStart = xStartStart;\
46 while (dPtr < dPtrInitReindexHorizontalLimit) {\
49 kernelPtrRowEnd = kernelFirstRowEnd;\
52 while (kernelPtr < kernelEnd) {\
54 while (kernelPtr < kernelPtrRowEnd) {\
55 sPtr = src + yLo->reindex(y) * width + xLo->reindex(x);\
60 kernelPtrRowEnd += kernelWidth;\
69 while (dPtr < dPtrNoReindexHorizontalLimit) {\
72 kernelPtrRowEnd = kernelFirstRowEnd;\
74 while (kernelPtr < kernelEnd) {\
75 sPtr = src + yLo->reindex(y) * width + xStart;\
76 while (kernelPtr < kernelPtrRowEnd) {\
81 kernelPtrRowEnd += kernelWidth;\
90 while (dPtr < dPtrHorizontalLimit) {\
93 kernelPtrRowEnd = kernelFirstRowEnd;\
95 while (kernelPtr < kernelEnd) {\
97 while (kernelPtr < kernelPtrRowEnd) {\
98 sPtr = src + yLo->reindex(y) * width + xHi->reindex(x);\
103 kernelPtrRowEnd += kernelWidth;\
111 dPtrInitReindexHorizontalLimit += width;\
112 dPtrNoReindexHorizontalLimit += width;\
113 dPtrHorizontalLimit += width;\
121 TPIXEL * sPtrRowBgn = src + yStart * width;\
124 int sPtrRowOffset = width - kernelWidth;\
126 while (dPtr < dPtrNoReindexVerticalLimit) {\
129 xStart = xStartStart;\
130 while (dPtr < dPtrInitReindexHorizontalLimit) {\
133 kernelPtrRowEnd = kernelFirstRowEnd;\
134 sPtrBgn = sPtrRowBgn;\
135 while (kernelPtr < kernelEnd) {\
137 while (kernelPtr < kernelPtrRowEnd) {\
138 sPtr = sPtrBgn + xLo->reindex(x);\
144 kernelPtrRowEnd += kernelWidth;\
152 sPtrBgn = sPtrRowBgn + xStart;\
153 while (dPtr < dPtrNoReindexHorizontalLimit) {\
156 kernelPtrRowEnd = kernelFirstRowEnd;\
158 while (kernelPtr < kernelEnd) {\
159 while (kernelPtr < kernelPtrRowEnd) {\
164 kernelPtrRowEnd += kernelWidth;\
165 sPtr += sPtrRowOffset;\
172 xStart = xNoReindexTo - xKernelCenter;\
173 while (dPtr < dPtrHorizontalLimit) {\
176 kernelPtrRowEnd = kernelFirstRowEnd;\
177 sPtrBgn = sPtrRowBgn;\
178 while (kernelPtr < kernelEnd) {\
180 while (kernelPtr < kernelPtrRowEnd) {\
181 sPtr = sPtrBgn + xHi->reindex(x);\
187 kernelPtrRowEnd += kernelWidth;\
194 dPtrInitReindexHorizontalLimit += width;\
195 dPtrNoReindexHorizontalLimit += width;\
196 dPtrHorizontalLimit += width;\
198 sPtrRowBgn += width;\
203 yStart = yNoReindexTo - yKernelCenter;\
204 while (dPtr < dPtrVerticalLimit) {\
207 xStart = xStartStart;\
208 while (dPtr < dPtrInitReindexHorizontalLimit) {\
211 kernelPtrRowEnd = kernelFirstRowEnd;\
214 while (kernelPtr < kernelEnd) {\
216 while (kernelPtr < kernelPtrRowEnd) {\
217 sPtr = src + yHi->reindex(y) * width + xLo->reindex(x);\
222 kernelPtrRowEnd += kernelWidth;\
231 while (dPtr < dPtrNoReindexHorizontalLimit) {\
234 kernelPtrRowEnd = kernelFirstRowEnd;\
236 while (kernelPtr < kernelEnd) {\
237 sPtr = src + yHi->reindex(y) * width + xStart;\
238 while (kernelPtr < kernelPtrRowEnd) {\
243 kernelPtrRowEnd += kernelWidth;\
252 while (dPtr < dPtrHorizontalLimit) {\
255 kernelPtrRowEnd = kernelFirstRowEnd;\
257 while (kernelPtr < kernelEnd) {\
259 while (kernelPtr < kernelPtrRowEnd) {\
260 sPtr = src + yHi->reindex(y) * width + xHi->reindex(x);\
265 kernelPtrRowEnd += kernelWidth;\
273 dPtrInitReindexHorizontalLimit += width;\
274 dPtrNoReindexHorizontalLimit += width;\
275 dPtrHorizontalLimit += width;\
288 template<
typename TPIXEL,
typename TCHANNEL>
290 if (this->chCount != 1) {
294 if (kernel == NULL || kernelWidth < 2 || kernelHeight < 2) {
297 TPIXEL *
const src = bitmap.
getData();
303 TPIXEL *
const dst = (TPIXEL *) malloc(width * height *
sizeof(TPIXEL));
312 int xMin = crop.
tl.
x;
313 int yMin = crop.
tl.
y;
314 int xMax = crop.
br.
x;
315 int yMax = crop.
br.
y;
317 int xNoReindexFrom = kernelWCenter < width ? kernelWCenter : width;
318 int xNoReindexTo = width - kernelWCenter;
319 int yNoReindexFrom = kernelHCenter < height ? kernelHCenter : height;
320 int yNoReindexTo = height - kernelHCenter;
326 if (xMin < xNoReindexFrom) {
330 }
else if (xLo->
getVals() == NULL) {
335 if (xNoReindexTo < xMax && initOk) {
336 xHi =
new MirroredReindexer(width - kernelWidth - 1, width + kernelWCenter, width);
339 }
else if (xHi->getVals() == NULL) {
344 if (yMin < yNoReindexFrom && initOk) {
348 }
else if (yLo->getVals() == NULL) {
353 if (yNoReindexTo < yMax && initOk) {
354 yHi =
new MirroredReindexer(height - kernelHeight - 1, height + kernelHCenter, height);
357 }
else if (yHi->getVals() == NULL) {
363 TPIXEL * dPtr = dst + yMin * width + xMin;
364 int dPtrOffset = width - xMax + xMin;
369 sum += *sPtr * *kernelPtr;,
371 sum += 0.5; *dPtr = (sum < 0) ? 0 : (sum > maxVal) ? maxVal : sum;,
406 template<
typename TPIXEL,
typename TCHANNEL>
408 if (this->chCount != 4) {
412 if (kernel == NULL || kernelWidth < 2 || kernelHeight < 2) {
415 TPIXEL *
const src = bitmap.
getData();
422 TPIXEL *
const dst = dstBitmap.
getData();
431 int xMin = dstArea.
tl.
x;
432 int yMin = dstArea.
tl.
y;
433 int xMax = dstArea.
br.
x;
434 int yMax = dstArea.
br.
y;
436 int xNoReindexFrom = kernelWCenter < width ? kernelWCenter : width;
437 int xNoReindexTo = width - kernelWCenter;
438 int yNoReindexFrom = kernelHCenter < height ? kernelHCenter : height;
439 int yNoReindexTo = height - kernelHCenter;
445 if (xMin < xNoReindexFrom) {
449 }
else if (xLo->
getVals() == NULL) {
454 if (xNoReindexTo < xMax && initOk) {
455 xHi =
new MirroredReindexer(width - kernelWidth - 1, width + kernelWCenter, width);
458 }
else if (xHi->getVals() == NULL) {
463 if (yMin < yNoReindexFrom && initOk) {
467 }
else if (yLo->getVals() == NULL) {
472 if (yNoReindexTo < yMax && initOk) {
473 yHi =
new MirroredReindexer(height - kernelHeight - 1, height + kernelHCenter, height);
476 }
else if (yHi->getVals() == NULL) {
482 TPIXEL * dPtr = dst + yMin * width + xMin;
483 int dPtrOffset = width - xMax + xMin;
496 kv = *kernelPtr; chPtr = (TCHANNEL *) sPtr; A = *(chPtr + 3) * kv; sumR += *(chPtr++) * A; sumG += *(chPtr++) * A; sumB += *chPtr *
A; sumA +=
A;,
498 chPtr = (TCHANNEL *) dPtr;
500 sumR += 0.5; sumG += 0.5; sumB += 0.5; sumA += 0.5;
502 sumA = (sumA < 0) ? 0 : (sumA > maxVal) ? maxVal : sumA;
504 sumR = sumR / sumA + 0.5; sumG = sumG / sumA + 0.5; sumB = sumB / sumA + 0.5;
506 *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;,
540 if (this->chCount != 4) {
551 int err = filterResult_4ch(bitmap, *tmp, crop);
564 if (this->chCount != 4) {
576 int err = filterResult_4ch(bitmap, *tmp, crop);
593 if (this->chCount != 4) {
612 err = filterResult_4ch(bitmap, *tmp, crop);
628 Point mskOrig,
double alpha) {
629 if (this->chCount != 4) {
648 err = filterResult_4ch(bitmap, *tmp, crop);
656 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);
663 template<
typename TPIXEL,
typename TCHANNEL>
665 if (kernel != NULL) {