Pix Pix::ThresholdTo2bpp(int nlevels, int cmapflag)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixThresholdTo2bpp(pix, nlevels, cmapflag);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::ThresholdTo2bpp()
main(int argc,
char **argv)
{
char *errorstr;
l_int32 same, error;
PIX *pixs1, *pixs2, *pixs4, *pixs8, *pixs16, *pixs32, *pixd;
PIX *pixc2, *pixc4, *pixc8;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXCMAP *cmap;
SARRAY *sa;
static char mainName[] = "convert_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: convert_rt", mainName, 1));
if ((pixs1 = pixRead("test1.png")) == NULL)
exit(ERROR_INT("pixs1 not made", mainName, 1));
if ((pixs2 = pixRead("dreyfus2.png")) == NULL)
exit(ERROR_INT("pixs2 not made", mainName, 1));
if ((pixc2 = pixRead("weasel2.4c.png")) == NULL)
exit(ERROR_INT("pixc2 not made", mainName, 1));
if ((pixs4 = pixRead("weasel4.16g.png")) == NULL)
exit(ERROR_INT("pixs4 not made", mainName, 1));
if ((pixc4 = pixRead("weasel4.11c.png")) == NULL)
exit(ERROR_INT("pixc4 not made", mainName, 1));
if ((pixs8 = pixRead("karen8.jpg")) == NULL)
exit(ERROR_INT("pixs8 not made", mainName, 1));
if ((pixc8 = pixRead("weasel8.240c.png")) == NULL)
exit(ERROR_INT("pixc8 not made", mainName, 1));
if ((pixs16 = pixRead("test16.tif")) == NULL)
exit(ERROR_INT("pixs16 not made", mainName, 1));
if ((pixs32 = pixRead("marge.jpg")) == NULL)
exit(ERROR_INT("pixs32 not made", mainName, 1));
error = FALSE;
sa = sarrayCreate(0);
/* Conversion: 1 bpp --> 8 bpp --> 1 bpp */
pixt1 = pixConvertTo8(pixs1, FALSE);
pixt2 = pixThreshold8(pixt1, 1, 0, 0);
pixEqual(pixs1, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs1, 100, 100, "1 bpp, no cmap", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "1 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 1 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 1 bpp <==> 8 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 2 bpp --> 8 bpp --> 2 bpp */
/* Conversion: 2 bpp cmap --> 8 bpp cmap --> 2 bpp cmap */
pixt1 = pixRemoveColormap(pixs2, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixThreshold8(pixt1, 2, 4, 0);
pixt3 = pixConvertTo8(pixt2, FALSE);
pixt4 = pixThreshold8(pixt3, 2, 4, 0);
pixEqual(pixt2, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "2 bpp, no cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "2 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 8 bpp\n");
pixt5 = pixConvertTo8(pixs2, TRUE);
pixt6 = pixThreshold8(pixt5, 2, 4, 1);
pixEqual(pixs2, pixt6, &same);
if (!same) {
pixDisplayWithTitle(pixs2, 100, 100, "2 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt6, 500, 100, "2 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 8 bpp; cmap",
L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 8 bpp; cmap\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
/* Conversion: 4 bpp --> 8 bpp --> 4 bpp */
/* Conversion: 4 bpp cmap --> 8 bpp cmap --> 4 bpp cmap */
pixt1 = pixRemoveColormap(pixs4, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixThreshold8(pixt1, 4, 16, 0);
pixt3 = pixConvertTo8(pixt2, FALSE);
pixt4 = pixThreshold8(pixt3, 4, 16, 0);
pixEqual(pixt2, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "4 bpp, no cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 8 bpp\n");
pixt5 = pixConvertTo8(pixs4, TRUE);
pixt6 = pixThreshold8(pixt5, 4, 16, 1);
pixEqual(pixs4, pixt6, &same);
if (!same) {
pixDisplayWithTitle(pixs4, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt6, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 8 bpp, cmap",
L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 8 bpp; cmap\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
/* Conversion: 2 bpp cmap --> 2 bpp --> 2 bpp cmap --> 2 bpp */
pixt1 = pixRemoveColormap(pixs2, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixConvertGrayToColormap(pixt1);
pixt3 = pixRemoveColormap(pixt2, REMOVE_CMAP_TO_GRAYSCALE);
pixt4 = pixThresholdTo2bpp(pixt3, 4, 1);
pixEqual(pixt1, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixs2, 100, 100, "2 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "2 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 2 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 2 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 4 bpp cmap --> 4 bpp --> 4 bpp cmap --> 4 bpp */
pixt1 = pixRemoveColormap(pixs4, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixConvertGrayToColormap(pixt1);
pixt3 = pixRemoveColormap(pixt2, REMOVE_CMAP_TO_GRAYSCALE);
pixt4 = pixThresholdTo4bpp(pixt3, 16, 1);
pixEqual(pixt1, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixs4, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 4 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 4 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 8 bpp --> 8 bpp cmap --> 8 bpp */
pixt1 = pixConvertTo8(pixs8, TRUE);
pixt2 = pixConvertTo8(pixt1, FALSE);
pixEqual(pixs8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixt1, 100, 100, "8 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 8 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 2 bpp cmap --> 32 bpp --> 2 bpp cmap */
pixt1 = pixConvertTo8(pixc2, TRUE);
pixt2 = pixConvertTo32(pixt1);
pixt3 = pixConvertTo32(pixc2);
pixEqual(pixt2, pixt3, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "32 bpp", DFLAG);
pixDisplayWithTitle(pixt3, 500, 100, "32 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp ==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 32 bpp\n");
cmap = pixGetColormap(pixc2);
pixt4 = pixOctcubeQuantFromCmap(pixt3, cmap, 2, 4, L_EUCLIDEAN_DISTANCE);
pixEqual(pixc2, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixc2, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 4 bpp cmap --> 32 bpp --> 4 bpp cmap */
pixt1 = pixConvertTo8(pixc4, TRUE);
pixt2 = pixConvertTo32(pixt1);
pixt3 = pixConvertTo32(pixc4);
pixEqual(pixt2, pixt3, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "32 bpp", DFLAG);
pixDisplayWithTitle(pixt3, 500, 100, "32 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp ==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 32 bpp\n");
cmap = pixGetColormap(pixc4);
pixt4 = pixOctcubeQuantFromCmap(pixt3, cmap, 2, 4, L_EUCLIDEAN_DISTANCE);
pixEqual(pixc4, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixc4, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 8 bpp --> 32 bpp --> 8 bpp */
pixt1 = pixConvertTo32(pixs8);
pixt2 = pixConvertTo8(pixt1, FALSE);
pixEqual(pixs8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs8, 100, 100, "8 bpp", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp <==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 8 bpp --> 16 bpp --> 8 bpp */
pixt1 = pixConvert8To16(pixs8, 8);
pixt2 = pixConvertTo8(pixt1, FALSE);
pixEqual(pixs8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs8, 100, 100, "8 bpp", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp <==> 16 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 16 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 16 bpp --> 8 bpp --> 16 bpp */
pixt1 = pixConvert16To8(pixs16, 1);
pixt2 = pixConvertTo16(pixt1);
pixWrite("/tmp/junkpix.png", pixt2, IFF_PNG);
pixEqual(pixs16, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs16, 100, 100, "16 bpp", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "16 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 16 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 16 bpp <==> 8 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 8 bpp cmap --> 32 bpp --> 8 bpp cmap */
/* Required to go to level 6 of octcube to get identical result */
pixt1 = pixConvertTo32(pixc8);
cmap = pixGetColormap(pixc8);
pixt2 = pixOctcubeQuantFromCmap(pixt1, cmap, 2, 6, L_EUCLIDEAN_DISTANCE);
pixEqual(pixc8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixc8, 100, 100, "8 bpp cmap", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp cmap <==> 32 bpp cmap",
L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Summarize results */
if (error == FALSE)
fprintf(stderr, "No errors found\n");
else {
errorstr = sarrayToString(sa, 1);
fprintf(stderr, "Errors in the following:\n %s", errorstr);
lept_free(errorstr);
}
sarrayDestroy(&sa);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixs4);
pixDestroy(&pixc2);
pixDestroy(&pixc4);
pixDestroy(&pixs8);
pixDestroy(&pixc8);
pixDestroy(&pixs16);
pixDestroy(&pixs32);
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;
}
int main(int argc,
char **argv)
{
BOX *box;
PIX *pixs, *pixs8, *pixm, *pixt1, *pixt2, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Start with a 32 bpp image and a mask. Use the
* same mask for all clip/masked operations. */
pixs = pixRead("test24.jpg");
pixt1 = pixRead("rabi.png");
box = boxCreate(303, 1983, 800, 500);
pixm = pixClipRectangle(pixt1, box, NULL);
pixInvert(pixm, pixm);
boxDestroy(&box);
box = boxCreate(100, 100, 800, 500); /* clips on pixs and derivatives */
pixt2 = pixClipRectangle(pixs, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 0 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixDestroy(&pixt1);
/* Clip 32 bpp RGB */
pixd = pixClipMasked(pixs, pixm, 100, 100, 0x03c08000);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Clip 8 bpp colormapped */
pixt1 = pixMedianCutQuant(pixs, 0);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 2 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x03c08000);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 3 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 4 bpp colormapped */
pixt1 = pixOctreeQuantNumColors(pixs, 16, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 4 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x03c08000);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 5 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 2 bpp colormapped */
pixt1 = pixMedianCutQuantGeneral(pixs, 0, 2, 4, 5, 1, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 6 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x03608000);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 7 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 8 bpp gray */
pixs8 = pixConvertRGBToLuminance(pixs);
pixt2 = pixClipRectangle(pixs8, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 8 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixs8, pixm, 100, 100, 90);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Clip 4 bpp gray */
pixt1 = pixThresholdTo4bpp(pixs8, 16, 0);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 10 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 11 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 5);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 12 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 13 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 4 bpp gray, colormapped */
pixt1 = pixThresholdTo4bpp(pixs8, 16, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 14 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x55555500);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 15 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 2 bpp gray */
pixt1 = pixThresholdTo2bpp(pixs8, 4, 0);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 16 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 1);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 17 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 2 bpp gray, colormapped */
pixt1 = pixThresholdTo2bpp(pixs8, 4, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x55555500);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 18 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixm);
pixDestroy(&pixs);
pixDestroy(&pixs8);
boxDestroy(&box);
/* Finally, do the 1 bpp painting through clipped region.
* We start with two 1 bpp text sources, use the inverse
* of the 2nd for the mask (so we take all of the 1st
* pixels under this mask), and for the remainder, which
* are the fg pixels in the 2nd, we paint them black (1).
* So this is a simple and fast blending of two 1 bpp pix. */
pixs = pixRead("feyn.tif");
box = boxCreate(670, 827, 800, 500);
pixt2 = pixClipRectangle(pixs, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 19 */
pixaAddPix(pixa, pixt2, L_INSERT);
boxDestroy(&box);
pixt1 = pixRead("rabi.png");
box = boxCreate(303, 1983, 800, 500);
pixm = pixClipRectangle(pixt1, box, NULL);
pixInvert(pixm, pixm);
regTestWritePixAndCheck(rp, pixm, IFF_PNG); /* 20 */
pixaAddPix(pixa, pixm, L_INSERT);
pixd = pixClipMasked(pixs, pixm, 670, 827, 1);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 21 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixs);
pixDestroy(&pixt1);
boxDestroy(&box);
/* If in testing mode, make a pdf */
if (rp->display) {
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0,
"Paint through mask", "/tmp/lept/regout/paintmask.pdf");
L_INFO("Output pdf: /tmp/lept/regout/paintmask.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char outname[256];
l_int32 loc, display, success;
L_BMF *bmf, *bmftop;
FILE *fp;
PIX *pixs, *pixt, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8;
PIXA *pixa;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
bmf = bmfCreate("./fonts", 6);
bmftop = bmfCreate("./fonts", 10);
pixs = pixRead("lucasta-47.jpg");
pix1 = pixScale(pixs, 0.4, 0.4); /* 8 bpp grayscale */
pix2 = pixConvertTo32(pix1); /* 32 bpp rgb */
pix3 = pixThresholdOn8bpp(pix1, 12, 1); /* 8 bpp cmapped */
pix4 = pixThresholdTo4bpp(pix1, 10, 1); /* 4 bpp cmapped */
pix5 = pixThresholdTo4bpp(pix1, 10, 0); /* 4 bpp not cmapped */
pix6 = pixThresholdTo2bpp(pix1, 3, 1); /* 2 bpp cmapped */
pix7 = pixThresholdTo2bpp(pix1, 3, 0); /* 2 bpp not cmapped */
pix8 = pixThresholdToBinary(pix1, 160); /* 1 bpp */
for (loc = 1; loc < 5; loc++) {
pixa = pixaCreate(0);
AddTextAndSave(pixa, pix1, bmf, textstr[0], loc, 190);
AddTextAndSave(pixa, pix2, bmf, textstr[1], loc, 0xff000000);
AddTextAndSave(pixa, pix3, bmf, textstr[2], loc, 0x00ff0000);
AddTextAndSave(pixa, pix4, bmf, textstr[3], loc, 0x0000ff00);
AddTextAndSave(pixa, pix5, bmf, textstr[4], loc, 11);
AddTextAndSave(pixa, pix6, bmf, textstr[5], loc, 0xff000000);
AddTextAndSave(pixa, pix7, bmf, textstr[6], loc, 2);
AddTextAndSave(pixa, pix8, bmf, textstr[7], loc, 1);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop, topstr[loc - 1],
0xff00ff00, L_ADD_ABOVE, NULL);
snprintf(outname, 240, "/tmp/writetext.%d.png", loc - 1);
pixWrite(outname, pixd, IFF_PNG);
regTestCheckFile(fp, argv, outname, loc - 1, &success);
pixDisplayWithTitle(pixd, 50 * loc, 50, NULL, display);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixaDestroy(&pixa);
}
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
bmfDestroy(&bmf);
bmfDestroy(&bmftop);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
main(int argc,
char **argv)
{
char outname[256], buf[512];
l_int32 loc, i;
L_BMF *bmf, *bmftop;
PIX *pixs, *pixt, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8;
PIXA *pixa;
L_REGPARAMS *rp;
SARRAY *sa;
if (regTestSetup(argc, argv, &rp))
return 1;
bmf = bmfCreate("./fonts", 6);
bmftop = bmfCreate("./fonts", 10);
pixs = pixRead("lucasta-47.jpg");
pix1 = pixScale(pixs, 0.4, 0.4); /* 8 bpp grayscale */
pix2 = pixConvertTo32(pix1); /* 32 bpp rgb */
pix3 = pixThresholdOn8bpp(pix1, 12, 1); /* 8 bpp cmapped */
pix4 = pixThresholdTo4bpp(pix1, 10, 1); /* 4 bpp cmapped */
pix5 = pixThresholdTo4bpp(pix1, 10, 0); /* 4 bpp not cmapped */
pix6 = pixThresholdTo2bpp(pix1, 3, 1); /* 2 bpp cmapped */
pix7 = pixThresholdTo2bpp(pix1, 3, 0); /* 2 bpp not cmapped */
pix8 = pixThresholdToBinary(pix1, 160); /* 1 bpp */
for (loc = 1; loc < 5; loc++) {
pixa = pixaCreate(0);
AddTextAndSave(pixa, pix1, bmf, textstr[0], loc, 800);
AddTextAndSave(pixa, pix2, bmf, textstr[1], loc, 0xff000000);
AddTextAndSave(pixa, pix3, bmf, textstr[2], loc, 0x00ff0000);
AddTextAndSave(pixa, pix4, bmf, textstr[3], loc, 0x0000ff00);
AddTextAndSave(pixa, pix5, bmf, textstr[4], loc, 800);
AddTextAndSave(pixa, pix6, bmf, textstr[5], loc, 0xff000000);
AddTextAndSave(pixa, pix7, bmf, textstr[6], loc, 800);
AddTextAndSave(pixa, pix8, bmf, textstr[7], loc, 800);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop, topstr[loc - 1],
0xff00ff00, L_ADD_ABOVE, NULL);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 - 4 */
pixDisplayWithTitle(pixd, 50 * loc, 50, NULL, rp->display);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixaDestroy(&pixa);
}
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
bmfDestroy(&bmf);
bmfDestroy(&bmftop);
/* Write multiple lines in different colors, filling up
* the colormap and requesting even more colors. */
pixs = pixRead("weasel4.11c.png");
pix1 = pixConvertTo8(pixs, 0);
pix2 = pixScale(pixs, 8.0, 8.0);
pix3 = pixQuantFromCmap(pix2, pixGetColormap(pixs), 4, 5,
L_EUCLIDEAN_DISTANCE);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 5 */
pixDisplayWithTitle(pix3, 0, 500, NULL, rp->display);
bmf = bmfCreate("fonts", 10);
sa = sarrayCreate(6);
for (i = 0; i < 6; i++) {
snprintf(buf, sizeof(buf), "This is textline %d\n", i);
sarrayAddString(sa, buf, L_COPY);
}
for (i = 0; i < 6; i++) {
pixSetTextline(pix3, bmf, sarrayGetString(sa, i, L_NOCOPY),
colors[i], 50, 120 + 60 * i, NULL, NULL);
}
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 6 */
pixDisplayWithTitle(pix3, 600, 500, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
bmfDestroy(&bmf);
sarrayDestroy(&sa);
return regTestCleanup(rp);
}