void pix_convolve :: processGrayImage(imageStruct &image)
{
const int csize=image.csize;
image.copy2Image(&tempImg);
int initX = m_rows / 2;
int initY = m_cols / 2;
int maxX = tempImg.xsize - initX;
int maxY = tempImg.ysize - initY;
int xTimesc = tempImg.xsize * csize;
int initOffset = initY * xTimesc + initX * csize;
for (int y = initY; y < maxY; y++) {
int realY = y * xTimesc;
int offsetY = realY - initOffset;
for (int x = initX; x < maxX; x++) {
int offsetXY = x + offsetY;
int new_val = 0;
int offsetXYC = offsetXY;
for (int matY = 0; matY < m_cols; matY++) {
int offsetXYCMat = matY * xTimesc + offsetXYC;
int realMatY = matY * m_rows;
for (int matX = 0; matX < m_rows; matX++) {
new_val += (tempImg.data[offsetXYCMat + matX] *
m_imatrix[realMatY + matX])>>8;
}
}
image.data[x+realY] = CLAMP(new_val);
//removes insult from injury ??
// we do not use the m_irange anymore ... remove it ??
}
}
}
bool imageTIFF::save(const imageStruct&constimage, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
TIFF *tif = NULL;
if(GL_YUV422_GEM==constimage.format) {
error("don't know how to write YUV-images with libTIFF");
return false;
}
tif=TIFFOpen(filename.c_str(), "w");
if (tif == NULL) {
return false;
}
imageStruct image; constimage.copy2Image(&image);
image.fixUpDown();
uint32 width=image.xsize, height = image.ysize;
short bits=8, samps=image.csize;
int npixels = width * height;
//int planar_conf = PLANARCONFIG_CONTIG;
const char *gemstring = "PD/GEM";
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bits);
TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samps);
TIFFSetField(tif, TIFFTAG_PLANARCONFIG, 1);
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(tif, TIFFTAG_XRESOLUTION, 72);
TIFFSetField(tif, TIFFTAG_YRESOLUTION, 72);
TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
TIFFSetField(tif, TIFFTAG_SOFTWARE, gemstring);
int yStride = image.xsize * image.csize;
unsigned char *srcLine = &(image.data[npixels * image.csize]);
srcLine -= yStride;
for (uint32 row = 0; row < height; row++) {
unsigned char *buf = srcLine;
if (TIFFWriteScanline(tif, buf, row, 0) < 0)
{
error("GEM: could not write line %d to image %s", row, filename.c_str());
TIFFClose(tif);
delete [] buf;
return(false);
}
srcLine -= yStride;
}
TIFFClose(tif);
return true;
}
void pix_convolve :: processYUVImage(imageStruct &image)
{
image.copy2Image(&tempImg);
//float range = 1;
int initX = m_rows / 2;
int initY = m_cols / 2;
int maxX = tempImg.xsize - initX;
int maxY = tempImg.ysize - initY;
int xTimesc = tempImg.xsize * tempImg.csize;
int initOffset = initY * xTimesc + initX * tempImg.csize;
// calculate3x3YUV(image,tempImg);
//quick fix for Intel 3x3YUV problems
#ifdef __BIG_ENDIAN__
if (m_rows == 3 && m_cols == 3) {
calculate3x3YUV(image,tempImg);
return;
}
#endif
if (m_chroma) {
for (int y = initY; y < maxY; y++) {
int realY = y * xTimesc;
int offsetY = realY - initOffset;
for (int x = initX; x < maxX; x++) {
int realPos = x * tempImg.csize + realY;
int offsetXY = x * tempImg.csize + offsetY;
// skip the UV
for (int c = 1; c < 3; c+=2) {
int new_val = 0;
int offsetXYC = offsetXY + c;
for (int matY = 0; matY < m_cols; matY++) {
int offsetXYCMat = matY * xTimesc + offsetXYC;
int realMatY = matY * m_rows;
for (int matX = 0; matX < m_rows; matX++) {
new_val += (tempImg.data[offsetXYCMat + matX * tempImg.csize] *
m_imatrix[realMatY + matX])>>8;
}
}
image.data[realPos + c] = CLAMP(new_val);
// image.data[realPos + c-1] = 128; //remove the U+V
}
}
}
} else {
for (int y = initY; y < maxY; y++) {
void pix_convolve :: processRGBAImage(imageStruct &image)
{
image.copy2Image(&tempImg);
int initX = m_rows / 2;
int initY = m_cols / 2;
int maxX = tempImg.xsize - initX;
int maxY = tempImg.ysize - initY;
int xTimesc = tempImg.xsize * tempImg.csize;
int initOffset = initY * xTimesc + initX * tempImg.csize;
const int csize = tempImg.csize;
if (m_rows == 3 && m_cols == 3) {
calculateRGBA3x3(image,tempImg);
return;
}
for (int y = initY; y < maxY; y++) {
int realY = y * xTimesc;
int offsetY = realY - initOffset;
for (int x = initX; x < maxX; x++) {
int realPos = x * csize + realY;
int offsetXY = x * csize + offsetY;
// skip the alpha value
for (int c = 1; c < csize; c++) {
int new_val = 0;
int offsetXYC = offsetXY + c;
for (int matY = 0; matY < m_cols; matY++) {
int offsetXYCMat = matY * xTimesc + offsetXYC;
int realMatY = matY * m_rows;
for (int matX = 0; matX < m_rows; matX++) {
new_val += (tempImg.data[offsetXYCMat + matX * csize] *
m_imatrix[realMatY + matX])>>8;
}
}
image.data[realPos + c] = CLAMP(new_val);
//removes insult from injury ??
// we do not use the m_irange anymore ... remove it ??
}
}
}
}
/////////////////////////////////////////////////////////
// processImage
//
/////////////////////////////////////////////////////////
void pix_flip :: processRGBAImage(imageStruct &image)
{
// eventually should do this inline, but in the interest of getting it done...
imageStruct tempImg;
if (image.data==0)return;
image.copy2Image(&tempImg);
int ySrcStride = image.xsize * image.csize;
int yDstStride = image.xsize * image.csize;
int xSrcStride = image.csize;
int xDstStride = image.csize;
unsigned char *srcLine = tempImg.data;
unsigned char *dstLine = image.data;
FlipType flip=m_flip;
if(!image.upsidedown) {
switch(flip) {
case(HORIZONTAL) : flip=BOTH;break;
case(VERTICAL) : flip=NONE;break;
case(BOTH) : flip=HORIZONTAL;break;
case(NONE) : flip=VERTICAL ;break;
default :break;
}
}
image.upsidedown=true;
switch(flip)
{
case(HORIZONTAL):
srcLine = tempImg.data + ySrcStride - xSrcStride;
xSrcStride = -xSrcStride;
break;
case(VERTICAL):
srcLine = tempImg.data + ySrcStride * image.ysize - ySrcStride;
ySrcStride = -ySrcStride;
break;
case(BOTH):
srcLine = tempImg.data + ySrcStride * image.ysize - xSrcStride;
xSrcStride = -xSrcStride;
ySrcStride = -ySrcStride;
break;
default:
return;
// break;
}
int ySize = image.ysize;
int xHold = image.xsize;
while(ySize--)
{
unsigned char *srcPixels = srcLine;
unsigned char *dstPixels = dstLine;
int xSize = xHold;
while(xSize--) {
dstPixels[chRed] = srcPixels[chRed];
dstPixels[chGreen] = srcPixels[chGreen];
dstPixels[chBlue] = srcPixels[chBlue];
dstPixels[chAlpha] = srcPixels[chAlpha];
dstPixels += xDstStride;
srcPixels += xSrcStride;
}
dstLine += yDstStride;
srcLine += ySrcStride;
}
}
bool imageTIFF::save(const imageStruct&constimage, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
TIFF *tif = NULL;
if(GL_YUV422_GEM==constimage.format) {
error("don't know how to write YUV-images with libTIFF");
return false;
}
tif=TIFFOpen(filename.c_str(), "w");
if (tif == NULL) {
return false;
}
imageStruct image; constimage.copy2Image(&image);
image.fixUpDown();
uint32 width=image.xsize, height = image.ysize;
short bits=8, samps=image.csize;
int npixels = width * height;
//int planar_conf = PLANARCONFIG_CONTIG;
std::string software = "PD/GEM";
std::string artist;
std::string hostcomputer;
double xresolution = 72., yresolution=72.;
short resunit = RESUNIT_INCH;
props.get("xresolution", xresolution);
props.get("yresolution", yresolution);
std::string resunit_s;
if(props.get("resolutionunit", resunit_s)) {
if(("inch"==resunit_s) || ("english"==resunit_s) || ("imperial"==resunit_s))
resunit=RESUNIT_INCH;
else if(("centimeter"==resunit_s) || ("metric"==resunit_s))
resunit=RESUNIT_CENTIMETER;
else
resunit=RESUNIT_NONE;
}
props.get("software", software);
props.get("artist", artist);
props.get("hostcomputer", hostcomputer);
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bits);
TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samps);
TIFFSetField(tif, TIFFTAG_PLANARCONFIG, 1);
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(tif, TIFFTAG_XRESOLUTION, xresolution); // RATIONAL
TIFFSetField(tif, TIFFTAG_YRESOLUTION, yresolution); // RATIONAL
TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, resunit);
if(!software.empty())
TIFFSetField(tif, TIFFTAG_SOFTWARE, software.c_str());
if(!artist.empty())
TIFFSetField(tif, TIFFTAG_ARTIST, artist.c_str());
if(!hostcomputer.empty())
TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, hostcomputer.c_str());
int yStride = image.xsize * image.csize;
unsigned char *srcLine = &(image.data[npixels * image.csize]);
srcLine -= yStride;
for (uint32 row = 0; row < height; row++) {
unsigned char *buf = srcLine;
if (TIFFWriteScanline(tif, buf, row, 0) < 0)
{
error("GEM: could not write line %d to image %s", row, filename.c_str());
TIFFClose(tif);
delete [] buf;
return(false);
}
srcLine -= yStride;
}
TIFFClose(tif);
return true;
}
