288 lines
6.1 KiB
C++
288 lines
6.1 KiB
C++
|
|
|
|
#include "tscannerutil.h"
|
|
|
|
#include <cstring>
|
|
|
|
#define BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) \
|
|
(((UCHAR *)(BUF))[(((X) + (BITOFFS)) >> 3) + (Y) * (BYTEWRAP)])
|
|
|
|
#define GET_BIT(X, Y, BUF, BYTEWRAP, BITOFFS) \
|
|
((BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) >> (7 - (((X) + (BITOFFS)) & 7))) & (UCHAR)1)
|
|
|
|
namespace TScannerUtil
|
|
{
|
|
|
|
struct EP {
|
|
unsigned char r, g, b;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void copyRGBBufferToTRaster32(unsigned char *rgbBuffer,
|
|
int rgbLx, int rgbLy,
|
|
const TRaster32P &rout, bool internal)
|
|
{
|
|
if (internal) {
|
|
TPixelRGBM32 *dst = rout->pixels();
|
|
EP *src = (EP *)(rgbBuffer + (rgbLx * rgbLy - 1) * 3);
|
|
const int w = rout->getWrap();
|
|
|
|
for (int x = 0; x < rout->getLx(); ++x) {
|
|
dst = rout->pixels() + x;
|
|
for (int y = 0; y < rout->getLy(); ++y) {
|
|
dst->r = src->r;
|
|
dst->g = src->g;
|
|
dst->b = src->b;
|
|
dst->m = 0xff;
|
|
dst += w;
|
|
--src;
|
|
}
|
|
}
|
|
} else {
|
|
unsigned char *index = rgbBuffer;
|
|
unsigned char *end = index + (rgbLx * rgbLy * 3);
|
|
TPixel32 *outPix = rout->pixels();
|
|
while (index < end) {
|
|
outPix->r = (int)*index;
|
|
index++;
|
|
outPix->g = (int)*index;
|
|
index++;
|
|
outPix->b = (int)*index;
|
|
index++;
|
|
outPix->m = 255;
|
|
outPix++;
|
|
}
|
|
rout->yMirror();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void copyRGBBufferToTRasterGR8(unsigned char *rgbBuffer, int rgbLx, int rgbLy, int rgbWrap,
|
|
const TRasterGR8P &rout)
|
|
{
|
|
TPixelGR8 *dst = rout->pixels();
|
|
EP *src = (EP *)(rgbBuffer + (rgbLx * rgbLy - 1) * 3);
|
|
const int w = rout->getWrap();
|
|
|
|
for (int x = 0; x < rout->getLx(); ++x) {
|
|
dst = rout->pixels() + x;
|
|
for (int y = 0; y < rout->getLy(); ++y) {
|
|
*dst = TPixelGR8::from(TPixelRGBM32(src->r, src->g, src->b));
|
|
dst += w;
|
|
--src;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void copyGR8BufferToTRasterGR8(unsigned char *gr8Buffer,
|
|
int rgbLx, int rgbLy,
|
|
const TRasterGR8P &rout, bool internal)
|
|
{
|
|
if (internal) {
|
|
unsigned char *dst = rout->getRawData();
|
|
unsigned char *src = (gr8Buffer + rgbLx * rgbLy - 1);
|
|
const int w = rout->getWrap();
|
|
|
|
for (int x = 0; x < rout->getLx(); ++x) {
|
|
dst = rout->getRawData() + x;
|
|
for (int y = 0; y < rout->getLy(); ++y) {
|
|
*dst = (*src);
|
|
dst += w;
|
|
--src;
|
|
}
|
|
}
|
|
} else {
|
|
memcpy(rout->getRawData(), gr8Buffer, rgbLx * rgbLy);
|
|
rout->yMirror();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void copyGR8BufferToTRasterBW(unsigned char *gr8Buffer,
|
|
int rgbLx, int rgbLy,
|
|
const TRasterGR8P &rout, bool internal, float thres)
|
|
{
|
|
if (internal) {
|
|
unsigned char *dst = rout->getRawData();
|
|
unsigned char *src = (gr8Buffer + rgbLx * rgbLy - 1);
|
|
const int w = rout->getWrap();
|
|
|
|
for (int x = 0; x < rout->getLx(); ++x) {
|
|
dst = rout->getRawData() + x;
|
|
for (int y = 0; y < rout->getLy(); ++y) {
|
|
if (*src < thres)
|
|
*dst = 0;
|
|
else
|
|
*dst = 255;
|
|
dst += w;
|
|
--src;
|
|
}
|
|
}
|
|
} else {
|
|
memcpy(rout->getRawData(), gr8Buffer, rgbLx * rgbLy);
|
|
rout->yMirror();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void copyBWBufferToTRasterGR8(const unsigned char *buffer,
|
|
int rgbLx, int rgbLy,
|
|
const TRasterGR8P &rout, bool isBW, bool internal)
|
|
{
|
|
if (0)
|
|
assert(0);
|
|
else {
|
|
int i = 0;
|
|
UCHAR *pix = rout->getRawData();
|
|
const unsigned char *byte;
|
|
while (i < rgbLx * rgbLy) {
|
|
int bytePos = i / 8;
|
|
int bitPos = i % 8;
|
|
byte = buffer + bytePos;
|
|
bool bit = (*byte) >> (7 - bitPos);
|
|
if (isBW)
|
|
*pix = (bit ? 255 : 0);
|
|
else
|
|
*pix = (bit ? 0 : 255);
|
|
|
|
pix++;
|
|
i++;
|
|
}
|
|
rout->yMirror();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void copy90BWBufferToRasGR8(unsigned char *bwBuffer, int bwLx, int bwLy, int bwWrap, bool isBW,
|
|
TRasterGR8P &rout, int mirror, int ninety)
|
|
{
|
|
int x1 = 0;
|
|
int y1 = 0;
|
|
int x2 = bwLx - 1;
|
|
int y2 = bwLy - 1;
|
|
int newx = 0;
|
|
int newy = 0;
|
|
|
|
UCHAR *bufin, *bufout, /* *bytein,*/ *byteout;
|
|
int bytewrapin, bitoffsin, wrapout;
|
|
int value_for_0, value_for_1;
|
|
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
|
|
int x, y, lx, ly;
|
|
int u1, v1, u2, v2;
|
|
|
|
mirror &= 1;
|
|
ninety &= 3;
|
|
|
|
if (!ninety && !mirror) {
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
if (isBW) {
|
|
value_for_0 = 0;
|
|
value_for_1 = 255;
|
|
} else {
|
|
value_for_0 = 255;
|
|
value_for_1 = 0;
|
|
}
|
|
|
|
u1 = x1;
|
|
v1 = y1;
|
|
u2 = x2;
|
|
v2 = y2;
|
|
|
|
su = u2 - u1;
|
|
sv = v2 - v1;
|
|
lu = u2 - u1 + 1;
|
|
lv = v2 - v1 + 1;
|
|
|
|
if (ninety & 1) {
|
|
lx = lv;
|
|
ly = lu;
|
|
} else {
|
|
lx = lu;
|
|
ly = lv;
|
|
}
|
|
|
|
bufin = bwBuffer;
|
|
bytewrapin = (bwWrap + 7) >> 3;
|
|
bitoffsin = 0; //rin->bit_offs;
|
|
bufout = rout->getRawData();
|
|
wrapout = rout->getWrap();
|
|
|
|
dudx = 0;
|
|
dudy = 0;
|
|
dvdx = 0;
|
|
dvdy = 0;
|
|
|
|
switch ((mirror << 2) + ninety) {
|
|
CASE(0 << 2) + 0 : u00 = u1;
|
|
v00 = v1;
|
|
dudx = 1;
|
|
dvdy = 1;
|
|
CASE(0 << 2) + 1 : u00 = u1;
|
|
v00 = v1 + sv;
|
|
dudy = 1;
|
|
dvdx = -1;
|
|
CASE(0 << 2) + 2 : u00 = u1 + su;
|
|
v00 = v1 + sv;
|
|
dudx = -1;
|
|
dvdy = -1;
|
|
CASE(0 << 2) + 3 : u00 = u1 + su;
|
|
v00 = v1;
|
|
dudy = -1;
|
|
dvdx = 1;
|
|
CASE(1 << 2) + 0 : u00 = u1 + su;
|
|
v00 = v1;
|
|
dudx = -1;
|
|
dvdy = 1;
|
|
CASE(1 << 2) + 1 : u00 = u1 + su;
|
|
v00 = v1 + sv;
|
|
dudy = -1;
|
|
dvdx = -1;
|
|
CASE(1 << 2) + 2 : u00 = u1;
|
|
v00 = v1 + sv;
|
|
dudx = 1;
|
|
dvdy = -1;
|
|
CASE(1 << 2) + 3 : u00 = u1;
|
|
v00 = v1;
|
|
dudy = 1;
|
|
dvdx = 1;
|
|
DEFAULT:
|
|
abort();
|
|
u00 = v00 = dudy = dvdx = 0;
|
|
}
|
|
|
|
if (dudx)
|
|
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
|
|
u = u0;
|
|
v = v0;
|
|
byteout = bufout + newx + y * wrapout;
|
|
for (x = newx; x < newx + lx; u += dudx, x++) {
|
|
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
|
|
*byteout++ = value_for_1;
|
|
else
|
|
*byteout++ = value_for_0;
|
|
}
|
|
}
|
|
else
|
|
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
|
|
u = u0;
|
|
v = v0;
|
|
byteout = bufout + newx + y * wrapout;
|
|
for (x = newx; x < newx + lx; v += dvdx, x++) {
|
|
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
|
|
*byteout++ = value_for_1;
|
|
else
|
|
*byteout++ = value_for_0;
|
|
}
|
|
}
|
|
}
|
|
};
|