1805 lines
58 KiB
C++
1805 lines
58 KiB
C++
|
|
|
|
#include "trop.h"
|
|
#include "tpixel.h"
|
|
#include "tpixelutils.h"
|
|
|
|
// calls to _mm_* functions disabled in code for now (marked as comment)
|
|
// so disable include <emmintrin.h>
|
|
/*
|
|
#if defined(_WIN32) && defined(x64)
|
|
#define ENABLE_SSE2
|
|
#endif
|
|
|
|
#ifdef ENABLE_SSE2
|
|
#include <emmintrin.h> // per SSE2
|
|
#endif
|
|
*/
|
|
|
|
namespace {
|
|
inline double luminance(TPixel32 *pix) {
|
|
return 0.2126 * pix->r + 0.7152 * pix->g + 0.0722 * pix->b;
|
|
}
|
|
inline double luminance(TPixel64 *pix) {
|
|
return 0.2126 * pix->r + 0.7152 * pix->g + 0.0722 * pix->b;
|
|
}
|
|
} // namespace
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_BEGIN_LOOP(UpType, up, DownType, down, OutType, out) \
|
|
{ \
|
|
int upWrap = up->getWrap(); \
|
|
int downWrap = down->getWrap(); \
|
|
int outWrap = out->getWrap(); \
|
|
\
|
|
up->lock(); \
|
|
down->lock(); \
|
|
out->lock(); \
|
|
UpType *upPix = 0, *upRow = up->pixels(); \
|
|
DownType *downPix, *downRow = down->pixels(); \
|
|
OutType *outPix, *outRow = out->pixels(); \
|
|
UpType *endPix; \
|
|
int upLx = up->getLx(); \
|
|
UpType *lastPix = upRow + upWrap * (up->getLy() - 1) + upLx; \
|
|
while (upPix < lastPix) { \
|
|
upPix = upRow; \
|
|
downPix = downRow; \
|
|
outPix = outRow; \
|
|
endPix = upPix + upLx; \
|
|
while (upPix < endPix) {
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_END_LOOP(up, down, out) \
|
|
++upPix; \
|
|
++downPix; \
|
|
++outPix; \
|
|
} \
|
|
upRow += upWrap; \
|
|
downRow += downWrap; \
|
|
outRow += outWrap; \
|
|
} \
|
|
up->unlock(); \
|
|
down->unlock(); \
|
|
out->unlock(); \
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_32_BEGIN_LOOP \
|
|
assert(up32 &&down32 &&out32); \
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelRGBM32, up32, TPixelRGBM32, down32, \
|
|
TPixelRGBM32, out32)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_32_END_LOOP \
|
|
assert(up32 &&down32 &&out32); \
|
|
FOR_EACH_PIXEL_END_LOOP(up32, down32, out32)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_64_BEGIN_LOOP \
|
|
assert(up64 &&down64 &&out64); \
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelRGBM64, up64, TPixelRGBM64, down64, \
|
|
TPixelRGBM64, out64)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_64_END_LOOP \
|
|
assert(up64 &&down64 &&out64); \
|
|
FOR_EACH_PIXEL_END_LOOP(up64, down64, out64)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_8_BEGIN_LOOP \
|
|
assert(up8 &&down8 &&out8); \
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelGR8, up8, TPixelGR8, down8, TPixelGR8, out8)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FOR_EACH_PIXEL_8_END_LOOP \
|
|
assert(up8 &&down8 &&out8); \
|
|
FOR_EACH_PIXEL_END_LOOP(up32, down32, out32)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::add(const TRasterP &rup, const TRasterP &rdown, const TRasterP &rout,
|
|
double v) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
TINT32 r, g, b, m;
|
|
if (upPix->m == 0)
|
|
*outPix = *downPix;
|
|
else {
|
|
r = downPix->r + tround(upPix->r * v);
|
|
g = downPix->g + tround(upPix->g * v);
|
|
b = downPix->b + tround(upPix->b * v);
|
|
m = downPix->m + tround(upPix->m * v);
|
|
outPix->r = (UCHAR)tcrop<TINT32>(r, (TINT32)0, (TINT32)255);
|
|
outPix->g = (UCHAR)tcrop<TINT32>(g, (TINT32)0, (TINT32)255);
|
|
outPix->b = (UCHAR)tcrop<TINT32>(b, (TINT32)0, (TINT32)255);
|
|
outPix->m = (UCHAR)tcrop<TINT32>(m, (TINT32)0, (TINT32)255);
|
|
}
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TINT32 r, g, b, m;
|
|
r = downPix->r + tround(upPix->r * v);
|
|
g = downPix->g + tround(upPix->g * v);
|
|
b = downPix->b + tround(upPix->b * v);
|
|
m = downPix->m + tround(upPix->m * v);
|
|
|
|
outPix->r = (USHORT)tcrop<TINT32>(r, 0, 0xffff);
|
|
outPix->g = (USHORT)tcrop<TINT32>(g, 0, 0xffff);
|
|
outPix->b = (USHORT)tcrop<TINT32>(b, 0, 0xffff);
|
|
outPix->m = (USHORT)tcrop<TINT32>(m, 0, 0xffff);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
USHORT value = troundp(upPix->value * v) + downPix->value;
|
|
|
|
outPix->value = (UCHAR)tcrop<USHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::add invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::add(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
USHORT r, g, b, m;
|
|
r = downPix->r + upPix->r;
|
|
g = downPix->g + upPix->g;
|
|
b = downPix->b + upPix->b;
|
|
m = downPix->m + upPix->m;
|
|
|
|
outPix->r = (UCHAR)tcrop<USHORT>(r, 0, 255);
|
|
outPix->g = (UCHAR)tcrop<USHORT>(g, 0, 255);
|
|
outPix->b = (UCHAR)tcrop<USHORT>(b, 0, 255);
|
|
outPix->m = (UCHAR)tcrop<USHORT>(m, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TINT32 r, g, b, m;
|
|
r = downPix->r + upPix->r;
|
|
g = downPix->g + upPix->g;
|
|
b = downPix->b + upPix->b;
|
|
m = downPix->m + upPix->m;
|
|
|
|
outPix->r = (USHORT)tcrop<TINT32>(r, 0, 0xffff);
|
|
outPix->g = (USHORT)tcrop<TINT32>(g, 0, 0xffff);
|
|
outPix->b = (USHORT)tcrop<TINT32>(b, 0, 0xffff);
|
|
outPix->m = (USHORT)tcrop<TINT32>(m, 0, 0xffff);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
USHORT value = upPix->value + downPix->value;
|
|
|
|
outPix->value = (UCHAR)tcrop<USHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::add invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::colordodge(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
USHORT r, g, b, m;
|
|
|
|
r = (USHORT)((downPix->r << 8) / (256.0 - upPix->r));
|
|
g = (USHORT)((downPix->g << 8) / (256.0 - upPix->g));
|
|
b = (USHORT)((downPix->b << 8) / (256.0 - upPix->b));
|
|
|
|
m = downPix->m + upPix->m;
|
|
|
|
outPix->r = (UCHAR)tcrop<USHORT>(r, 0, 255);
|
|
outPix->g = (UCHAR)tcrop<USHORT>(g, 0, 255);
|
|
outPix->b = (UCHAR)tcrop<USHORT>(b, 0, 255);
|
|
outPix->m = (UCHAR)tcrop<USHORT>(m, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TINT32 r, g, b, m;
|
|
r = (TINT32)(65536.0 * (downPix->r / (65536.0 - upPix->r)));
|
|
|
|
g = (TINT32)(65536.0 * (downPix->g / (65536.0 - upPix->g)));
|
|
|
|
b = (TINT32)(65536.0 * (downPix->b / (65536.0 - upPix->b)));
|
|
|
|
m = downPix->m + upPix->m;
|
|
|
|
outPix->r = (USHORT)tcrop<TINT32>(r, 0, 0xffff);
|
|
outPix->g = (USHORT)tcrop<TINT32>(g, 0, 0xffff);
|
|
outPix->b = (USHORT)tcrop<TINT32>(b, 0, 0xffff);
|
|
outPix->m = (USHORT)tcrop<TINT32>(m, 0, 0xffff);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
USHORT value;
|
|
if (downPix->value)
|
|
value = (USHORT)((downPix->value << 8) / (255.0 - upPix->value));
|
|
|
|
outPix->value = (UCHAR)tcrop<USHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::color dodge invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::colorburn(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
// downPix->r=0;
|
|
// downPix->g=255;
|
|
// downPix->b=0;
|
|
double r, g, b;
|
|
if (upPix->m) {
|
|
if (downPix->r == 0 || downPix->r == 255)
|
|
r = downPix->r;
|
|
else if (upPix->r)
|
|
r = 255 - (((255 - downPix->r) << 8) / (double)upPix->r);
|
|
else
|
|
r = 0;
|
|
if (downPix->g == 0 || downPix->g == 255)
|
|
g = downPix->g;
|
|
else if (upPix->g)
|
|
g = 255 - (((255 - downPix->g) << 8) / (double)upPix->g);
|
|
else
|
|
g = 0;
|
|
if (downPix->b == 0 || downPix->b == 255)
|
|
b = downPix->b;
|
|
else if (upPix->b)
|
|
b = 255 - (((255 - downPix->b) << 8) / (double)upPix->b);
|
|
else
|
|
b = 0;
|
|
|
|
if (upPix->m != 255) {
|
|
TPixel32 tmpPix;
|
|
tmpPix.r = (UCHAR)tcrop<double>(r, .0, 255.0);
|
|
tmpPix.g = (UCHAR)tcrop<double>(g, .0, 255.0);
|
|
tmpPix.b = (UCHAR)tcrop<double>(b, .0, 255.0);
|
|
tmpPix.m = upPix->m;
|
|
;
|
|
overPix<TPixel32, UCHAR>(*outPix, *downPix, tmpPix);
|
|
} else {
|
|
outPix->r = (UCHAR)tcrop<double>(r, .0, 255.0);
|
|
outPix->g = (UCHAR)tcrop<double>(g, .0, 255.0);
|
|
outPix->b = (UCHAR)tcrop<double>(b, .0, 255.0);
|
|
outPix->m = downPix->m;
|
|
}
|
|
} else {
|
|
outPix = downPix;
|
|
}
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
double r, g, b;
|
|
if (upPix->m) {
|
|
if (downPix->r == 0 || downPix->r == 65535)
|
|
r = downPix->r;
|
|
else if (upPix->r)
|
|
r = 65535 - 65536 * ((65535.0 - downPix->r) / (double)upPix->r);
|
|
else
|
|
r = 0;
|
|
if (downPix->g == 0 || downPix->g == 65535)
|
|
g = downPix->g;
|
|
else if (upPix->g)
|
|
g = 65535 - 65536 * ((65535.0 - downPix->g) / (double)upPix->g);
|
|
else
|
|
g = 0;
|
|
if (downPix->b == 0 || downPix->b == 65535)
|
|
b = downPix->b;
|
|
else if (upPix->b)
|
|
b = 65535 - 65536 * ((65535.0 - downPix->b) / (double)upPix->b);
|
|
else
|
|
b = 0;
|
|
|
|
if (upPix->m != 65535) {
|
|
TPixel64 tmpPix;
|
|
tmpPix.r = (USHORT)tcrop<double>(r, .0, 65535.0);
|
|
tmpPix.g = (USHORT)tcrop<double>(g, .0, 65535.0);
|
|
tmpPix.b = (USHORT)tcrop<double>(b, .0, 65535.0);
|
|
tmpPix.m = upPix->m;
|
|
overPix<TPixel64, USHORT>(*outPix, *downPix, tmpPix);
|
|
} else {
|
|
outPix->r = (USHORT)tcrop<double>(r, .0, 65535.0);
|
|
outPix->g = (USHORT)tcrop<double>(g, .0, 65535.0);
|
|
outPix->b = (USHORT)tcrop<double>(b, .0, 65535.0);
|
|
outPix->m = downPix->m;
|
|
}
|
|
} else {
|
|
outPix = downPix;
|
|
}
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::color burn invalid raster combination");
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::screen(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
double r, g, b;
|
|
r = 256 - ((256 - upPix->r) * (256 - downPix->r) >> 8);
|
|
g = 256 - ((256 - upPix->g) * (256 - downPix->g) >> 8);
|
|
b = 256 - ((256 - upPix->b) * (256 - downPix->b) >> 8);
|
|
|
|
if (upPix->m != 255) {
|
|
double m;
|
|
m = 256 - ((256 - upPix->m) * (256 - downPix->m) >> 8);
|
|
TPixel32 tmpPix;
|
|
tmpPix.r = (UCHAR)tcrop<double>(r, 0, 255);
|
|
tmpPix.g = (UCHAR)tcrop<double>(g, 0, 255);
|
|
tmpPix.b = (UCHAR)tcrop<double>(b, 0, 255);
|
|
tmpPix.m = (UCHAR)tcrop<double>(m, 0, 255);
|
|
overPix<TPixel32, UCHAR>(*outPix, *downPix, tmpPix);
|
|
} else {
|
|
outPix->r = (UCHAR)tcrop<double>(r, 0, 255);
|
|
outPix->g = (UCHAR)tcrop<double>(g, 0, 255);
|
|
outPix->b = (UCHAR)tcrop<double>(b, 0, 255);
|
|
outPix->m = upPix->m;
|
|
}
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
double r, g, b;
|
|
r = 65536 - (65536 - upPix->r) * ((65536 - downPix->r) / 65536.0);
|
|
g = 65536 - (65536 - upPix->g) * ((65536 - downPix->g) / 65536.0);
|
|
b = 65536 - (65536 - upPix->b) * ((65536 - downPix->b) / 65536.0);
|
|
|
|
if (upPix->m != 65535) {
|
|
double m;
|
|
m = 65536 - (65536 - upPix->m) * ((65536 - downPix->m) / 65536.0);
|
|
TPixel64 tmpPix;
|
|
tmpPix.r = (USHORT)tcrop<double>(r, 0, 65535);
|
|
tmpPix.g = (USHORT)tcrop<double>(g, 0, 65535);
|
|
tmpPix.b = (USHORT)tcrop<double>(b, 0, 65535);
|
|
tmpPix.m = (USHORT)tcrop<double>(m, 0, 65535);
|
|
overPix<TPixel64, USHORT>(*outPix, *downPix, tmpPix);
|
|
} else {
|
|
outPix->r = (USHORT)tcrop<double>(r, 0, 65535);
|
|
outPix->g = (USHORT)tcrop<double>(g, 0, 65535);
|
|
outPix->b = (USHORT)tcrop<double>(b, 0, 65535);
|
|
outPix->m = upPix->m;
|
|
}
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
USHORT value;
|
|
if (downPix->value)
|
|
value = (USHORT)((downPix->value << 8) / (255.0 - upPix->value));
|
|
|
|
outPix->value = (UCHAR)tcrop<USHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::color dodge invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::sub(const TRasterP &rup, const TRasterP &rdown, const TRasterP &rout,
|
|
bool matte) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
if (matte) {
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
SHORT r = downPix->r - upPix->r;
|
|
SHORT g = downPix->g - upPix->g;
|
|
SHORT b = downPix->b - upPix->b;
|
|
SHORT m = downPix->m - upPix->m;
|
|
|
|
outPix->r = (UCHAR)tcrop<SHORT>(r, 0, 255);
|
|
outPix->g = (UCHAR)tcrop<SHORT>(g, 0, 255);
|
|
outPix->b = (UCHAR)tcrop<SHORT>(b, 0, 255);
|
|
outPix->m = (UCHAR)tcrop<SHORT>(m, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TINT32 r = downPix->r - upPix->r;
|
|
TINT32 g = downPix->g - upPix->g;
|
|
TINT32 b = downPix->b - upPix->b;
|
|
TINT32 m = downPix->m - upPix->m;
|
|
outPix->r = (USHORT)tcrop<TINT32>(r, 0, 0xffff);
|
|
outPix->g = (USHORT)tcrop<TINT32>(g, 0, 0xffff);
|
|
outPix->b = (USHORT)tcrop<TINT32>(b, 0, 0xffff);
|
|
outPix->m = (USHORT)tcrop<TINT32>(m, 0, 0xffff);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
SHORT value = upPix->value - downPix->value;
|
|
outPix->value = (UCHAR)tcrop<SHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::sub invalid raster combination");
|
|
}
|
|
}
|
|
} else {
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
SHORT r = downPix->r - upPix->r;
|
|
SHORT g = downPix->g - upPix->g;
|
|
SHORT b = downPix->b - upPix->b;
|
|
SHORT m = downPix->m; // - upPix->m;
|
|
|
|
outPix->r = (UCHAR)tcrop<SHORT>(r, 0, 255);
|
|
outPix->g = (UCHAR)tcrop<SHORT>(g, 0, 255);
|
|
outPix->b = (UCHAR)tcrop<SHORT>(b, 0, 255);
|
|
outPix->m = (UCHAR)tcrop<SHORT>(m, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TINT32 r = downPix->r - upPix->r;
|
|
TINT32 g = downPix->g - upPix->g;
|
|
TINT32 b = downPix->b - upPix->b;
|
|
TINT32 m = downPix->m; // - upPix->m;
|
|
outPix->r = (USHORT)tcrop<TINT32>(r, 0, 0xffff);
|
|
outPix->g = (USHORT)tcrop<TINT32>(g, 0, 0xffff);
|
|
outPix->b = (USHORT)tcrop<TINT32>(b, 0, 0xffff);
|
|
outPix->m = (USHORT)tcrop<TINT32>(m, 0, 0xffff);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
SHORT value = upPix->value - downPix->value;
|
|
outPix->value = (UCHAR)tcrop<SHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::sub invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::mult(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout, int v, bool matte) {
|
|
/*
|
|
Let U be 'up', D be 'down' and M be 'multiplied' (the result), and suppose for
|
|
the moment
|
|
that pixels are both NOT premultiplied and normalized to [0, 1].
|
|
|
|
The additional value v is used to add to RGB components of the U pixel:
|
|
|
|
U'_rgb = (U_rgb + v / 255)
|
|
|
|
The matte component is either U_m D_m in case (matte == true), or D_m in case
|
|
(matte == false).
|
|
Please, observe that in the case (matte == false) that choice makes the product
|
|
NOT COMMUTATIVE,
|
|
but I think that's justified - it's simply the most obvious use case.
|
|
|
|
In case (matte == true), each channel is multiplied independently, and that's
|
|
it.
|
|
|
|
The matter is more complicated when (matte == false). The problem in this case
|
|
is dealing with rgb
|
|
components when U and D both have some transparency. When U is fully
|
|
transparent, we expect the
|
|
result to be D, and vice-versa, which is non-trivial.
|
|
|
|
We REQUIRE that (let's denote r only here):
|
|
|
|
M_r = M_r_u = U_r (1 - D_m) + U_r D_r D_m, when U_m == 1 (When U is fully
|
|
opaque, M_r is a D_m-linear
|
|
combination of
|
|
U_r and U_r D_r)
|
|
M_r = M_r_d = D_r (1 - U_m) + U_r D_r U_m, when D_m == 1 (Vice-versa, when
|
|
it's D that is fully opaque)
|
|
|
|
Finally, we're building a weighted sum, by U_m and D_m of the two above:
|
|
|
|
M_r = (M_r_u * U_m + M_r_d * D_m) / (U_m + D_m) =
|
|
= (...) =
|
|
= [ U_r U_m (1 - D_m) + D_r D_m (1 - U_m) + 2 U_r U_m D_r D_m ] / (U_m +
|
|
D_m)
|
|
*/
|
|
|
|
// 32-bit images case
|
|
TRaster32P up32 = rup, down32 = rdown, out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
static const float maxChannelF = float(TPixel32::maxChannelValue);
|
|
static const UCHAR maxChannelC = UCHAR(TPixel32::maxChannelValue);
|
|
|
|
float vf = v;
|
|
|
|
if (matte) {
|
|
float dnMf, upMf_norm, outMf;
|
|
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP // Awful... should be explicit...
|
|
|
|
dnMf = downPix->m;
|
|
upMf_norm = upPix->m / maxChannelF;
|
|
|
|
outMf = downPix->m * upMf_norm;
|
|
|
|
outPix->r =
|
|
tcrop((upPix->r / upMf_norm + vf) * (downPix->r / dnMf), 0.0f, outMf);
|
|
outPix->g =
|
|
tcrop((upPix->g / upMf_norm + vf) * (downPix->g / dnMf), 0.0f, outMf);
|
|
outPix->b =
|
|
tcrop((upPix->b / upMf_norm + vf) * (downPix->b / dnMf), 0.0f, outMf);
|
|
outPix->m = outMf;
|
|
|
|
// NOTE: + 0.5f in the crop arguments could take care of rounding...
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
float umf_norm, dmf_norm, umdmf_norm, outMf;
|
|
float mSumf, uf, df, ufdf, normalizer;
|
|
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
mSumf = upPix->m + float(downPix->m);
|
|
if (mSumf > 0.0f) {
|
|
umf_norm = upPix->m / maxChannelF, dmf_norm = downPix->m / maxChannelF;
|
|
outMf = upPix->m +
|
|
(1.0f - umf_norm) *
|
|
downPix->m; // umf_norm should be ensured in [0.0, 1.0].
|
|
// Convex combination should be in the conversion range.
|
|
normalizer = outMf / (maxChannelF * mSumf);
|
|
umdmf_norm = umf_norm * dmf_norm;
|
|
|
|
uf = upPix->r + vf * umdmf_norm, df = downPix->r, ufdf = uf * df;
|
|
outPix->r = tcrop((uf * (maxChannelC - downPix->m) +
|
|
df * (maxChannelC - upPix->m) + ufdf + ufdf) *
|
|
normalizer,
|
|
0.0f, outMf);
|
|
|
|
uf = upPix->g + vf * umdmf_norm, df = downPix->g, ufdf = uf * df;
|
|
outPix->g = tcrop((uf * (maxChannelC - downPix->m) +
|
|
df * (maxChannelC - upPix->m) + ufdf + ufdf) *
|
|
normalizer,
|
|
0.0f, outMf);
|
|
|
|
uf = upPix->b + vf * umdmf_norm, df = downPix->b, ufdf = uf * df;
|
|
outPix->b = tcrop((uf * (maxChannelC - downPix->m) +
|
|
df * (maxChannelC - upPix->m) + ufdf + ufdf) *
|
|
normalizer,
|
|
0.0f, outMf);
|
|
|
|
outPix->m = outMf;
|
|
} else
|
|
*outPix = TPixel32::Transparent;
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// 64-bit images case
|
|
TRaster64P up64 = rup, down64 = rdown, out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
static const double maxChannelF = double(TPixel64::maxChannelValue);
|
|
static const USHORT maxChannelC = USHORT(TPixel64::maxChannelValue);
|
|
|
|
double vf =
|
|
v * (TPixel64::maxChannelValue / double(TPixel32::maxChannelValue));
|
|
|
|
if (matte) {
|
|
double dnMf, upMf_norm, outMf;
|
|
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
dnMf = downPix->m;
|
|
upMf_norm = upPix->m / maxChannelF;
|
|
|
|
outMf = downPix->m * upMf_norm;
|
|
|
|
outPix->r =
|
|
tcrop((upPix->r / upMf_norm + vf) * (downPix->r / dnMf), 0.0, outMf);
|
|
outPix->g =
|
|
tcrop((upPix->g / upMf_norm + vf) * (downPix->g / dnMf), 0.0, outMf);
|
|
outPix->b =
|
|
tcrop((upPix->b / upMf_norm + vf) * (downPix->b / dnMf), 0.0, outMf);
|
|
outPix->m = outMf;
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
double umf_norm, dmf_norm, umdmf_norm, outMf;
|
|
double mSumf, uf, df, ufdf, normalizer;
|
|
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
mSumf = upPix->m + double(downPix->m);
|
|
if (mSumf > 0.0) {
|
|
umf_norm = upPix->m / maxChannelF, dmf_norm = downPix->m / maxChannelF;
|
|
outMf = upPix->m + (1.0 - umf_norm) * downPix->m;
|
|
|
|
normalizer = outMf / (maxChannelF * mSumf);
|
|
umdmf_norm = umf_norm * dmf_norm;
|
|
|
|
uf = upPix->r + vf * umdmf_norm, df = downPix->r, ufdf = uf * df;
|
|
outPix->r = tcrop((uf * (maxChannelC - downPix->m) +
|
|
df * (maxChannelC - upPix->m) + ufdf + ufdf) *
|
|
normalizer,
|
|
0.0, outMf);
|
|
|
|
uf = upPix->g + vf * umdmf_norm, df = downPix->g, ufdf = uf * df;
|
|
outPix->g = tcrop((uf * (maxChannelC - downPix->m) +
|
|
df * (maxChannelC - upPix->m) + ufdf + ufdf) *
|
|
normalizer,
|
|
0.0, outMf);
|
|
|
|
uf = upPix->b + vf * umdmf_norm, df = downPix->b, ufdf = uf * df;
|
|
outPix->b = tcrop((uf * (maxChannelC - downPix->m) +
|
|
df * (maxChannelC - upPix->m) + ufdf + ufdf) *
|
|
normalizer,
|
|
0.0, outMf);
|
|
|
|
outPix->m = outMf;
|
|
} else
|
|
*outPix = TPixel64::Transparent;
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// According to the specifics, throw an exception. I think it's not
|
|
// appropriate, though.
|
|
throw TRopException("TRop::mult invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::ropin(const TRasterP &source, const TRasterP &matte,
|
|
const TRasterP &rout) {
|
|
TRaster32P source32 = source;
|
|
TRaster32P matte32 = matte;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P source64 = source;
|
|
TRaster64P matte64 = matte;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (source32 && matte32 && out32) {
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelRGBM32, source32, TPixelRGBM32, matte32,
|
|
TPixelRGBM32, out32)
|
|
|
|
if (downPix->m == 0)
|
|
outPix->r = outPix->g = outPix->b = outPix->m = 0;
|
|
else if (downPix->m == 255)
|
|
*outPix = *upPix;
|
|
else {
|
|
/*
|
|
__m128i zeros = _mm_setzero_si128();
|
|
|
|
__m128i upPix_packed_i= _mm_unpacklo_epi8(_mm_cvtsi32_si128(*(DWORD*)upPix),
|
|
zeros);
|
|
__m128 upPix_packed = _mm_cvtepi32_ps(_mm_unpacklo_epi16(upPix_packed_i,
|
|
zeros));
|
|
|
|
float fac = downPix->m / 255.0;
|
|
__m128 fac_packed = _mm_load1_ps(&fac);
|
|
|
|
upPix_packed = _mm_mul_ps(upPix_packed, fac_packed);
|
|
|
|
__m128i outPix_packed_i = _mm_cvtps_epi32(upPix_packed);
|
|
outPix_packed_i = _mm_packs_epi32(outPix_packed_i, zeros);
|
|
outPix_packed_i = _mm_packus_epi16(outPix_packed_i, zeros);
|
|
*(DWORD*)(outPix) = _mm_cvtsi128_si32(outPix_packed_i);
|
|
*/
|
|
|
|
const int MAGICFAC = (257U * 256U + 1U);
|
|
UINT fac = MAGICFAC * downPix->m;
|
|
|
|
outPix->r = (UINT)(upPix->r * fac + (1U << 23)) >> 24;
|
|
outPix->g = (UINT)(upPix->g * fac + (1U << 23)) >> 24;
|
|
outPix->b = (UINT)(upPix->b * fac + (1U << 23)) >> 24;
|
|
outPix->m = (UINT)(upPix->m * fac + (1U << 23)) >> 24;
|
|
}
|
|
|
|
FOR_EACH_PIXEL_END_LOOP(source32, matte32, out32)
|
|
} else if (source64 && matte64 && out64)
|
|
|
|
{
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelRGBM64, source64, TPixelRGBM64, matte64,
|
|
TPixelRGBM64, out64)
|
|
|
|
if (downPix->m == 0)
|
|
outPix->r = outPix->g = outPix->b = outPix->m = 0;
|
|
else if (downPix->m == 65535)
|
|
*outPix = *upPix;
|
|
else {
|
|
/*
|
|
__m128i zeros = _mm_setzero_si128();
|
|
|
|
__m128i upPix_packed_i= _mm_unpacklo_epi8(_mm_cvtsi32_si128(*(DWORD*)upPix),
|
|
zeros);
|
|
__m128 upPix_packed = _mm_cvtepi32_ps(_mm_unpacklo_epi16(upPix_packed_i,
|
|
zeros));
|
|
|
|
float fac = downPix->m / 255.0;
|
|
__m128 fac_packed = _mm_load1_ps(&fac);
|
|
|
|
upPix_packed = _mm_mul_ps(upPix_packed, fac_packed);
|
|
|
|
__m128i outPix_packed_i = _mm_cvtps_epi32(upPix_packed);
|
|
outPix_packed_i = _mm_packs_epi32(outPix_packed_i, zeros);
|
|
outPix_packed_i = _mm_packus_epi16(outPix_packed_i, zeros);
|
|
*(DWORD*)(outPix) = _mm_cvtsi128_si32(outPix_packed_i);
|
|
*/
|
|
double fac = downPix->m / 65535.0;
|
|
|
|
outPix->r = (USHORT)(upPix->r * fac);
|
|
outPix->g = (USHORT)(upPix->g * fac);
|
|
outPix->b = (USHORT)(upPix->b * fac);
|
|
outPix->m = (USHORT)(upPix->m * fac);
|
|
}
|
|
|
|
FOR_EACH_PIXEL_END_LOOP(source64, matte64, out64)
|
|
} else
|
|
throw TRopException("TRop::in invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::ropout(const TRasterP &source, const TRasterP &matte,
|
|
const TRasterP &rout) {
|
|
TRaster32P source32 = source;
|
|
TRaster32P matte32 = matte;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P source64 = source;
|
|
TRaster64P matte64 = matte;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (source32 && matte32 && out32) {
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelRGBM32, source32, TPixelRGBM32, matte32,
|
|
TPixelRGBM32, out32)
|
|
|
|
if (downPix->m == 255)
|
|
outPix->r = outPix->g = outPix->b = outPix->m = 0;
|
|
else if (downPix->m == 0)
|
|
*outPix = *upPix;
|
|
else {
|
|
const int MAGICFAC = (257U * 256U + 1U);
|
|
UINT fac = MAGICFAC * (255 - downPix->m);
|
|
|
|
outPix->r = (UINT)(upPix->r * fac + (1U << 23)) >> 24;
|
|
outPix->g = (UINT)(upPix->g * fac + (1U << 23)) >> 24;
|
|
outPix->b = (UINT)(upPix->b * fac + (1U << 23)) >> 24;
|
|
outPix->m = (UINT)(upPix->m * fac + (1U << 23)) >> 24;
|
|
}
|
|
|
|
FOR_EACH_PIXEL_END_LOOP(source32, matte32, out32)
|
|
} else if (source64 && matte64 && out64) {
|
|
FOR_EACH_PIXEL_BEGIN_LOOP(TPixelRGBM64, source64, TPixelRGBM64, matte64,
|
|
TPixelRGBM64, out64)
|
|
|
|
if (downPix->m == 65535)
|
|
outPix->r = outPix->g = outPix->b = outPix->m = 0;
|
|
else if (downPix->m == 0)
|
|
*outPix = *upPix;
|
|
else {
|
|
double fac = (65535 - downPix->m) / 65535.0;
|
|
|
|
outPix->r = (USHORT)(upPix->r * fac);
|
|
outPix->g = (USHORT)(upPix->g * fac);
|
|
outPix->b = (USHORT)(upPix->b * fac);
|
|
outPix->m = (USHORT)(upPix->m * fac);
|
|
}
|
|
|
|
FOR_EACH_PIXEL_END_LOOP(source64, matte64, out64)
|
|
} else
|
|
throw TRopException("TRop::out invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::atop(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
// calcola rup ATOP rdown
|
|
|
|
// da ottimizzare...
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
TPixel32 tmpPix(0, 0, 0, 0);
|
|
if (downPix->m != 0) {
|
|
const int MAGICFAC = (257U * 256U + 1U);
|
|
UINT fac = MAGICFAC * downPix->m;
|
|
|
|
tmpPix.r = (UINT)(upPix->r * fac + (1U << 23)) >> 24;
|
|
tmpPix.g = (UINT)(upPix->g * fac + (1U << 23)) >> 24;
|
|
tmpPix.b = (UINT)(upPix->b * fac + (1U << 23)) >> 24;
|
|
tmpPix.m = (UINT)(upPix->m * fac + (1U << 23)) >> 24;
|
|
}
|
|
|
|
overPix<TPixel32, UCHAR>(*outPix, *downPix, tmpPix);
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TPixel64 tmpPix(0, 0, 0, 0);
|
|
if (downPix->m != 0) {
|
|
double fac = downPix->m / 65535.0;
|
|
|
|
tmpPix.r = (USHORT)(upPix->r * fac);
|
|
tmpPix.g = (USHORT)(upPix->g * fac);
|
|
tmpPix.b = (USHORT)(upPix->b * fac);
|
|
tmpPix.m = (USHORT)(upPix->m * fac);
|
|
}
|
|
|
|
overPix<TPixel64, USHORT>(*outPix, *downPix, tmpPix);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::atop invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::txor(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
// da ottimizzare...
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
TUINT32 notUpM = 255 - upPix->m;
|
|
TUINT32 notDownM = 255 - downPix->m;
|
|
|
|
TUINT32 r = notUpM + upPix->r * (notDownM);
|
|
TUINT32 g = notUpM + upPix->g * (notDownM);
|
|
TUINT32 b = notUpM + upPix->b * (notDownM);
|
|
|
|
outPix->r = (UCHAR)tcrop<TUINT32>(0, 255, r);
|
|
outPix->g = (UCHAR)tcrop<TUINT32>(0, 255, g);
|
|
outPix->b = (UCHAR)tcrop<TUINT32>(0, 255, b);
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
TUINT32 notUpM = 65535 - upPix->m;
|
|
TUINT32 notDownM = 65535 - downPix->m;
|
|
|
|
TUINT32 r = notUpM + upPix->r * (notDownM);
|
|
TUINT32 g = notUpM + upPix->g * (notDownM);
|
|
TUINT32 b = notUpM + upPix->b * (notDownM);
|
|
|
|
outPix->r = (USHORT)tcrop<TUINT32>(0, 65535, r);
|
|
outPix->g = (USHORT)tcrop<TUINT32>(0, 65535, g);
|
|
outPix->b = (USHORT)tcrop<TUINT32>(0, 65535, b);
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::xor invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::crossDissolve(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout, UCHAR v) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
outPix->r = (upPix->r * v + downPix->r * (255 - v)) / 255;
|
|
outPix->g = (upPix->g * v + downPix->g * (255 - v)) / 255;
|
|
outPix->b = (upPix->b * v + downPix->b * (255 - v)) / 255;
|
|
outPix->m = (upPix->m * v + downPix->m * (255 - v)) / 255;
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else if (up64 && down64 && out64) {
|
|
USHORT vv = v * 257;
|
|
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
outPix->r = (upPix->r * vv + downPix->r * (65535 - vv)) / 65535;
|
|
outPix->g = (upPix->g * vv + downPix->g * (65535 - vv)) / 65535;
|
|
outPix->b = (upPix->b * vv + downPix->b * (65535 - vv)) / 65535;
|
|
outPix->m = (upPix->m * vv + downPix->m * (65535 - vv)) / 65535;
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::crossDissolve invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::darken(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
double value0 = luminance(upPix);
|
|
double value1 = luminance(downPix);
|
|
|
|
if (value0 < value1)
|
|
*outPix = *upPix;
|
|
else
|
|
*outPix = *downPix;
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
double value0 = luminance(upPix);
|
|
double value1 = luminance(downPix);
|
|
|
|
if (value0 < value1)
|
|
*outPix = *upPix;
|
|
else
|
|
*outPix = *downPix;
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::darken invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::lighten(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
double value0 = luminance(upPix);
|
|
double value1 = luminance(downPix);
|
|
|
|
if (value0 > value1) {
|
|
TINT32 r, g, b, m;
|
|
if (upPix->m == 0)
|
|
*outPix = *downPix;
|
|
else {
|
|
r = downPix->r + upPix->r;
|
|
g = downPix->g + upPix->g;
|
|
b = downPix->b + upPix->b;
|
|
m = downPix->m + upPix->m;
|
|
outPix->r = (UCHAR)tcrop<TINT32>(r, (TINT32)0, (TINT32)255);
|
|
outPix->g = (UCHAR)tcrop<TINT32>(g, (TINT32)0, (TINT32)255);
|
|
outPix->b = (UCHAR)tcrop<TINT32>(b, (TINT32)0, (TINT32)255);
|
|
outPix->m = (UCHAR)tcrop<TINT32>(m, (TINT32)0, (TINT32)255);
|
|
}
|
|
} else {
|
|
*outPix = *downPix;
|
|
}
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
double value0 = luminance(upPix);
|
|
double value1 = luminance(downPix);
|
|
|
|
if (value0 > value1) {
|
|
TINT32 r, g, b, m;
|
|
if (upPix->m == 0)
|
|
*outPix = *downPix;
|
|
else {
|
|
r = downPix->r + upPix->r;
|
|
g = downPix->g + upPix->g;
|
|
b = downPix->b + upPix->b;
|
|
m = downPix->m + upPix->m;
|
|
outPix->r = (USHORT)tcrop<TINT32>(r, (TINT32)0, (TINT32)65535);
|
|
outPix->g = (USHORT)tcrop<TINT32>(g, (TINT32)0, (TINT32)65535);
|
|
outPix->b = (USHORT)tcrop<TINT32>(b, (TINT32)0, (TINT32)65535);
|
|
outPix->m = (USHORT)tcrop<TINT32>(m, (TINT32)0, (TINT32)65535);
|
|
}
|
|
} else {
|
|
*outPix = *downPix;
|
|
}
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::lighten invalid raster combination");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::ropmin(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout, bool matte) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
if (matte) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
outPix->r = upPix->r < downPix->r ? upPix->r : downPix->r;
|
|
outPix->g = upPix->g < downPix->g ? upPix->g : downPix->g;
|
|
outPix->b = upPix->b < downPix->b ? upPix->b : downPix->b;
|
|
outPix->m = upPix->m < downPix->m ? upPix->m : downPix->m;
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
if (upPix->m >= 255) {
|
|
outPix->r = upPix->r < downPix->r ? upPix->r : downPix->r;
|
|
outPix->g = upPix->g < downPix->g ? upPix->g : downPix->g;
|
|
outPix->b = upPix->b < downPix->b ? upPix->b : downPix->b;
|
|
outPix->m = upPix->m < downPix->m ? upPix->m : downPix->m;
|
|
|
|
} else if (upPix->m) {
|
|
TPixel32 tmp;
|
|
tmp.r = upPix->r < downPix->r ? upPix->r : downPix->r;
|
|
tmp.g = upPix->g < downPix->g ? upPix->g : downPix->g;
|
|
tmp.b = upPix->b < downPix->b ? upPix->b : downPix->b;
|
|
// tmp.m = upPix->m < downPix->m ? upPix->m : downPix->m;
|
|
outPix->r = upPix->m * (tmp.r - downPix->r) / 255.0 + downPix->r;
|
|
outPix->g = upPix->m * (tmp.g - downPix->g) / 255.0 + downPix->g;
|
|
outPix->b = upPix->m * (tmp.b - downPix->b) / 255.0 + downPix->b;
|
|
outPix->m = upPix->m * (tmp.m - downPix->m) / 255.0 + downPix->m;
|
|
} else
|
|
*outPix = *downPix;
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
}
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
if (matte) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
outPix->r = upPix->r < downPix->r ? upPix->r : downPix->r;
|
|
outPix->g = upPix->g < downPix->g ? upPix->g : downPix->g;
|
|
outPix->b = upPix->b < downPix->b ? upPix->b : downPix->b;
|
|
outPix->m = upPix->m < downPix->m ? upPix->m : downPix->m;
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
if (upPix->m >= 65535) {
|
|
outPix->r = upPix->r < downPix->r ? upPix->r : downPix->r;
|
|
outPix->g = upPix->g < downPix->g ? upPix->g : downPix->g;
|
|
outPix->b = upPix->b < downPix->b ? upPix->b : downPix->b;
|
|
outPix->m = upPix->m < downPix->m ? upPix->m : downPix->m;
|
|
|
|
} else if (upPix->m) {
|
|
TPixel32 tmp;
|
|
tmp.r = upPix->r < downPix->r ? upPix->r : downPix->r;
|
|
tmp.g = upPix->g < downPix->g ? upPix->g : downPix->g;
|
|
tmp.b = upPix->b < downPix->b ? upPix->b : downPix->b;
|
|
// tmp.m = upPix->m < downPix->m ? upPix->m : downPix->m;
|
|
outPix->r = upPix->m * (tmp.r - downPix->r) / 65535.0 + downPix->r;
|
|
outPix->g = upPix->m * (tmp.g - downPix->g) / 65535.0 + downPix->g;
|
|
outPix->b = upPix->m * (tmp.b - downPix->b) / 65535.0 + downPix->b;
|
|
outPix->m = upPix->m * (tmp.m - downPix->m) / 65535.0 + downPix->m;
|
|
} else
|
|
*outPix = *downPix;
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
}
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
outPix->value =
|
|
upPix->value < downPix->value ? upPix->value : downPix->value;
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::min invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::ropmax(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
|
|
outPix->r = upPix->r > downPix->r ? upPix->r : downPix->r;
|
|
outPix->g = upPix->g > downPix->g ? upPix->g : downPix->g;
|
|
outPix->b = upPix->b > downPix->b ? upPix->b : downPix->b;
|
|
outPix->m = upPix->m > downPix->m ? upPix->m : downPix->m;
|
|
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
outPix->r = upPix->r > downPix->r ? upPix->r : downPix->r;
|
|
outPix->g = upPix->g > downPix->g ? upPix->g : downPix->g;
|
|
outPix->b = upPix->b > downPix->b ? upPix->b : downPix->b;
|
|
outPix->m = upPix->m > downPix->m ? upPix->m : downPix->m;
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
outPix->value =
|
|
upPix->value > downPix->value ? upPix->value : downPix->value;
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::max invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::linearburn(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
if (upPix->m) {
|
|
TPixel32 app;
|
|
if (downPix->m) {
|
|
TINT32 r, g, b, m;
|
|
TPixel32 tmpPix;
|
|
tmpPix = depremultiply(*downPix);
|
|
r = tmpPix.r + upPix->r - 255;
|
|
g = tmpPix.g + upPix->g - 255;
|
|
b = tmpPix.b + upPix->b - 255;
|
|
m = tmpPix.m + upPix->m - 255;
|
|
|
|
app.r = (UCHAR)tcrop<TINT32>(r, (TINT32)0, (TINT32)255);
|
|
app.g = (UCHAR)tcrop<TINT32>(g, (TINT32)0, (TINT32)255);
|
|
app.b = (UCHAR)tcrop<TINT32>(b, (TINT32)0, (TINT32)255);
|
|
// app.m = (UCHAR)tcrop<TINT32> (m, (TINT32)0, (TINT32)255);
|
|
app.m = upPix->m;
|
|
} else
|
|
app = *upPix;
|
|
overPix<TPixel32, UCHAR>(*outPix, *downPix, app);
|
|
}
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
if (upPix->m) {
|
|
TPixel64 app;
|
|
if (downPix->m) {
|
|
TINT32 r, g, b, m;
|
|
TPixel64 tmpPix;
|
|
tmpPix = depremultiply(*downPix);
|
|
r = tmpPix.r + upPix->r - 65535;
|
|
g = tmpPix.g + upPix->g - 65535;
|
|
b = tmpPix.b + upPix->b - 65535;
|
|
m = tmpPix.m + upPix->m - 65535;
|
|
|
|
app.r = (USHORT)tcrop<TINT32>(r, 0, 0xffff);
|
|
app.g = (USHORT)tcrop<TINT32>(g, 0, 0xffff);
|
|
app.b = (USHORT)tcrop<TINT32>(b, 0, 0xffff);
|
|
// app.m = (UCHAR)tcrop<TINT32> (m, (TINT32)0, (TINT32)255);
|
|
app.m = upPix->m;
|
|
} else
|
|
app = *upPix;
|
|
overPix<TPixel64, USHORT>(*outPix, *downPix, app);
|
|
}
|
|
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
USHORT value = troundp(upPix->value + downPix->value - 255);
|
|
|
|
outPix->value = (UCHAR)tcrop<USHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::max invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::overlay(const TRasterP &rup, const TRasterP &rdown,
|
|
const TRasterP &rout) {
|
|
TRaster32P up32 = rup;
|
|
TRaster32P down32 = rdown;
|
|
TRaster32P out32 = rout;
|
|
|
|
if (up32 && down32 && out32) {
|
|
FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
if (upPix->m) {
|
|
TPixel32 app;
|
|
TPixel32 tmpPix, tmp2Pix;
|
|
if (downPix->m) {
|
|
tmpPix = *downPix;
|
|
tmp2Pix = depremultiply(*upPix);
|
|
if (tmpPix.r < 128)
|
|
app.r = troundp(2 * tmp2Pix.r * (tmpPix.r / 255.0));
|
|
else {
|
|
SHORT r =
|
|
255 *
|
|
(1 - 2 * (1.0 - tmpPix.r / 255.0) * (1.0 - tmp2Pix.r / 255.0));
|
|
app.r = (UCHAR)tcrop<SHORT>(r, 0, 255);
|
|
}
|
|
if (tmpPix.g < 128)
|
|
app.g = troundp(2 * tmp2Pix.g * (tmpPix.g / 255.0));
|
|
else {
|
|
SHORT g =
|
|
255 *
|
|
(1 - 2 * (1.0 - tmpPix.g / 255.0) * (1.0 - tmp2Pix.g / 255.0));
|
|
app.g = (UCHAR)tcrop<SHORT>(g, 0, 255);
|
|
}
|
|
if (tmpPix.b < 128)
|
|
app.b = troundp(2 * tmp2Pix.b * (tmpPix.b / 255.0));
|
|
else {
|
|
SHORT b =
|
|
255 *
|
|
(1 - 2 * (1.0 - tmpPix.b / 255.0) * (1.0 - tmp2Pix.b / 255.0));
|
|
app.b = (UCHAR)tcrop<SHORT>(b, 0, 255);
|
|
}
|
|
app.m = tmp2Pix.m;
|
|
app = premultiply(app);
|
|
} else
|
|
app = *upPix;
|
|
overPix<TPixel32, UCHAR>(*outPix, *downPix, app);
|
|
}
|
|
FOR_EACH_PIXEL_32_END_LOOP
|
|
} else {
|
|
TRaster64P up64 = rup;
|
|
TRaster64P down64 = rdown;
|
|
TRaster64P out64 = rout;
|
|
|
|
if (up64 && down64 && out64) {
|
|
FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
|
|
if (upPix->m) {
|
|
TPixel64 app;
|
|
TPixel64 tmpPix, tmp2Pix;
|
|
if (downPix->m) {
|
|
tmpPix = *downPix;
|
|
tmp2Pix = depremultiply(*upPix);
|
|
if (tmpPix.r < 32768)
|
|
app.r = troundp(2 * tmp2Pix.r * (tmpPix.r / 65535.0));
|
|
else {
|
|
SHORT r = 65535 * (1 -
|
|
2 * (1.0 - tmpPix.r / 65535.0) *
|
|
(1.0 - tmp2Pix.r / 65535.0));
|
|
app.r = (USHORT)tcrop<TINT32>(r, 0, 65535);
|
|
}
|
|
if (tmpPix.g < 32768)
|
|
app.g = troundp(2 * tmp2Pix.g * (tmpPix.g / 65535.0));
|
|
else {
|
|
SHORT g = 65535 * (1 -
|
|
2 * (1.0 - tmpPix.g / 65535.0) *
|
|
(1.0 - tmp2Pix.g / 65535.0));
|
|
app.g = (USHORT)tcrop<TINT32>(g, 0, 65535);
|
|
}
|
|
if (tmpPix.b < 32768)
|
|
app.b = troundp(2 * tmp2Pix.b * (tmpPix.b / 65535.0));
|
|
else {
|
|
SHORT b = 65535 * (1 -
|
|
2 * (1.0 - tmpPix.b / 65535.0) *
|
|
(1.0 - tmp2Pix.b / 65535.0));
|
|
app.b = (USHORT)tcrop<TINT32>(b, 0, 65535);
|
|
}
|
|
app.m = tmp2Pix.m;
|
|
app = premultiply(app);
|
|
} else
|
|
app = *upPix;
|
|
overPix<TPixel64, USHORT>(*outPix, *downPix, app);
|
|
}
|
|
FOR_EACH_PIXEL_64_END_LOOP
|
|
} else {
|
|
TRasterGR8P up8 = rup;
|
|
TRasterGR8P down8 = rdown;
|
|
TRasterGR8P out8 = rout;
|
|
|
|
if (up8 && down8 && out8) {
|
|
FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
|
|
USHORT value;
|
|
if (downPix->value < 128)
|
|
value = troundp(2 * upPix->value * (downPix->value / 255.0));
|
|
else
|
|
value = 255 * (1 -
|
|
2 * (1.0 - downPix->value / 255.0) *
|
|
(1.0 - upPix->value / 255.0));
|
|
outPix->value = (UCHAR)tcrop<USHORT>(value, 0, 255);
|
|
|
|
FOR_EACH_PIXEL_8_END_LOOP
|
|
} else
|
|
throw TRopException("TRop::max invalid raster combination");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::premultiply(const TRasterP &ras) {
|
|
ras->lock();
|
|
TRaster32P ras32 = ras;
|
|
if (ras32) {
|
|
TPixel32 *endPix, *upPix = 0, *upRow = ras32->pixels();
|
|
TPixel32 *lastPix =
|
|
upRow + ras32->getWrap() * (ras32->getLy() - 1) + ras32->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras32->getLx();
|
|
while (upPix < endPix) {
|
|
premult(*upPix);
|
|
++upPix;
|
|
}
|
|
upRow += ras32->getWrap();
|
|
}
|
|
} else {
|
|
TRaster64P ras64 = ras;
|
|
if (ras64) {
|
|
TPixel64 *endPix, *upPix = 0, *upRow = ras64->pixels();
|
|
TPixel64 *lastPix =
|
|
upRow + ras64->getWrap() * (ras64->getLy() - 1) + ras64->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras64->getLx();
|
|
while (upPix < endPix) {
|
|
premult(*upPix);
|
|
++upPix;
|
|
}
|
|
upRow += ras64->getWrap();
|
|
}
|
|
} else {
|
|
ras->unlock();
|
|
throw TException("TRop::premultiply invalid raster type");
|
|
}
|
|
}
|
|
ras->unlock();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::depremultiply(const TRasterP &ras) {
|
|
ras->lock();
|
|
TRaster32P ras32 = ras;
|
|
if (ras32) {
|
|
TPixel32 *endPix, *upPix = 0, *upRow = ras32->pixels();
|
|
TPixel32 *lastPix =
|
|
upRow + ras32->getWrap() * (ras32->getLy() - 1) + ras32->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras32->getLx();
|
|
while (upPix < endPix) {
|
|
if (upPix->m != 0) depremult(*upPix);
|
|
++upPix;
|
|
}
|
|
upRow += ras32->getWrap();
|
|
}
|
|
} else {
|
|
TRaster64P ras64 = ras;
|
|
if (ras64) {
|
|
TPixel64 *endPix, *upPix = 0, *upRow = ras64->pixels();
|
|
TPixel64 *lastPix =
|
|
upRow + ras64->getWrap() * (ras64->getLy() - 1) + ras64->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras64->getLx();
|
|
while (upPix < endPix) {
|
|
if (upPix->m != 0) depremult(*upPix);
|
|
++upPix;
|
|
}
|
|
upRow += ras64->getWrap();
|
|
}
|
|
} else {
|
|
ras->unlock();
|
|
throw TException("TRop::depremultiply invalid raster type");
|
|
}
|
|
}
|
|
ras->unlock();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::expandColor(const TRaster32P &ras32, bool precise) {
|
|
struct locals {
|
|
static void copyRGB(TPixel32 *dst, TPixel32 *src) {
|
|
dst->r = src->r;
|
|
dst->g = src->g;
|
|
dst->b = src->b;
|
|
}
|
|
}; // locals
|
|
ras32->lock();
|
|
TPixel32 *endPix, *upPix = 0, *upRow = ras32->pixels();
|
|
TPixel32 *lastPix =
|
|
upRow + ras32->getWrap() * (ras32->getLy() - 1) + ras32->getLx();
|
|
int currentRow = 0;
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras32->getLx();
|
|
while (upPix < endPix) {
|
|
if (upPix->m == 0) {
|
|
// search 4-neighbor pixels
|
|
// left
|
|
if (upPix != upRow && (upPix - 1)->m != 0)
|
|
locals::copyRGB(upPix, upPix - 1);
|
|
// right
|
|
else if (upPix != endPix - 1 && (upPix + 1)->m != 0)
|
|
locals::copyRGB(upPix, upPix + 1);
|
|
// up
|
|
else if (currentRow != 0 && (upPix - ras32->getWrap())->m != 0)
|
|
locals::copyRGB(upPix, upPix - ras32->getWrap());
|
|
// down
|
|
else if (currentRow != ras32->getLy() - 1 &&
|
|
(upPix + ras32->getWrap())->m != 0)
|
|
locals::copyRGB(upPix, upPix + ras32->getWrap());
|
|
// search 8-neighbor pixels
|
|
else if (precise) {
|
|
// upper left
|
|
if (currentRow != 0 && upPix != upRow &&
|
|
(upPix - ras32->getWrap() - 1)->m != 0)
|
|
locals::copyRGB(upPix, upPix - ras32->getWrap() - 1);
|
|
// upper right
|
|
else if (currentRow != 0 && upPix != endPix - 1 &&
|
|
(upPix - ras32->getWrap() + 1)->m != 0)
|
|
locals::copyRGB(upPix, upPix - ras32->getWrap() + 1);
|
|
// lower left
|
|
else if (currentRow != ras32->getLy() - 1 && upPix != upRow &&
|
|
(upPix + ras32->getWrap() - 1)->m != 0)
|
|
locals::copyRGB(upPix, upPix + ras32->getWrap() - 1);
|
|
// lower right
|
|
else if (currentRow != ras32->getLy() - 1 && upPix != endPix - 1 &&
|
|
(upPix + ras32->getWrap() + 1)->m != 0)
|
|
locals::copyRGB(upPix, upPix + ras32->getWrap() + 1);
|
|
}
|
|
}
|
|
++upPix;
|
|
}
|
|
upRow += ras32->getWrap();
|
|
currentRow++;
|
|
}
|
|
ras32->unlock();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::whiteTransp(const TRasterP &ras) {
|
|
ras->lock();
|
|
TRaster32P ras32 = ras;
|
|
if (ras32) {
|
|
TPixel32 *endPix, *upPix = 0, *upRow = ras32->pixels();
|
|
TPixel32 *lastPix =
|
|
upRow + ras32->getWrap() * (ras32->getLy() - 1) + ras32->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras32->getLx();
|
|
while (upPix < endPix) {
|
|
if (*upPix == TPixel::White) *upPix = TPixel::Transparent;
|
|
++upPix;
|
|
}
|
|
upRow += ras32->getWrap();
|
|
}
|
|
} else {
|
|
TRaster64P ras64 = ras;
|
|
if (ras64) {
|
|
TPixel64 *endPix, *upPix = 0, *upRow = ras64->pixels();
|
|
TPixel64 *lastPix =
|
|
upRow + ras64->getWrap() * (ras64->getLy() - 1) + ras64->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras64->getLx();
|
|
while (upPix < endPix) {
|
|
if (*upPix == TPixel64::White) *upPix = TPixel64::Transparent;
|
|
++upPix;
|
|
}
|
|
upRow += ras64->getWrap();
|
|
}
|
|
} else {
|
|
ras->unlock();
|
|
throw TException("TRop::premultiply invalid raster type");
|
|
}
|
|
}
|
|
ras->unlock();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRop::applyColorScale(const TRasterP &ras, const TPixel32 &colorScale) {
|
|
ras->lock();
|
|
|
|
TRop::depremultiply(ras);
|
|
|
|
TRaster32P ras32 = ras;
|
|
int maxCh = TPixel32::maxChannelValue;
|
|
if (ras32) {
|
|
TPixel32 *endPix, *upPix = 0, *upRow = ras32->pixels();
|
|
TPixel32 *lastPix =
|
|
upRow + ras32->getWrap() * (ras32->getLy() - 1) + ras32->getLx();
|
|
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras32->getLx();
|
|
while (upPix < endPix) {
|
|
int maxCh = TPixel32::maxChannelValue;
|
|
int r = maxCh - (maxCh - (*upPix).r) * (maxCh - colorScale.r) / maxCh;
|
|
int g = maxCh - (maxCh - (*upPix).g) * (maxCh - colorScale.g) / maxCh;
|
|
int b = maxCh - (maxCh - (*upPix).b) * (maxCh - colorScale.b) / maxCh;
|
|
int m = (*upPix).m * colorScale.m / maxCh;
|
|
*upPix = TPixel32(r, g, b, m);
|
|
++upPix;
|
|
}
|
|
upRow += ras32->getWrap();
|
|
}
|
|
} else {
|
|
TRaster64P ras64 = ras;
|
|
if (ras64) {
|
|
TPixel64 *endPix, *upPix = 0, *upRow = ras64->pixels();
|
|
TPixel64 *lastPix =
|
|
upRow + ras64->getWrap() * (ras64->getLy() - 1) + ras64->getLx();
|
|
|
|
int maxCh64 = TPixel64::maxChannelValue;
|
|
while (upPix < lastPix) {
|
|
upPix = upRow;
|
|
endPix = upPix + ras64->getLx();
|
|
while (upPix < endPix) {
|
|
int r =
|
|
maxCh64 - (maxCh64 - (*upPix).r) * (maxCh - colorScale.r) / maxCh;
|
|
int g =
|
|
maxCh64 - (maxCh64 - (*upPix).g) * (maxCh - colorScale.g) / maxCh;
|
|
int b =
|
|
maxCh64 - (maxCh64 - (*upPix).b) * (maxCh - colorScale.b) / maxCh;
|
|
int m = (*upPix).m * colorScale.m / maxCh;
|
|
*upPix = TPixel64(r, g, b, m);
|
|
++upPix;
|
|
}
|
|
upRow += ras64->getWrap();
|
|
}
|
|
} else {
|
|
ras->unlock();
|
|
throw TException("TRop::premultiply invalid raster type");
|
|
}
|
|
}
|
|
TRop::premultiply(ras);
|
|
ras->unlock();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename Chan>
|
|
const double *premultiplyTable() {
|
|
static double *table = 0;
|
|
if (!table) {
|
|
int maxChannelValue = (std::numeric_limits<Chan>::max)();
|
|
int chanValuesCount = maxChannelValue + 1;
|
|
double maxD = maxChannelValue;
|
|
|
|
table = new double[chanValuesCount];
|
|
|
|
for (int i = 0; i < chanValuesCount; ++i) table[i] = i / maxD;
|
|
}
|
|
|
|
return table;
|
|
}
|
|
|
|
template DVAPI const double *premultiplyTable<UCHAR>();
|
|
template DVAPI const double *premultiplyTable<USHORT>();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename Chan>
|
|
const double *depremultiplyTable() {
|
|
static double *table = 0;
|
|
if (!table) {
|
|
int maxChannelValue = (std::numeric_limits<Chan>::max)();
|
|
int chanValuesCount = maxChannelValue + 1;
|
|
double maxD = maxChannelValue;
|
|
|
|
table = new double[chanValuesCount];
|
|
|
|
table[0] = 0.0;
|
|
for (int i = 1; i < chanValuesCount; ++i) table[i] = maxD / i;
|
|
}
|
|
|
|
return table;
|
|
}
|
|
|
|
template DVAPI const double *depremultiplyTable<UCHAR>();
|
|
template DVAPI const double *depremultiplyTable<USHORT>();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#undef FOR_EACH_PIXEL_BEGIN_LOOP
|
|
#undef FOR_EACH_PIXEL_32_BEGIN_LOOP
|
|
#undef FOR_EACH_PIXEL_64_BEGIN_LOOP
|
|
#undef FOR_EACH_PIXEL_8_BEGIN_LOOP
|
|
#undef FOR_EACH_PIXEL_END_LOOP
|
|
#undef FOR_EACH_PIXEL_32_END_LOOP
|
|
#undef FOR_EACH_PIXEL_64_END_LOOP
|
|
#undef FOR_EACH_PIXEL_8_END_LOOP
|