static l_int32
test_1bpp_color(L_REGPARAMS *rp)
{
l_int32 same, transp;
FILE *fp;
PIX *pix1, *pix2;
PIXCMAP *cmap;
pix1 = pixRead("feyn-fract2.tif");
cmap = pixcmapCreate(1);
pixSetColormap(pix1, cmap);
pixcmapAddRGBA(cmap, 180, 130, 220, 255); /* color, opaque */
pixcmapAddRGBA(cmap, 20, 120, 0, 255); /* color, opaque */
pixWrite("/tmp/regout/1bpp-color.png", pix1, IFF_PNG);
pix2 = pixRead("/tmp/regout/1bpp-color.png");
pixEqual(pix1, pix2, &same);
if (same)
fprintf(stderr, "1bpp_color: success\n");
else
fprintf(stderr, "1bpp_color: bad output\n");
pixDisplayWithTitle(pix2, 700, 100, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
fp = fopenReadStream("/tmp/regout/1bpp-color.png");
fgetPngColormapInfo(fp, &cmap, &transp);
fclose(fp);
if (transp)
fprintf(stderr, "1bpp_color: error -- transparency found!\n");
else
fprintf(stderr, "1bpp_color: correct -- no transparency found\n");
if (rp->display) pixcmapWriteStream(stderr, cmap);
pixcmapDestroy(&cmap);
return same;
}
static l_int32
test_8bpp_trans(L_REGPARAMS *rp)
{
l_int32 same, transp;
FILE *fp;
PIX *pix1, *pix2, *pix3;
PIXCMAP *cmap;
pix1 = pixRead("wyom.jpg");
pix2 = pixColorSegment(pix1, 75, 10, 8, 7);
cmap = pixGetColormap(pix2);
pixcmapSetAlpha(cmap, 0, 0); /* set blueish sky color to transparent */
pixWrite("/tmp/regout/8bpp-trans.png", pix2, IFF_PNG);
pix3 = pixRead("/tmp/regout/8bpp-trans.png");
pixEqual(pix2, pix3, &same);
if (same)
fprintf(stderr, "8bpp_trans: success\n");
else
fprintf(stderr, "8bpp_trans: bad output\n");
pixDisplayWithTitle(pix3, 700, 0, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
fp = fopenReadStream("/tmp/regout/8bpp-trans.png");
fgetPngColormapInfo(fp, &cmap, &transp);
fclose(fp);
if (transp)
fprintf(stderr, "8bpp_trans: correct -- transparency found\n");
else
fprintf(stderr, "8bpp_trans: error -- no transparency found!\n");
if (rp->display) pixcmapWriteStream(stderr, cmap);
pixcmapDestroy(&cmap);
return same;
}
/*!
* pixPrintStreamInfo()
*
* Input: fp (file stream)
* pix
* text (<optional> identifying string; can be null)
* Return: 0 if OK, 1 on error
*/
l_int32
pixPrintStreamInfo(FILE *fp,
PIX *pix,
const char *text)
{
PIXCMAP *cmap;
PROCNAME("pixPrintStreamInfo");
if (!fp)
return ERROR_INT("fp not defined", procName, 1);
if (!pix)
return ERROR_INT("pix not defined", procName, 1);
if (text)
fprintf(fp, " Pix Info for %s:\n", text);
fprintf(fp, " width = %d, height = %d, depth = %d\n",
pixGetWidth(pix), pixGetHeight(pix), pixGetDepth(pix));
fprintf(fp, " wpl = %d, data = %p, refcount = %d\n",
pixGetWpl(pix), pixGetData(pix), pixGetRefcount(pix));
if ((cmap = pixGetColormap(pix)) != NULL)
pixcmapWriteStream(fp, cmap);
else
fprintf(fp, " no colormap\n");
return 0;
}
int main(int argc,
char **argv)
{
l_uint8 *data;
l_int32 w, h, n1, n2, n, i, minval, maxval;
l_int32 ncolors, rval, gval, bval, equal;
l_int32 *rmap, *gmap, *bmap;
l_uint32 color;
l_float32 gamma;
BOX *box;
FILE *fp;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixb, *pixg, *pixc, *pixd;
PIX *pixg2, *pixcs1, *pixcs2, *pixd1, *pixd2;
PIXA *pixa, *pixa2, *pixa3;
PIXCMAP *cmap, *cmap2;
RGBA_QUAD *cta;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------------------ (1) ----------------------------*/
/* Blend with a white background */
pix1 = pixRead("books_logo.png");
pixDisplayWithTitle(pix1, 100, 0, NULL, rp->display);
pix2 = pixAlphaBlendUniform(pix1, 0xffffff00);
pixDisplayWithTitle(pix2, 100, 150, NULL, rp->display);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
/* Generate an alpha layer based on the white background */
pix3 = pixSetAlphaOverWhite(pix2);
pixSetSpp(pix3, 3);
pixWrite("/tmp/alphaops.2.png", pix3, IFF_PNG); /* without alpha */
regTestCheckFile(rp, "/tmp/alphaops.2.png"); /* 2 */
pixSetSpp(pix3, 4);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3, with alpha */
pixDisplayWithTitle(pix3, 100, 300, NULL, rp->display);
/* Render on a light yellow background */
pix4 = pixAlphaBlendUniform(pix3, 0xffffe000);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 100, 450, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* ------------------------ (2) ----------------------------*/
lept_rmdir("alpha");
lept_mkdir("alpha");
/* Make the transparency (alpha) layer.
* pixs is the mask. We turn it into a transparency (alpha)
* layer by converting to 8 bpp. A small convolution fuzzes
* the mask edges so that you don't see the pixels. */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
pixg = pixConvert1To8(NULL, pixs, 0, 255);
pixg2 = pixBlockconvGray(pixg, NULL, 1, 1);
regTestWritePixAndCheck(rp, pixg2, IFF_JFIF_JPEG); /* 5 */
pixDisplayWithTitle(pixg2, 0, 0, "alpha", rp->display);
/* Make the viewable image.
* pixc is the image that we see where the alpha layer is
* opaque -- i.e., greater than 0. Scale it to the same
* size as the mask. To visualize what this will look like
* when displayed over a black background, create the black
* background image, pixb, and do the blending with pixcs1
* explicitly using the alpha layer pixg2. */
pixc = pixRead("tetons.jpg");
pixcs1 = pixScaleToSize(pixc, w, h);
regTestWritePixAndCheck(rp, pixcs1, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixcs1, 300, 0, "viewable", rp->display);
pixb = pixCreateTemplate(pixcs1); /* black */
pixd1 = pixBlendWithGrayMask(pixb, pixcs1, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd1, IFF_JFIF_JPEG); /* 7 */
pixDisplayWithTitle(pixd1, 600, 0, "alpha-blended 1", rp->display);
/* Embed the alpha layer pixg2 into the color image pixc.
* Write it out as is. Then clean pixcs1 (to 0) under the fully
* transparent part of the alpha layer, and write that result
* out as well. */
pixSetRGBComponent(pixcs1, pixg2, L_ALPHA_CHANNEL);
pixWrite("/tmp/alpha/pixcs1.png", pixcs1, IFF_PNG);
pixcs2 = pixSetUnderTransparency(pixcs1, 0, 0);
pixWrite("/tmp/alpha/pixcs2.png", pixcs2, IFF_PNG);
/* What will this look like over a black background?
* Do the blending explicitly and display. It should
* look identical to the blended result pixd1 before cleaning. */
pixd2 = pixBlendWithGrayMask(pixb, pixcs2, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd2, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd2, 0, 400, "alpha blended 2", rp->display);
/* Read the two images back, ignoring the transparency layer.
* The uncleaned image will come back identical to pixcs1.
* However, the cleaned image will be black wherever
* the alpha layer was fully transparent. It will
* look the same when viewed through the alpha layer,
* but have much better compression. */
pix1 = pixRead("/tmp/alpha/pixcs1.png"); /* just pixcs1 */
pix2 = pixRead("/tmp/alpha/pixcs2.png"); /* cleaned under transparent */
n1 = nbytesInFile("/tmp/alpha/pixcs1.png");
n2 = nbytesInFile("/tmp/alpha/pixcs2.png");
fprintf(stderr, " Original: %d bytes\n Cleaned: %d bytes\n", n1, n2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 9 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 10 */
pixDisplayWithTitle(pix1, 300, 400, "without alpha", rp->display);
pixDisplayWithTitle(pix2, 600, 400, "cleaned under transparent",
rp->display);
pixa = pixaCreate(0);
pixSaveTiled(pixg2, pixa, 1.0, 1, 20, 32);
pixSaveTiled(pixcs1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pix1, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pixd1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pixd2, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pix2, pixa, 1.0, 1, 20, 0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 200, 200, "composite", rp->display);
pixWrite("/tmp/alpha/alpha.png", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixg);
pixDestroy(&pixg2);
pixDestroy(&pixc);
pixDestroy(&pixcs1);
pixDestroy(&pixcs2);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------------------ (3) ----------------------------*/
color = 0xffffa000;
gamma = 1.0;
minval = 0;
maxval = 200;
box = boxCreate(0, 85, 600, 100);
pixa = pixaCreate(6);
pix1 = pixRead("blend-green1.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green2.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green3.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-orange.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-yellow.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-red.png");
pixaAddPix(pixa, pix1, L_INSERT);
n = pixaGetCount(pixa);
pixa2 = pixaCreate(n);
pixa3 = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 1);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 12, 14, ... 22 */
pixDisplayWithTitle(pix2, 150 * i, 0, NULL, rp->display);
pixaAddPix(pixa2, pix2, L_INSERT);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 2);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 13, 15, ... 23 */
pixDisplayWithTitle(pix2, 150 * i, 200, NULL, rp->display);
pixaAddPix(pixa3, pix2, L_INSERT);
pixDestroy(&pix1);
}
if (rp->display) {
pixaConvertToPdf(pixa2, 0, 0.75, L_FLATE_ENCODE, 0, "blend 1 test",
"/tmp/alpha/blending1.pdf");
pixaConvertToPdf(pixa3, 0, 0.75, L_FLATE_ENCODE, 0, "blend 2 test",
"/tmp/alpha/blending2.pdf");
}
pixaDestroy(&pixa);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
boxDestroy(&box);
/* ------------------------ (4) ----------------------------*/
/* Use one image as the alpha component for a second image */
pix1 = pixRead("test24.jpg");
pix2 = pixRead("marge.jpg");
pix3 = pixScale(pix2, 1.9, 2.2);
pix4 = pixConvertTo8(pix3, 0);
pixSetRGBComponent(pix1, pix4, L_ALPHA_CHANNEL);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 24 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
/* Set the alpha value in a colormap to bval */
pix5 = pixOctreeColorQuant(pix1, 128, 0);
cmap = pixGetColormap(pix5);
pixcmapToArrays(cmap, &rmap, &gmap, &bmap, NULL);
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
cta = (RGBA_QUAD *)cmap->array;
cta[i].alpha = bval;
}
/* Test binary serialization/deserialization of colormap with alpha */
pixcmapSerializeToMemory(cmap, 4, &ncolors, &data);
cmap2 = pixcmapDeserializeFromMemory(data, 4, ncolors);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 25 */
pixcmapDestroy(&cmap2);
lept_free(data);
/* Test ascii serialization/deserialization of colormap with alpha */
fp = fopenWriteStream("/tmp/alpha/cmap.4", "w");
pixcmapWriteStream(fp, cmap);
fclose(fp);
fp = fopenReadStream("/tmp/alpha/cmap.4");
cmap2 = pixcmapReadStream(fp);
fclose(fp);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 26 */
pixcmapDestroy(&cmap2);
/* Test r/w for cmapped pix with non-opaque alpha */
pixDisplayWithTitle(pix5, 900, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 27 */
pixWrite("/tmp/alpha/fourcomp.png", pix5, IFF_PNG);
pix6 = pixRead("/tmp/alpha/fourcomp.png");
regTestComparePix(rp, pix5, pix6); /* 28 */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
lept_free(rmap);
lept_free(gmap);
lept_free(bmap);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, j, sindex, wb, hb, ws, hs, delx, dely, x, y, y0;
PIX *pixs, *pixb, *pix1, *pix2;
PIXA *pixa;
PIXCMAP *cmap;
setLeptDebugOK(1);
lept_mkdir("lept/blend");
pixa = pixaCreate(0);
pixs = pixRead("rabi.png"); /* blendee */
pixb = pixRead("weasel4.11c.png"); /* blender */
/* Fade the blender */
pixcmapShiftIntensity(pixGetColormap(pixb), FADE_FRACTION);
/* Downscale the input */
wb = pixGetWidth(pixb);
hb = pixGetHeight(pixb);
pix1 = pixScaleToGray4(pixs);
/* Threshold to 5 levels, 4 bpp */
ws = pixGetWidth(pix1);
hs = pixGetHeight(pix1);
pix2 = pixThresholdTo4bpp(pix1, 5, 1);
pixaAddPix(pixa, pix2, L_COPY);
pixaAddPix(pixa, pixb, L_COPY);
cmap = pixGetColormap(pix2);
pixcmapWriteStream(stderr, cmap);
/* Overwrite the white pixels (at sindex in pix2) */
pixcmapGetIndex(cmap, 255, 255, 255, &sindex);
/* Blend the weasel 20 times */
delx = ws / NX;
dely = hs / NY;
for (i = 0; i < NY; i++) {
y = 20 + i * dely;
if (y >= hs + hb)
continue;
for (j = 0; j < NX; j++) {
x = 30 + j * delx;
y0 = y;
if (j & 1) {
y0 = y + dely / 2;
if (y0 >= hs + hb)
continue;
}
if (x >= ws + wb)
continue;
pixBlendCmap(pix2, pixb, x, y0, sindex);
}
}
pixaAddPix(pixa, pix2, L_COPY);
cmap = pixGetColormap(pix2);
pixcmapWriteStream(stderr, cmap);
fprintf(stderr, "Writing to: /tmp/lept/blend/blendcmap.pdf\n");
pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, "cmap-blendtest",
"/tmp/lept/blend/blendcmap.pdf");
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixaDestroy(&pixa);
return 0;
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb;
PIXA *pixa;
PIXCMAP *cmap;
static char mainName[] = "colorspacetest";
if (argc != 2)
return ERROR_INT(" Syntax: colorspacetest filein", mainName, 1);
if ((pixs = pixRead(argv[1])) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
/* Generate colors by sampling hue with max sat and value.
* This was used to make the color strip 19-colors.png. */
pixa = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixa, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixa, 32, 1100, 1.0, 0, 0, 0);
pixDisplayWrite(pixt2, 1);
pixDestroy(&pixt2);
pixaDestroy(&pixa);
/* Colorspace conversion in rgb */
pixDisplayWrite(pixs, 1);
pixt = pixConvertRGBToHSV(NULL, pixs);
pixDisplayWrite(pixt, 1);
pixConvertHSVToRGB(pixt, pixt);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
pixDisplayWrite(pixt, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixcmapConvertHSVToRGB(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
pixDisplayWrite(pixr, 1);
pixDisplayWrite(pixg, 1);
pixDisplayWrite(pixb, 1);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Color content measurement */
pixa = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/junkplot1", GPLOT_X11,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/junkplot2", GPLOT_X11,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, 250, 4, 0, 10, 2);
pixWrite("/tmp/junkcolormag", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", 1);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
pixDisplayMultiple("/tmp/display/file*");
pixDestroy(&pixs);
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout;
l_int32 w, h;
l_float32 scale;
FILE *fp;
PIX *pix, *pixs, *pixd;
PIXCMAP *cmap;
static char mainName[] = "dithertest";
if (argc != 3)
exit(ERROR_INT(" Syntax: dithertest filein fileout", mainName, 1));
filein = argv[1];
fileout = argv[2];
if ((pix = pixRead(filein)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
if (pixGetDepth(pix) != 8)
exit(ERROR_INT("pix not 8 bpp", mainName, 1));
pixs = pixGammaTRC(NULL, pix, GAMMA, 0, 255);
startTimer();
pixd = pixDitherToBinary(pixs);
fprintf(stderr, " time for binarized dither = %7.3f sec\n", stopTimer());
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* Dither to 2 bpp, with colormap */
startTimer();
pixd = pixDitherTo2bpp(pixs, 1);
fprintf(stderr, " time for dither = %7.3f sec\n", stopTimer());
pixDisplayWrite(pixd, 1);
cmap = pixGetColormap(pixd);
pixcmapWriteStream(stderr, cmap);
pixDestroy(&pixd);
/* Dither to 2 bpp, without colormap */
startTimer();
pixd = pixDitherTo2bpp(pixs, 0);
fprintf(stderr, " time for dither = %7.3f sec\n", stopTimer());
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* Dither to 2 bpp, without colormap; output in PostScript */
pixd = pixDitherTo2bpp(pixs, 0);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
scale = L_MIN(FACTOR * 2550 / w, FACTOR * 3300 / h);
fp = lept_fopen(fileout, "wb+");
pixWriteStreamPS(fp, pixd, NULL, 300, scale);
lept_fclose(fp);
pixDestroy(&pixd);
/* Dither 2x upscale to 1 bpp */
startTimer();
pixd = pixScaleGray2xLIDither(pixs);
fprintf(stderr, " time for scale/dither = %7.3f sec\n", stopTimer());
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* Dither 4x upscale to 1 bpp */
startTimer();
pixd = pixScaleGray4xLIDither(pixs);
fprintf(stderr, " time for scale/dither = %7.3f sec\n", stopTimer());
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
pixDisplayMultiple("/tmp/junk_write_display*");
pixDestroy(&pix);
pixDestroy(&pixs);
return 0;
}
main(int argc,
char **argv)
{
const char *str;
l_int32 equal, index, w, h;
BOX *box;
PIX *pixs, *pixd, *pixt, *pixd1, *pixd2, *pixd3;
PIX *pixt0, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa;
PIXCMAP *cmap;
static char mainName[] = "grayquant_reg";
if ((pixs = pixRead("test8.jpg")) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
pixa = pixaCreate(0);
pixSaveTiled(pixs, pixa, 1, 1, 20, 8);
/* threshold to 1 bpp */
pixd = pixThresholdToBinary(pixs, THRESHOLD);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/junkthr0.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* dither to 2 bpp, with and without colormap */
pixd = pixDitherTo2bpp(pixs, 1);
pixt = pixDitherTo2bpp(pixs, 0);
pixt2 = pixConvertGrayToColormap(pixt);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr1.png", pixd, IFF_PNG);
pixWrite("/tmp/junkthr2.png", pixt, IFF_PNG);
pixWrite("/tmp/junkthr3.png", pixt2, IFF_PNG);
/* pixcmapWriteStream(stderr, pixGetColormap(pixd)); */
pixEqual(pixd, pixt2, &equal);
if (!equal)
fprintf(stderr, "Error: thr2 != thr3\n");
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixd);
/* threshold to 2 bpp, with and without colormap */
pixd = pixThresholdTo2bpp(pixs, 4, 1);
pixt = pixThresholdTo2bpp(pixs, 4, 0);
pixt2 = pixConvertGrayToColormap(pixt);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr4.png", pixd, IFF_PNG);
pixWrite("/tmp/junkthr5.png", pixt2, IFF_PNG);
pixEqual(pixd, pixt2, &equal);
if (!equal)
fprintf(stderr, "Error: thr4 != thr5\n");
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixd);
pixd = pixThresholdTo2bpp(pixs, 3, 1);
pixt = pixThresholdTo2bpp(pixs, 3, 0);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr6.png", pixd, IFF_PNG);
pixWrite("/tmp/junkthr7.png", pixt, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* threshold to 4 bpp, with and without colormap */
pixd = pixThresholdTo4bpp(pixs, 9, 1);
pixt = pixThresholdTo4bpp(pixs, 9, 0);
pixt2 = pixConvertGrayToColormap(pixt);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr8.png", pixd, IFF_PNG);
pixWrite("/tmp/junkthr9.png", pixt, IFF_PNG);
pixWrite("/tmp/junkthr10.png", pixt2, IFF_PNG);
/* pixcmapWriteStream(stderr, pixGetColormap(pixd)); */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixd);
/* threshold on 8 bpp, with and without colormap */
pixd = pixThresholdOn8bpp(pixs, 9, 1);
pixt = pixThresholdOn8bpp(pixs, 9, 0);
pixt2 = pixConvertGrayToColormap(pixt);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr11.png", pixd, IFF_PNG);
pixWrite("/tmp/junkthr12.png", pixt2, IFF_PNG);
/* pixcmapWriteStream(stderr, pixGetColormap(pixd)); */
pixEqual(pixd, pixt2, &equal);
if (!equal)
fprintf(stderr, "Error: thr11 != thr12\n");
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixd);
pixd1 = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd1, 100, 100);
pixWrite("/tmp/junkpixd1.jpg", pixd1, IFF_JFIF_JPEG);
pixDestroy(&pixd1);
pixaDestroy(&pixa);
pixa = pixaCreate(0);
pixSaveTiled(pixs, pixa, 1, 1, 20, 32);
/* highlight 2 bpp with colormap */
pixd = pixThresholdTo2bpp(pixs, 3, 1);
cmap = pixGetColormap(pixd);
pixcmapWriteStream(stderr, cmap);
box = boxCreate(278, 35, 122, 50);
pixSetSelectCmap(pixd, box, 2, 255, 255, 100);
pixcmapWriteStream(stderr, cmap);
pixDisplay(pixd, 0, 0);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/junkthr13.png", pixd, IFF_PNG);
pixDestroy(&pixd);
boxDestroy(&box);
/* test pixThreshold8() */
pixd = pixThreshold8(pixs, 1, 2, 1); /* cmap */
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/junkthr14.png", pixd, IFF_PNG);
pixDisplay(pixd, 100, 0);
pixDestroy(&pixd);
pixd = pixThreshold8(pixs, 1, 2, 0); /* no cmap */
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr15.png", pixd, IFF_PNG);
pixDisplay(pixd, 200, 0);
pixDestroy(&pixd);
pixd = pixThreshold8(pixs, 2, 3, 1); /* highlight one box */
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
box = boxCreate(278, 35, 122, 50);
pixSetSelectCmap(pixd, box, 2, 255, 255, 100);
pixWrite("/tmp/junkthr16.png", pixd, IFF_PNG);
pixDisplay(pixd, 300, 0);
cmap = pixGetColormap(pixd);
pixcmapWriteStream(stderr, cmap);
boxDestroy(&box);
pixDestroy(&pixd);
pixd = pixThreshold8(pixs, 2, 4, 0); /* no cmap */
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr17.png", pixd, IFF_PNG);
pixDisplay(pixd, 400, 0);
pixDestroy(&pixd);
pixd = pixThreshold8(pixs, 4, 6, 1); /* highlight one box */
box = boxCreate(278, 35, 122, 50);
pixSetSelectCmap(pixd, box, 5, 255, 255, 100);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr18.png", pixd, IFF_PNG);
cmap = pixGetColormap(pixd);
pixcmapWriteStream(stderr, cmap);
boxDestroy(&box);
pixDisplay(pixd, 500, 0);
pixDestroy(&pixd);
pixd = pixThreshold8(pixs, 4, 6, 0); /* no cmap */
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr19.png", pixd, IFF_PNG);
pixDisplay(pixd, 600, 0);
pixDestroy(&pixd);
/* highlight 4 bpp with 2 colormap entries */
/* Note: We use 5 levels (0-4) for gray. */
/* 5 & 6 are used for highlight color. */
pixd = pixThresholdTo4bpp(pixs, 5, 1);
cmap = pixGetColormap(pixd);
pixcmapGetIndex(cmap, 255, 255, 255, &index);
box = boxCreate(278, 35, 122, 50);
pixSetSelectCmap(pixd, box, index, 255, 255, 100); /* use 5 */
boxDestroy(&box);
box = boxCreate(4, 6, 157, 33);
pixSetSelectCmap(pixd, box, index, 100, 255, 255); /* use 6 */
boxDestroy(&box);
pixcmapWriteStream(stderr, cmap);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixDisplay(pixd, 700, 0);
pixWrite("/tmp/junkthr20.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* comparison 8 bpp jpeg with 2 bpp (highlight) */
pixDestroy(&pixs);
pixs = pixRead("feyn.tif");
pixt = pixScaleToGray4(pixs);
pixt2 = pixReduceRankBinaryCascade(pixs, 2, 2, 0, 0);
pixd = pixThresholdTo2bpp(pixt, 3, 1);
box = boxCreate(175, 208, 228, 88);
pixSetSelectCmap(pixd, box, 2, 255, 255, 100);
pixDisplay(pixd, 100, 200);
cmap = pixGetColormap(pixd);
pixcmapWriteStream(stderr, cmap);
pixSaveTiled(pixt, pixa, 1, 1, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr21.jpg", pixt, IFF_JFIF_JPEG);
pixWrite("/tmp/junkthr22.png", pixt2, IFF_PNG);
pixWrite("/tmp/junkthr23.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixt2);
boxDestroy(&box);
/* thresholding to 4 bpp (highlight); use pixt from above */
pixd = pixThresholdTo4bpp(pixt, NLEVELS, 1);
box = boxCreate(175, 208, 228, 83);
pixSetSelectCmap(pixd, box, NLEVELS - 1, 255, 255, 100);
boxDestroy(&box);
box = boxCreate(232, 298, 110, 25);
pixSetSelectCmap(pixd, box, NLEVELS - 1, 100, 255, 255);
boxDestroy(&box);
box = boxCreate(21, 698, 246, 82);
pixSetSelectCmap(pixd, box, NLEVELS - 1, 225, 100, 255);
boxDestroy(&box);
pixDisplay(pixd, 500, 200);
cmap = pixGetColormap(pixd);
pixcmapWriteStream(stderr, cmap);
pixt2 = pixReduceRankBinaryCascade(pixs, 2, 2, 0, 0);
pixSaveTiled(pixt2, pixa, 1, 1, 20, 0);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junkthr24.png", pixt2, IFF_PNG);
pixWrite("/tmp/junkthr25.png", pixd, IFF_PNG);
pixDestroy(&pixt2);
pixDestroy(&pixd);
/* Thresholding to 4 bpp at 2, 3, 4, 5 and 6 levels */
box = boxCreate(25, 202, 136, 37);
pixt1 = pixClipRectangle(pixt, box, NULL);
pixt2 = pixScale(pixt1, 6., 6.);
pixGetDimensions(pixt2, &w, &h, NULL);
pixSaveTiled(pixt2, pixa, 1, 1, 20, 0);
pixDisplay(pixt2, 0, 0);
pixWrite("/tmp/junk-8.jpg", pixt2, IFF_JFIF_JPEG);
pixd = pixCreate(w, 6 * h, 8);
pixRasterop(pixd, 0, 0, w, h, PIX_SRC, pixt2, 0, 0);
pixt3 = pixThresholdTo4bpp(pixt2, 6, 1);
pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE);
pixRasterop(pixd, 0, h, w, h, PIX_SRC, pixt4, 0, 0);
pixSaveTiled(pixt3, pixa, 1, 0, 20, 0);
pixDisplay(pixt3, 0, 100);
pixWrite("/tmp/junk-4-6.png", pixt3, IFF_PNG);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixt3 = pixThresholdTo4bpp(pixt2, 5, 1);
pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE);
pixRasterop(pixd, 0, 2 * h, w, h, PIX_SRC, pixt4, 0, 0);
pixSaveTiled(pixt3, pixa, 1, 0, 20, 0);
pixDisplay(pixt3, 0, 200);
pixWrite("/tmp/junk-4-5.png", pixt3, IFF_PNG);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixt3 = pixThresholdTo4bpp(pixt2, 4, 1);
pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE);
pixRasterop(pixd, 0, 3 * h, w, h, PIX_SRC, pixt4, 0, 0);
pixSaveTiled(pixt3, pixa, 1, 0, 20, 0);
pixDisplay(pixt3, 0, 300);
pixWrite("/tmp/junk-4-4.png", pixt3, IFF_PNG);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixt3 = pixThresholdTo4bpp(pixt2, 3, 1);
pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE);
pixRasterop(pixd, 0, 4 * h, w, h, PIX_SRC, pixt4, 0, 0);
pixSaveTiled(pixt3, pixa, 1, 1, 20, 0);
pixDisplay(pixt3, 0, 400);
pixWrite("/tmp/junk-4-3.png", pixt3, IFF_PNG);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixt3 = pixThresholdTo4bpp(pixt2, 2, 1);
pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE);
pixRasterop(pixd, 0, 5 * h, w, h, PIX_SRC, pixt4, 0, 0);
pixDisplay(pixt3, 0, 500);
pixSaveTiled(pixt3, pixa, 1, 0, 20, 0);
pixWrite("/tmp/junk-4-2.png", pixt3, IFF_PNG);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixWrite("/tmp/junk-all.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd2 = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd2, 100, 100);
pixWrite("/tmp/junkpixd2.jpg", pixd2, IFF_JFIF_JPEG);
pixDestroy(&pixd2);
pixaDestroy(&pixa);
#if 0 /* upscale 2x and threshold to 1 bpp; e.g., use test8.jpg */
startTimer();
pixd = pixScaleGray2xLIThresh(pixs, THRESHOLD);
fprintf(stderr, " time for scale/dither = %7.3f sec\n", stopTimer());
pixWrite(fileout, pixd, IFF_PNG);
pixDestroy(&pixd);
#endif
#if 0 /* upscale 4x and threshold to 1 bpp; e.g., use test8.jpg */
startTimer();
pixd = pixScaleGray4xLIThresh(pixs, THRESHOLD);
fprintf(stderr, " time for scale/dither = %7.3f sec\n", stopTimer());
pixWrite(fileout, pixd, IFF_PNG);
pixDestroy(&pixd);
#endif
boxDestroy(&box);
pixDestroy(&pixt);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixs);
/* Thresholding with fixed and arbitrary bin boundaries */
pixa = pixaCreate(0);
pixs = pixRead("stampede2.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 8);
pixt = pixThresholdTo4bpp(pixs, 5, 1);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixt = pixThresholdTo4bpp(pixs, 7, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixt = pixThresholdTo4bpp(pixs, 11, 1);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixSaveTiled(pixs, pixa, 1, 1, 20, 8);
str = "45 75 115 185";
pixt = pixThresholdGrayArb(pixs, str, 8, 0, 0, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
str = "38 65 85 115 160 210";
pixt = pixThresholdGrayArb(pixs, str, 8, 0, 1, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
str = "38 60 75 90 110 130 155 185 208 239";
pixt = pixThresholdGrayArb(pixs, str, 8, 0, 0, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixSaveTiled(pixs, pixa, 1, 1, 20, 8);
str = "45 75 115 185";
pixt = pixThresholdGrayArb(pixs, str, 0, 1, 0, 1);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
str = "38 65 85 115 160 210";
pixt = pixThresholdGrayArb(pixs, str, 0, 1, 0, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
str = "38 60 75 90 110 130 155 185 208 239";
pixt = pixThresholdGrayArb(pixs, str, 4, 1, 0, 1);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixd3 = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd3, 100, 100);
pixWrite("/tmp/junkpixd3.jpg", pixd3, IFF_JFIF_JPEG);
pixDestroy(&pixd3);
pixaDestroy(&pixa);
pixDestroy(&pixs);
return 0;
}
main(int argc,
char **argv)
{
char *text;
l_int32 w, h, d, wpl, count, npages, color, format, bps, spp, iscmap;
FILE *fp;
PIX *pix;
PIXCMAP *cmap;
char *filein;
static char mainName[] = "fileinfo";
if (argc != 2)
exit(ERROR_INT(" Syntax: fileinfo filein", mainName, 1));
filein = argv[1];
l_pngSetStrip16To8(0); /* to preserve 16 bpp if format is png */
/* Read the full image */
if ((pix = pixRead(filein)) == NULL)
exit(ERROR_INT("image not returned from file", mainName, 1));
format = pixGetInputFormat(pix);
pixGetDimensions(pix, &w, &h, &d);
wpl = pixGetWpl(pix);
fprintf(stderr, "Reading the full image:\n");
fprintf(stderr, " Input image format type: %s\n",
ImageFileFormatExtensions[format]);
fprintf(stderr, " w = %d, h = %d, d = %d, wpl = %d\n", w, h, d, wpl);
fprintf(stderr, " xres = %d, yres = %d\n",
pixGetXRes(pix), pixGetYRes(pix));
text = pixGetText(pix);
if (text) /* not null */
fprintf(stderr, " Text: %s\n", text);
cmap = pixGetColormap(pix);
if (cmap) {
pixcmapHasColor(cmap, &color);
if (color)
fprintf(stderr, " Colormap exists and has color values:");
else
fprintf(stderr, " Colormap exists and has only gray values:");
pixcmapWriteStream(stderr, pixGetColormap(pix));
}
else
fprintf(stderr, " Colormap does not exist.\n");
if (format == IFF_TIFF || format == IFF_TIFF_G4 ||
format == IFF_TIFF_G3 || format == IFF_TIFF_PACKBITS) {
fprintf(stderr, " Tiff header information:\n");
fp = lept_fopen(filein, "rb");
tiffGetCount(fp, &npages);
lept_fclose(fp);
if (npages == 1)
fprintf(stderr, " One page in file\n");
else
fprintf(stderr, " %d pages in file\n", npages);
fprintTiffInfo(stderr, filein);
}
if (d == 1) {
pixCountPixels(pix, &count, NULL);
fprintf(stderr, " 1 bpp: pixel ratio ON/OFF = %6.3f\n",
(l_float32)count / (l_float32)(pixGetWidth(pix) * pixGetHeight(pix)));
}
pixDestroy(&pix);
/* Test pixReadHeader() */
if (pixReadHeader(filein, &format, &w, &h, &bps, &spp, &iscmap)) {
fprintf(stderr, "Failure to read header!\n");
return 1;
}
fprintf(stderr, "Reading just the header:\n");
fprintf(stderr, " Input image format type: %s\n",
ImageFileFormatExtensions[format]);
fprintf(stderr,
" w = %d, h = %d, d = %d, bps = %d, spp = %d, iscmap = %d\n",
w, h, d, bps, spp, iscmap);
return 0;
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb; /* for color content extraction */
PIXA *pixa, *pixat;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate a pdf of results when called with display */
pixa = pixaCreate(0);
/* Generate colors by sampling hue with max sat and value.
* This image has been saved as 19-colors.png. */
pixat = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixat, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixat, 32, 1100, 1.0, 0, 0, 0);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 0 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixaDestroy(&pixat);
/* Colorspace conversion in rgb */
pixs = pixRead("wyom.jpg");
pixaAddPix(pixa, pixs, L_INSERT);
pixt = pixConvertRGBToHSV(NULL, pixs);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_COPY);
pixConvertHSVToRGB(pixt, pixt);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 2 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 3 */
pixaAddPix(pixa, pixt, L_COPY);
cmap = pixGetColormap(pixt);
if (rp->display) pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixcmapConvertHSVToRGB(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
regTestWritePixAndCheck(rp, pixr, IFF_JFIF_JPEG); /* 6 */
pixaAddPix(pixa, pixr, L_INSERT);
regTestWritePixAndCheck(rp, pixg, IFF_JFIF_JPEG); /* 7 */
pixaAddPix(pixa, pixg, L_INSERT);
regTestWritePixAndCheck(rp, pixb, IFF_JFIF_JPEG); /* 8 */
pixaAddPix(pixa, pixb, L_INSERT);
/* Color content measurement. This tests the global
* mapping of (r,g,b) --> (white), for 20 different
* values of (r,g,b). For each mappings, we compute
* the color magnitude and threshold it at six values.
* For each of those six thresholds, we plot the
* fraction of pixels that exceeds the threshold
* color magnitude, where the red value (mapped to
* white) goes between 100 and 195. */
pixat = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixat, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/regout/colorspace.10", GPLOT_PNG,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/regout/colorspace.11", GPLOT_PNG,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixat, 32, 250, 4, 0, 10, 2);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 9 */
pixaAddPix(pixa, pixt1, L_INSERT);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", rp->display);
pixaDestroy(&pixat);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
/* Give gnuplot time to write out the files */
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
/* Save as golden files, or check against them */
regTestCheckFile(rp, "/tmp/regout/colorspace.10.png"); /* 10 */
regTestCheckFile(rp, "/tmp/regout/colorspace.11.png"); /* 11 */
if (rp->display) {
pixt = pixRead("/tmp/regout/colorspace.10.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixt = pixRead("/tmp/regout/colorspace.11.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixaConvertToPdf(pixa, 0, 1.0, 0, 0, "colorspace tests",
"/tmp/regout/colorspace.pdf");
L_INFO("Output pdf: /tmp/regout/colorspace.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 w, h, d, wpl, count, i, format, xres, yres;
FILE *fp;
PIX *pix, *pixt1, *pixt2;
PIXCMAP *cmap;
char *filein;
char *fileout = NULL;
static char mainName[] = "iotest";
if (argc != 2 && argc != 3)
exit(ERROR_INT(" Syntax: iotest filein [fileout]", mainName, 1));
filein = argv[1];
if (argc == 3)
fileout = argv[2];
#if 1
if ((pix = pixRead(filein)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
#else
if ((pix = pixReadJpeg(filein, 0, 4, NULL)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
#endif
pixGetDimensions(pix, &w, &h, &d);
wpl = pixGetWpl(pix);
fprintf(stderr, "w = %d, h = %d, d = %d, wpl = %d\n", w, h, d, wpl);
xres = pixGetXRes(pix);
yres = pixGetXRes(pix);
if (xres != 0 && yres != 0)
fprintf(stderr, "xres = %d, yres = %d\n", xres, yres);
if (pixGetColormap(pix)) {
/* Write and read back the colormap */
pixcmapWriteStream(stderr, pixGetColormap(pix));
fp = lept_fopen("/tmp/junkcmap1", "wb");
pixcmapWriteStream(fp, pixGetColormap(pix));
lept_fclose(fp);
fp = lept_fopen("/tmp/junkcmap1", "rb");
cmap = pixcmapReadStream(fp);
lept_fclose(fp);
fp = lept_fopen("/tmp/junkcmap2", "wb");
pixcmapWriteStream(fp, cmap);
lept_fclose(fp);
pixcmapDestroy(&cmap);
/* Remove and regenerate colormap */
pixt1 = pixRemoveColormap(pix, REMOVE_CMAP_BASED_ON_SRC);
if (pixGetDepth(pixt1) == 8) {
fprintf(stderr, "Colormap: represents grayscale image\n");
pixt2 = pixConvertGrayToColormap(pixt1);
}
else { /* 32 bpp */
fprintf(stderr, "Colormap: represents RGB image\n");
pixt2 = pixConvertRGBToColormap(pixt1, 1);
}
pixWrite("/tmp/junkpixt2.png", pixt2, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
else {
fprintf(stderr, "no colormap\n");
}
format = pixGetInputFormat(pix);
fprintf(stderr, "Input format extension: %s\n",
ImageFileFormatExtensions[format]);
if (format == IFF_JFIF_JPEG)
fprintf(stderr, "Jpeg comment: %s\n", pixGetText(pix));
if (d == 1) {
pixCountPixels(pix, &count, NULL);
fprintf(stderr, "pixel ratio ON/OFF = %6.3f\n",
(l_float32)count / (l_float32)(pixGetWidth(pix) * pixGetHeight(pix)));
}
if (argc == 3) {
#if 1
d = pixGetDepth(pix);
if (d == 16 || d < 8 || pixGetColormap(pix))
pixWrite(fileout, pix, IFF_PNG);
else
pixWriteJpeg(fileout, pix, 75, 0);
#elif 0
pixWrite(fileout, pix, IFF_BMP);
#elif 0
pixWrite(fileout, pix, IFF_PNG);
#elif 0
pixWrite(fileout, pix, IFF_TIFF);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_TIFF_PACKBITS);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_TIFF_G3);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_TIFF_G4);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_JFIF_JPEG);
#elif 0
pixWriteJpeg(fileout, pix, 75, 0);
#elif 0
pixWrite(fileout, pix, IFF_PNM);
#elif 0
pixWrite(fileout, pix, IFF_PS);
#endif
}
pixDestroy(&pix);
#if 0 /* test tiff header reader */
{ l_int32 w, h, bps, spp, res, cmap;
if (readHeaderTiff(filein, 0, &w, &h, &bps, &spp, &res, &cmap) == 0)
fprintf(stderr,
"w = %d, h = %d, bps = %d, spp = %d, res = %d, cmap = %d\n",
w, h, bps, spp, res, cmap);
}
#endif
return 0;
}
