int main(int argc,
char **argv)
{
char *filein, *fileout;
char bigbuf[512];
l_int32 iplot, same;
l_float32 gam;
l_float64 gamma[] = {.5, 1.0, 1.5, 2.0, 2.5, -1.0};
GPLOT *gplot;
NUMA *na, *nax;
PIX *pixs, *pixd;
static char mainName[] = "gammatest";
if (argc != 4)
return ERROR_INT(" Syntax: gammatest filein gam fileout", mainName, 1);
lept_mkdir("lept/gamma");
filein = argv[1];
gam = atof(argv[2]);
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
startTimer();
pixd = pixGammaTRC(NULL, pixs, gam, MINVAL, MAXVAL);
fprintf(stderr, "Time for gamma: %7.3f sec\n", stopTimer());
pixGammaTRC(pixs, pixs, gam, MINVAL, MAXVAL);
pixEqual(pixs, pixd, &same);
if (!same)
fprintf(stderr, "Error in pixGammaTRC!\n");
pixWrite(fileout, pixs, IFF_JFIF_JPEG);
pixDestroy(&pixs);
na = numaGammaTRC(gam, MINVAL, MAXVAL);
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/gamma/trc", "gamma trc");
l_fileDisplay("/tmp/lept/gamma/trc.png", 100, 100, 1.0);
numaDestroy(&na);
/* Plot gamma TRC maps */
gplot = gplotCreate("/tmp/lept/gamma/corr", GPLOT_PNG,
"Mapping function for gamma correction",
"value in", "value out");
nax = numaMakeSequence(0.0, 1.0, 256);
for (iplot = 0; gamma[iplot] >= 0.0; iplot++) {
na = numaGammaTRC(gamma[iplot], 30, 215);
sprintf(bigbuf, "gamma = %3.1f", gamma[iplot]);
gplotAddPlot(gplot, nax, na, GPLOT_LINES, bigbuf);
numaDestroy(&na);
}
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
l_fileDisplay("/tmp/lept/gamma/corr.png", 100, 100, 1.0);
numaDestroy(&nax);
return 0;
}
void
GenCleans(const char *fname,
l_int32 *pindex,
l_int32 thresh,
L_BMF *bmf)
{
l_int32 index, blackval, whiteval;
char buf[256];
PIX *pix1, *pix2, *pix3, *pix4, *pix5;
blackval = 70;
whiteval = 180;
index = *pindex;
pix1 = pixRead(fname);
snprintf(buf, sizeof(buf), "/tmp/lept/adapt_%03d.jpg", index++);
pixWrite(buf, pix1, IFF_JFIF_JPEG);
pix2 = pixBackgroundNorm(pix1, NULL, NULL, 10, 15, thresh, 25, 200, 2, 1);
snprintf(buf, sizeof(buf), "Norm color: fg thresh = %d", thresh);
fprintf(stderr, "%s\n", buf);
pix3 = pixAddSingleTextline(pix2, bmf, buf, 0x00ff0000, L_ADD_BELOW);
snprintf(buf, sizeof(buf), "/tmp/lept/adapt_%03d.jpg", index++);
pixWrite(buf, pix3, IFF_JFIF_JPEG);
pixDestroy(&pix3);
pix3 = pixGammaTRC(NULL, pix2, 1.0, blackval, whiteval);
snprintf(buf, sizeof(buf), "Clean color: fg thresh = %d", thresh);
pix4 = pixAddSingleTextblock(pix3, bmf, buf, 0x00ff0000, L_ADD_BELOW, NULL);
snprintf(buf, sizeof(buf), "/tmp/lept/adapt_%03d.jpg", index++);
pixWrite(buf, pix4, IFF_JFIF_JPEG);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pix2 = pixConvertRGBToGray(pix1, 0.33, 0.34, 0.33);
pix3 = pixBackgroundNorm(pix2, NULL, NULL, 10, 15, thresh, 25, 200, 2, 1);
pix4 = pixGammaTRC(NULL, pix3, 1.0, blackval, whiteval);
snprintf(buf, sizeof(buf), "Clean gray: fg thresh = %d", thresh);
pix5 = pixAddSingleTextblock(pix4, bmf, buf, 0x00ff0000, L_ADD_BELOW, NULL);
snprintf(buf, sizeof(buf), "/tmp/lept/adapt_%03d.jpg", index++);
pixWrite(buf, pix5, IFF_JFIF_JPEG);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix1);
*pindex = index;
return;
}
main(int argc,
char **argv)
{
PIX *pixs, *pixd;
l_int32 minval, maxval;
l_float32 gamma;
char *filein, *fileout;
static char mainName[] = "trctest";
if (argc != 6)
exit(ERROR_INT(" Syntax: trctest filein gamma minval maxval fileout",
mainName, 1));
filein = argv[1];
gamma = atof(argv[2]);
minval = atoi(argv[3]);
maxval = atoi(argv[4]);
fileout = argv[5];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
pixd = pixGammaTRC(NULL, pixs, gamma, minval, maxval);
pixWrite(fileout, pixd, IFF_PNG);
pixDestroy(&pixs);
pixDestroy(&pixd);
return 0;
}
/* load PNG, TIFF, JPG, GIF or BMP to PIX datastructure. The actual supported
* formats depends on how the leptonica was compiled */
PIX *loadimage(char *filename){
PIX *pix, *pixt;
int format, bpp;
format=fileformat(filename);
// In later versions of leptonica you will have to do this
// pixReadHeader(filename, format,NULL,NULL,NULL,bpp,NULL);
if(format!=IFF_PNG && format!=IFF_JFIF_JPEG && format!=IFF_TIFF && format!=
IFF_GIF && format!=7 && format!=8){
dfprintf(stderr,"Not recognised file format %i", format);
return NULL;
}
if ((pix = pixRead(filename)) == NULL) return NULL;
/* TODO: convert image to 1-bpp 300dpi regardless of scan */
bpp=pixGetDepth(pix);
if(bpp>1){
/*
printf("Bits per pixel=%i",bpp);
exit(1); */
//pixThresholdForFgBg(pix,5,100,NULL,NULL);
//pixContrastTRC(pix, pix, 1000);
pixt = pixContrastNorm(NULL, pix, 10, 10, 40, 2, 2);
pixDestroy(&pix);
pix = pixGammaTRC(NULL, pixt, 1.5, 50, 235);
pixt=pixThresholdToBinary(pix, 200);
//pixt=pixThreshold8(pix,1,1,0);
pixDestroy(&pix);
pix=pixt;
}
return pix;
}
/*
* Clean dark background of image
* based on leptonica adaptmap_dark.c
*/
PIX* MainWindow::cleanDarkBackground(int blackval, int whiteval, int thresh) {
QApplication::setOverrideCursor(Qt::WaitCursor);
PIX *pix1, *pix2;
pix1 = pixBackgroundNorm(pixs, NULL, NULL, 10, 15, thresh, 25, 200, 2, 1);
pix2 = pixGammaTRC(NULL, pix1, 1.0, blackval, whiteval);
setPixToScene(pix2);
pixDestroy(&pix1);
QApplication::restoreOverrideCursor();
return pix2;
}
/*
* Binarize and fix uneven illumination
*/
void MainWindow::on_actionBinarizeUnIl_triggered() {
QApplication::setOverrideCursor(Qt::WaitCursor);
PIX *pixc, *pixg, *pixsg, *pixd;
/* Convert the RGB image to grayscale. */
this->statusBar()->showMessage(tr("Convert the RGB image to grayscale."));
pixsg = pixConvertRGBToLuminance(pixs);
setPixToScene(pixsg);
/* Remove the text in the fg. */
this->statusBar()->showMessage(tr("Remove the text in the fg."));
pixc = pixCloseGray(pixsg, 25, 25);
setPixToScene(pixc);
/* Smooth the bg with a convolution. */
// pixsm = pixBlockconv(pixc, 15, 15);
// pixDestroy(&pixsm);
/* Normalize for uneven illumination on gray image. */
this->statusBar()->showMessage(tr("Normalize for uneven illumination on gray image."));
pixBackgroundNormGrayArrayMorph(pixsg, NULL, 4, 5, 200, &pixg);
pixc = pixApplyInvBackgroundGrayMap(pixsg, pixg, 4, 4);
pixDestroy(&pixsg);
pixDestroy(&pixg);
setPixToScene(pixc);
/* Increase the dynamic range. */
// make dark gray *black* and light gray *white*
this->statusBar()->showMessage(tr("Increase the dynamic range."));
pixd = pixGammaTRC(NULL, pixc, 1.0, 50, 220);
setPixToScene(pixd);
/* Threshold to 1 bpp. */
this->statusBar()->showMessage(tr("Threshold to 1 bpp."));
pixs = pixThresholdToBinary(pixd, 120);
pixDestroy(&pixd);
setPixToScene();
this->statusBar()->showMessage(tr("Finished..."), 2000);
modified = true;
updateTitle();
QApplication::restoreOverrideCursor();
}
jint Java_com_googlecode_leptonica_android_Morphology_nativeTophat(JNIEnv *env,
jclass clazz,
jint nativePix) {
LOGV("%s",__FUNCTION__);
PIX *pixs = (PIX *) nativePix;
if(pixs==0){
LOGI("pixs is 0");
}
PIX* pixsg = pixConvertRGBToLuminance(pixs);
LOGI("luminance");
if(pixsg==0){
LOGI("lumi error");
}
/* Black tophat (closing - original-image) and invert */
PIX* pixg = pixTophat(pixsg, 15, 15, L_TOPHAT_BLACK);
LOGI("tophat");
if(pixg==0){
LOGI("tophat error");
}
pixInvert(pixg, pixg);
LOGI("invert");
if(pixg==0){
LOGI("invert error");
}
/* Set black point at 200, white point at 245. */
PIX* pixd = pixGammaTRC(NULL, pixg, 1.0, 200, 245);
LOGI("gamma");
if(pixd==0){
LOGI("gamma error");
}
pixDestroy(&pixsg);
pixDestroy(&pixg);
return (jint) pixd;
}
main(int argc,
char **argv)
{
PIX *pixs, *pixsg, *pixg, *pixd;
PIXA *pixa;
static char mainName[] = "livre_tophat";
if (argc != 1)
return ERROR_INT(" Syntax: livre_tophat", mainName, 1);
/* Read the image in at 150 ppi. */
if ((pixs = pixRead("brothers.150.jpg")) == NULL)
return ERROR_INT("pix not made", mainName, 1);
pixDisplayWrite(NULL, -1);
pixDisplayWriteFormat(pixs, 2, IFF_JFIF_JPEG);
pixsg = pixConvertRGBToLuminance(pixs);
/* Black tophat (closing - original-image) and invert */
pixg = pixTophat(pixsg, 15, 15, L_TOPHAT_BLACK);
pixInvert(pixg, pixg);
pixDisplayWriteFormat(pixg, 2, IFF_JFIF_JPEG);
/* Set black point at 200, white point at 245. */
pixd = pixGammaTRC(NULL, pixg, 1.0, 200, 245);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixg);
pixDestroy(&pixd);
/* Generate the output image */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 350, 3, 0, 25, 2);
pixWrite("/tmp/tophat.jpg", pixd, IFF_JFIF_JPEG);
pixDisplay(pixd, 0, 0);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixsg);
return 0;
}
int main(int argc,
char **argv) {
char dilateseq[BUF_SIZE], erodeseq[BUF_SIZE];
char openseq[BUF_SIZE], closeseq[BUF_SIZE];
char wtophatseq[BUF_SIZE], btophatseq[BUF_SIZE];
char *filein;
l_int32 w, h, d;
PIX *pixs, *pixt, *pixt2, *pixt3, *pixt3a, *pixt4;
PIX *pixg, *pixd, *pixd1, *pixd2, *pixd3;
PIXACC *pacc;
PIXCMAP *cmap;
static char mainName[] = "graymorph1_reg";
if (argc != 2)
return ERROR_INT(" Syntax: graymorph1_reg filein", mainName, 1);
filein = argv[1];
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 8)
return ERROR_INT("pixs not 8 bpp", mainName, 1);
/* -------- Test gray morph, including interpreter ------------ */
pixd = pixDilateGray(pixs, WSIZE, HSIZE);
sprintf(dilateseq, "D%d.%d", WSIZE, HSIZE);
pixg = pixGrayMorphSequence(pixs, dilateseq, HORIZ_SEP, 0);
pixCompare(pixd, pixg, "results are the same", "results are different");
pixDestroy(&pixg);
pixDestroy(&pixd);
pixd = pixErodeGray(pixs, WSIZE, HSIZE);
sprintf(erodeseq, "E%d.%d", WSIZE, HSIZE);
pixg = pixGrayMorphSequence(pixs, erodeseq, HORIZ_SEP, 100);
pixCompare(pixd, pixg, "results are the same", "results are different");
pixDestroy(&pixg);
pixDestroy(&pixd);
pixd = pixOpenGray(pixs, WSIZE, HSIZE);
sprintf(openseq, "O%d.%d", WSIZE, HSIZE);
pixg = pixGrayMorphSequence(pixs, openseq, HORIZ_SEP, 200);
pixCompare(pixd, pixg, "results are the same", "results are different");
pixDestroy(&pixg);
pixDestroy(&pixd);
pixd = pixCloseGray(pixs, WSIZE, HSIZE);
sprintf(closeseq, "C%d.%d", WSIZE, HSIZE);
pixg = pixGrayMorphSequence(pixs, closeseq, HORIZ_SEP, 300);
pixCompare(pixd, pixg, "results are the same", "results are different");
pixDestroy(&pixg);
pixDestroy(&pixd);
pixd = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_WHITE);
sprintf(wtophatseq, "Tw%d.%d", WSIZE, HSIZE);
pixg = pixGrayMorphSequence(pixs, wtophatseq, HORIZ_SEP, 400);
pixCompare(pixd, pixg, "results are the same", "results are different");
pixDestroy(&pixg);
pixDestroy(&pixd);
pixd = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_BLACK);
sprintf(btophatseq, "Tb%d.%d", WSIZE, HSIZE);
pixg = pixGrayMorphSequence(pixs, btophatseq, HORIZ_SEP, 500);
pixCompare(pixd, pixg, "results are the same", "results are different");
pixDestroy(&pixg);
/* ------------- Test erode/dilate duality -------------- */
pixd = pixDilateGray(pixs, WSIZE, HSIZE);
pixInvert(pixs, pixs);
pixd2 = pixErodeGray(pixs, WSIZE, HSIZE);
pixInvert(pixd2, pixd2);
pixCompare(pixd, pixd2, "results are the same", "results are different");
pixDestroy(&pixd);
pixDestroy(&pixd2);
/* ------------- Test open/close duality -------------- */
pixd = pixOpenGray(pixs, WSIZE, HSIZE);
pixInvert(pixs, pixs);
pixd2 = pixCloseGray(pixs, WSIZE, HSIZE);
pixInvert(pixd2, pixd2);
pixCompare(pixd, pixd2, "results are the same", "results are different");
pixDestroy(&pixd);
pixDestroy(&pixd2);
/* ------------- Test tophat duality -------------- */
pixd = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_WHITE);
pixInvert(pixs, pixs);
pixd2 = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_BLACK);
pixCompare(pixd, pixd2, "Correct: images are duals",
"Error: images are not duals");
pixDestroy(&pixd);
pixDestroy(&pixd2);
pixInvert(pixs, pixs);
pixd = pixGrayMorphSequence(pixs, "Tw9.5", HORIZ_SEP, 100);
pixInvert(pixs, pixs);
pixd2 = pixGrayMorphSequence(pixs, "Tb9.5", HORIZ_SEP, 300);
pixCompare(pixd, pixd2, "Correct: images are duals",
"Error: images are not duals");
pixDestroy(&pixd);
pixDestroy(&pixd2);
/* ------------- Test opening/closing for large sels -------------- */
pixd = pixGrayMorphSequence(pixs,
"C9.9 + C19.19 + C29.29 + C39.39 + C49.49", HORIZ_SEP, 100);
pixDestroy(&pixd);
pixd = pixGrayMorphSequence(pixs,
"O9.9 + O19.19 + O29.29 + O39.39 + O49.49", HORIZ_SEP, 400);
pixDestroy(&pixd);
/* ---------- Closing plus white tophat result ------------ *
* Parameters: wsize, hsize = 9, 29 *
* ---------------------------------------------------------*/
pixd = pixCloseGray(pixs, 9, 9);
pixd1 = pixTophat(pixd, 9, 9, L_TOPHAT_WHITE);
pixd2 = pixGrayMorphSequence(pixs, "C9.9 + TW9.9", HORIZ_SEP, 0);
pixCompare(pixd1, pixd2, "correct: same", "wrong: different");
pixd3 = pixMaxDynamicRange(pixd1, L_LINEAR_SCALE);
pixDisplayWrite(pixd3, 1);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pixd3);
pixd = pixCloseGray(pixs, 29, 29);
pixd1 = pixTophat(pixd, 29, 29, L_TOPHAT_WHITE);
pixd2 = pixGrayMorphSequence(pixs, "C29.29 + Tw29.29", HORIZ_SEP, 0);
pixCompare(pixd1, pixd2, "correct: same", "wrong: different");
pixd3 = pixMaxDynamicRange(pixd1, L_LINEAR_SCALE);
pixDisplayWrite(pixd3, 1);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pixd3);
/* --------- hdome with parameter height = 100 ------------*/
pixd = pixHDome(pixs, 100, 4);
pixd2 = pixMaxDynamicRange(pixd, L_LINEAR_SCALE);
pixDisplayWrite(pixd2, 1);
pixDestroy(&pixd2);
/* ----- Contrast enhancement with morph parameters 9, 9 -------*/
pixd1 = pixInitAccumulate(w, h, 0x8000);
pixAccumulate(pixd1, pixs, L_ARITH_ADD);
pixMultConstAccumulate(pixd1, 3., 0x8000);
pixd2 = pixOpenGray(pixs, 9, 9);
pixAccumulate(pixd1, pixd2, L_ARITH_SUBTRACT);
pixDestroy(&pixd2);
pixd2 = pixCloseGray(pixs, 9, 9);
pixAccumulate(pixd1, pixd2, L_ARITH_SUBTRACT);
pixDestroy(&pixd2);
pixd = pixFinalAccumulate(pixd1, 0x8000, 8);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd1);
/* Do the same thing with the Pixacc */
pacc = pixaccCreate(w, h, 1);
pixaccAdd(pacc, pixs);
pixaccMultConst(pacc, 3.);
pixd1 = pixOpenGray(pixs, 9, 9);
pixaccSubtract(pacc, pixd1);
pixDestroy(&pixd1);
pixd1 = pixCloseGray(pixs, 9, 9);
pixaccSubtract(pacc, pixd1);
pixDestroy(&pixd1);
pixd2 = pixaccFinal(pacc, 8);
pixaccDestroy(&pacc);
pixDisplayWrite(pixd2, 1);
pixCompare(pixd, pixd2, "Correct: same", "Wrong: different");
pixDestroy(&pixd);
pixDestroy(&pixd2);
/* ---- Tophat result on feynman stamp, to extract diagrams ----- */
pixDestroy(&pixs);
pixs = pixRead("feynman-stamp.jpg");
/* Make output image to hold five intermediate images */
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
pixd = pixCreate(5 * w + 18, h + 6, 32); /* composite output image */
pixSetAllArbitrary(pixd, 0x0000ff00); /* set to blue */
/* Paste in the input image */
pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_FULL_COLOR);
pixRasterop(pixd, 3, 3, w, h, PIX_SRC, pixt, 0, 0); /* 1st one */
/* pixWrite("/tmp/junkgray.jpg", pixt, IFF_JFIF_JPEG); */
pixDestroy(&pixt);
/* Paste in the grayscale version */
cmap = pixGetColormap(pixs);
if (cmap)
pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE);
else
pixt = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33);
pixt2 = pixConvertTo32(pixt); /* 8 --> 32 bpp */
pixRasterop(pixd, w + 6, 3, w, h, PIX_SRC, pixt2, 0, 0); /* 2nd one */
pixDestroy(&pixt2);
/* Paste in a log dynamic range scaled version of the white tophat */
pixt2 = pixTophat(pixt, 3, 3, L_TOPHAT_WHITE);
pixt3a = pixMaxDynamicRange(pixt2, L_LOG_SCALE);
pixt3 = pixConvertTo32(pixt3a);
pixRasterop(pixd, 2 * w + 9, 3, w, h, PIX_SRC, pixt3, 0, 0); /* 3rd */
/* pixWrite("/tmp/junktophat.jpg", pixt2, IFF_JFIF_JPEG); */
pixDestroy(&pixt3);
pixDestroy(&pixt3a);
pixDestroy(&pixt);
/* Stretch the range and threshold to binary; paste it in */
pixt3a = pixGammaTRC(NULL, pixt2, 1.0, 0, 80);
pixt3 = pixThresholdToBinary(pixt3a, 70);
pixt4 = pixConvertTo32(pixt3);
pixRasterop(pixd, 3 * w + 12, 3, w, h, PIX_SRC, pixt4, 0, 0); /* 4th */
/* pixWrite("/tmp/junkbin.png", pixt3, IFF_PNG); */
pixDestroy(&pixt2);
pixDestroy(&pixt3a);
pixDestroy(&pixt4);
/* Invert; this is the final result */
pixInvert(pixt3, pixt3);
pixt4 = pixConvertTo32(pixt3);
pixRasterop(pixd, 4 * w + 15, 3, w, h, PIX_SRC, pixt4, 0, 0); /* 5th */
pixWrite("/tmp/junkbininvert.png", pixt3, IFF_PNG);
pixDisplayWrite(pixd, 1);
/* pixWrite("/tmp/junkall.jpg", pixd, IFF_JFIF_JPEG); */
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixd);
pixDisplayMultiple("/tmp/display/file*");
pixDestroy(&pixs);
return 0;
}
int main(int argc,
char **argv)
{
char dilateseq[512], erodeseq[512];
char openseq[512], closeseq[512];
char wtophatseq[512], btophatseq[512];
l_int32 w, h;
PIX *pixs, *pix1, *pix2, *pix3, *pix4, *pix5;
PIXA *pixa;
PIXACC *pacc;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("aneurisms8.jpg");
pixa = pixaCreate(0);
/* =========================================================== */
/* -------- Test gray morph, including interpreter ------------ */
pix1 = pixDilateGray(pixs, WSIZE, HSIZE);
sprintf(dilateseq, "D%d.%d", WSIZE, HSIZE);
pix2 = pixGrayMorphSequence(pixs, dilateseq, 0, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestComparePix(rp, pix1, pix2); /* 1 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pix1 = pixErodeGray(pixs, WSIZE, HSIZE);
sprintf(erodeseq, "E%d.%d", WSIZE, HSIZE);
pix2 = pixGrayMorphSequence(pixs, erodeseq, 0, 100);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 2 */
regTestComparePix(rp, pix1, pix2); /* 3 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pix1 = pixOpenGray(pixs, WSIZE, HSIZE);
sprintf(openseq, "O%d.%d", WSIZE, HSIZE);
pix2 = pixGrayMorphSequence(pixs, openseq, 0, 200);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 4 */
regTestComparePix(rp, pix1, pix2); /* 5 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pix1 = pixCloseGray(pixs, WSIZE, HSIZE);
sprintf(closeseq, "C%d.%d", WSIZE, HSIZE);
pix2 = pixGrayMorphSequence(pixs, closeseq, 0, 300);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 6 */
regTestComparePix(rp, pix1, pix2); /* 7 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pix1 = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_WHITE);
sprintf(wtophatseq, "Tw%d.%d", WSIZE, HSIZE);
pix2 = pixGrayMorphSequence(pixs, wtophatseq, 0, 400);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8 */
regTestComparePix(rp, pix1, pix2); /* 9 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pix1 = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_BLACK);
sprintf(btophatseq, "Tb%d.%d", WSIZE, HSIZE);
pix2 = pixGrayMorphSequence(pixs, btophatseq, 0, 500);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 10 */
regTestComparePix(rp, pix1, pix2); /* 11 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
/* ------------- Test erode/dilate duality -------------- */
pix1 = pixDilateGray(pixs, WSIZE, HSIZE);
pix2 = pixInvert(NULL, pixs);
pix3 = pixErodeGray(pix2, WSIZE, HSIZE);
pixInvert(pix3, pix3);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
regTestComparePix(rp, pix1, pix3); /* 13 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* ------------- Test open/close duality -------------- */
pix1 = pixOpenGray(pixs, WSIZE, HSIZE);
pix2 = pixInvert(NULL, pixs);
pix3 = pixCloseGray(pix2, WSIZE, HSIZE);
pixInvert(pix3, pix3);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */
regTestComparePix(rp, pix1, pix3); /* 15 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* ------------- Test tophat duality -------------- */
pix1 = pixTophat(pixs, WSIZE, HSIZE, L_TOPHAT_WHITE);
pix2 = pixInvert(NULL, pixs);
pix3 = pixTophat(pix2, WSIZE, HSIZE, L_TOPHAT_BLACK);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 16 */
regTestComparePix(rp, pix1, pix3); /* 17 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
pix1 = pixGrayMorphSequence(pixs, "Tw9.5", 0, 100);
pix2 = pixInvert(NULL, pixs);
pix3 = pixGrayMorphSequence(pix2, "Tb9.5", 0, 300);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 18 */
regTestComparePix(rp, pix1, pix3); /* 19 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* ------------- Test opening/closing for large sels -------------- */
pix1 = pixGrayMorphSequence(pixs,
"C9.9 + C19.19 + C29.29 + C39.39 + C49.49", 0, 100);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 20 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixGrayMorphSequence(pixs,
"O9.9 + O19.19 + O29.29 + O39.39 + O49.49", 0, 400);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 21 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixaDisplayTiledInColumns(pixa, 4, 1.0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 22 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixaDestroy(&pixa);
pixDestroy(&pix1);
/* =========================================================== */
pixa = pixaCreate(0);
/* ---------- Closing plus white tophat result ------------ *
* Parameters: wsize, hsize = 9, 29 *
* ---------------------------------------------------------*/
pix1 = pixCloseGray(pixs, 9, 9);
pix2 = pixTophat(pix1, 9, 9, L_TOPHAT_WHITE);
pix3 = pixGrayMorphSequence(pixs, "C9.9 + TW9.9", 0, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 23 */
regTestComparePix(rp, pix2, pix3); /* 24 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixMaxDynamicRange(pix2, L_LINEAR_SCALE);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 25 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
pix1 = pixCloseGray(pixs, 29, 29);
pix2 = pixTophat(pix1, 29, 29, L_TOPHAT_WHITE);
pix3 = pixGrayMorphSequence(pixs, "C29.29 + Tw29.29", 0, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 26 */
regTestComparePix(rp, pix2, pix3); /* 27 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixMaxDynamicRange(pix2, L_LINEAR_SCALE);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 28 */
pixaAddPix(pixa, pix1, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* --------- hdome with parameter height = 100 ------------*/
pix1 = pixHDome(pixs, 100, 4);
pix2 = pixMaxDynamicRange(pix1, L_LINEAR_SCALE);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 29 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 30 */
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
/* ----- Contrast enhancement with morph parameters 9, 9 -------*/
pixGetDimensions(pixs, &w, &h, NULL);
pix1 = pixInitAccumulate(w, h, 0x8000);
pixAccumulate(pix1, pixs, L_ARITH_ADD);
pixMultConstAccumulate(pix1, 3., 0x8000);
pix2 = pixOpenGray(pixs, 9, 9);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 31 */
pixaAddPix(pixa, pix2, L_INSERT);
pixAccumulate(pix1, pix2, L_ARITH_SUBTRACT);
pix2 = pixCloseGray(pixs, 9, 9);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 32 */
pixaAddPix(pixa, pix2, L_INSERT);
pixAccumulate(pix1, pix2, L_ARITH_SUBTRACT);
pix2 = pixFinalAccumulate(pix1, 0x8000, 8);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 33 */
pixaAddPix(pixa, pix2, L_INSERT);
pixDestroy(&pix1);
/* Do the same thing with the Pixacc */
pacc = pixaccCreate(w, h, 1);
pixaccAdd(pacc, pixs);
pixaccMultConst(pacc, 3.);
pix1 = pixOpenGray(pixs, 9, 9);
pixaccSubtract(pacc, pix1);
pixDestroy(&pix1);
pix1 = pixCloseGray(pixs, 9, 9);
pixaccSubtract(pacc, pix1);
pixDestroy(&pix1);
pix1 = pixaccFinal(pacc, 8);
pixaccDestroy(&pacc);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 34 */
pixaAddPix(pixa, pix1, L_INSERT);
regTestComparePix(rp, pix1, pix2); /* 35 */
pix1 = pixaDisplayTiledInColumns(pixa, 4, 1.0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 36 */
pixDisplayWithTitle(pix1, 1100, 0, NULL, rp->display);
pixaDestroy(&pixa);
pixDestroy(&pix1);
pixDestroy(&pixs);
/* =========================================================== */
pixa = pixaCreate(0);
/* ---- Tophat result on feynman stamp, to extract diagrams ----- */
pixs = pixRead("feynman-stamp.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
/* Make output image to hold five intermediate images */
pix1 = pixCreate(5 * w + 18, h + 6, 32); /* composite output image */
pixSetAllArbitrary(pix1, 0x0000ff00); /* set to blue */
/* Paste in the input image */
pix2 = pixRemoveColormap(pixs, REMOVE_CMAP_TO_FULL_COLOR);
pixRasterop(pix1, 3, 3, w, h, PIX_SRC, pix2, 0, 0); /* 1st one */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 37 */
pixaAddPix(pixa, pix2, L_INSERT);
/* Paste in the grayscale version */
cmap = pixGetColormap(pixs);
if (cmap)
pix2 = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE);
else
pix2 = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33);
pix3 = pixConvertTo32(pix2); /* 8 --> 32 bpp */
pixRasterop(pix1, w + 6, 3, w, h, PIX_SRC, pix3, 0, 0); /* 2nd one */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 38 */
pixaAddPix(pixa, pix3, L_INSERT);
/* Paste in a log dynamic range scaled version of the white tophat */
pix3 = pixTophat(pix2, 3, 3, L_TOPHAT_WHITE);
pix4 = pixMaxDynamicRange(pix3, L_LOG_SCALE);
pix5 = pixConvertTo32(pix4);
pixRasterop(pix1, 2 * w + 9, 3, w, h, PIX_SRC, pix5, 0, 0); /* 3rd */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 39 */
pixaAddPix(pixa, pix5, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix4);
/* Stretch the range and threshold to binary; paste it in */
pix2 = pixGammaTRC(NULL, pix3, 1.0, 0, 80);
pix4 = pixThresholdToBinary(pix2, 70);
pix5 = pixConvertTo32(pix4);
pixRasterop(pix1, 3 * w + 12, 3, w, h, PIX_SRC, pix5, 0, 0); /* 4th */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 40 */
pixaAddPix(pixa, pix5, L_INSERT);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Invert; this is the final result */
pixInvert(pix4, pix4);
pix5 = pixConvertTo32(pix4);
pixRasterop(pix1, 4 * w + 15, 3, w, h, PIX_SRC, pix5, 0, 0); /* 5th */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 41 */
pixaAddPix(pixa, pix5, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix4);
pix1 = pixaDisplayTiledInRows(pixa, 32, 1700, 1.0, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 42 */
pixDisplayWithTitle(pix1, 0, 800, NULL, rp->display);
pixaDestroy(&pixa);
pixDestroy(&pix1);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
l_int32 irval, igval, ibval;
l_float32 rval, gval, bval, fract, fgfract;
L_BMF *bmf;
BOX *box;
BOXA *boxa;
FPIX *fpix;
PIX *pixs, *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7;
PIX *pix8, *pix9, *pix10, *pix11, *pix12, *pix13, *pix14, *pix15;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
pixs = pixRead("breviar38.150.jpg");
/* pixs = pixRead("breviar32.150.jpg"); */
pixaAddPix(pixa, pixs, L_CLONE);
regTestWritePixAndCheck(rp, pixs, IFF_JFIF_JPEG); /* 0 */
pixDisplayWithTitle(pixs, 0, 0, "Input image", rp->display);
/* Extract the blue component, which is small in all the text
* regions, including in the highlight color region */
pix1 = pixGetRGBComponent(pixs, COLOR_BLUE);
pixaAddPix(pixa, pix1, L_CLONE);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 1 */
pixDisplayWithTitle(pix1, 200, 0, "Blue component", rp->display);
/* Do a background normalization, with the background set to
* approximately 200 */
pix2 = pixBackgroundNormSimple(pix1, NULL, NULL);
pixaAddPix(pixa, pix2, L_COPY);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 2 */
pixDisplayWithTitle(pix2, 400, 0, "BG normalized to 200", rp->display);
/* Do a linear transform on the gray pixels, with 50 going to
* black and 160 going to white. 50 is sufficiently low to
* make both the red and black print quite dark. Quantize
* to a few equally spaced gray levels. This is the image
* to which highlight color will be applied. */
pixGammaTRC(pix2, pix2, 1.0, 50, 160);
pix3 = pixThresholdOn8bpp(pix2, 7, 1);
pixaAddPix(pixa, pix3, L_CLONE);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 3 */
pixDisplayWithTitle(pix3, 600, 0, "Basic quantized with white bg",
rp->display);
/* Identify the regions of red text. First, make a mask
* consisting of all pixels such that (R-B)/B is larger
* than 2.0. This will have all the red, plus a lot of
* the dark pixels. */
fpix = pixComponentFunction(pixs, 1.0, 0.0, -1.0, 0.0, 0.0, 1.0);
pix4 = fpixThresholdToPix(fpix, 2.0);
pixInvert(pix4, pix4); /* red plus some dark text */
pixaAddPix(pixa, pix4, L_CLONE);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 800, 0, "Red plus dark pixels", rp->display);
/* Make a mask consisting of all the red and background pixels */
pix5 = pixGetRGBComponent(pixs, COLOR_RED);
pix6 = pixThresholdToBinary(pix5, 128);
pixInvert(pix6, pix6); /* red plus background (white) */
/* Intersect the two masks to get a mask consisting of pixels
* that are almost certainly red. This is the seed. */
pix7 = pixAnd(NULL, pix4, pix6); /* red only (seed) */
pixaAddPix(pixa, pix7, L_COPY);
regTestWritePixAndCheck(rp, pix7, IFF_PNG); /* 5 */
pixDisplayWithTitle(pix7, 0, 600, "Seed for red color", rp->display);
/* Make the clipping mask by thresholding the image with
* the background cleaned to white. */
pix8 = pixThresholdToBinary(pix2, 230); /* mask */
pixaAddPix(pixa, pix8, L_CLONE);
regTestWritePixAndCheck(rp, pix8, IFF_PNG); /* 6 */
pixDisplayWithTitle(pix8, 200, 600, "Clipping mask for red components",
rp->display);
/* Fill into the mask from the seed */
pixSeedfillBinary(pix7, pix7, pix8, 8); /* filled: red plus touching */
regTestWritePixAndCheck(rp, pix7, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix7, 400, 600, "Red component mask filled",
rp->display);
/* Remove long horizontal and vertical lines from the filled result */
pix9 = pixMorphSequence(pix7, "o40.1", 0);
pixSubtract(pix7, pix7, pix9); /* remove long horizontal lines */
pixDestroy(&pix9);
pix9 = pixMorphSequence(pix7, "o1.40", 0);
pixSubtract(pix7, pix7, pix9); /* remove long vertical lines */
/* Close the regions to be colored */
pix10 = pixMorphSequence(pix7, "c5.1", 0);
pixaAddPix(pixa, pix10, L_CLONE);
regTestWritePixAndCheck(rp, pix10, IFF_PNG); /* 8 */
pixDisplayWithTitle(pix10, 600, 600,
"Components defining regions allowing coloring",
rp->display);
/* Sanity check on amount to be colored. Only accept images
* with less than 10% of all the pixels with highlight color */
pixForegroundFraction(pix10, &fgfract);
if (fgfract >= 0.10) {
L_INFO("too much highlighting: fract = %6.3f; removing it\n",
rp->testname, fgfract);
pixClearAll(pix10);
pixSetPixel(pix10, 0, 0, 1);
}
/* Get the bounding boxes of the regions to be colored */
boxa = pixConnCompBB(pix10, 8);
/* Get a color to paint that is representative of the
* actual highlight color in the image. Scale each
* color component up from the average by an amount necessary
* to saturate the red. Then divide the green and
* blue components by 2.0. */
pixGetAverageMaskedRGB(pixs, pix7, 0, 0, 1, L_MEAN_ABSVAL,
&rval, &gval, &bval);
fract = 255.0 / rval;
irval = lept_roundftoi(fract * rval);
igval = lept_roundftoi(fract * gval / 2.0);
ibval = lept_roundftoi(fract * bval / 2.0);
fprintf(stderr, "(r,g,b) = (%d,%d,%d)\n", irval, igval, ibval);
/* Color the quantized gray version in the selected regions */
pix11 = pixColorGrayRegions(pix3, boxa, L_PAINT_DARK, 220, irval,
igval, ibval);
pixaAddPix(pixa, pix11, L_CLONE);
regTestWritePixAndCheck(rp, pix11, IFF_PNG); /* 9 */
pixDisplayWithTitle(pix11, 800, 600, "Final colored result", rp->display);
pixaAddPix(pixa, pixs, L_CLONE);
/* Test colorization on gray and cmapped gray */
pix12 = pixColorGrayRegions(pix2, boxa, L_PAINT_DARK, 220, 0, 255, 0);
pixaAddPix(pixa, pix12, L_CLONE);
regTestWritePixAndCheck(rp, pix12, IFF_PNG); /* 10 */
pixDisplayWithTitle(pix12, 900, 600, "Colorizing boxa gray", rp->display);
box = boxCreate(200, 200, 250, 350);
pix13 = pixCopy(NULL, pix2);
pixColorGray(pix13, box, L_PAINT_DARK, 220, 0, 0, 255);
pixaAddPix(pixa, pix13, L_CLONE);
regTestWritePixAndCheck(rp, pix13, IFF_PNG); /* 11 */
pixDisplayWithTitle(pix13, 1000, 600, "Colorizing box gray", rp->display);
pix14 = pixThresholdTo4bpp(pix2, 6, 1);
pix15 = pixColorGrayRegions(pix14, boxa, L_PAINT_DARK, 220, 0, 0, 255);
pixaAddPix(pixa, pix15, L_CLONE);
regTestWritePixAndCheck(rp, pix15, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix15, 1100, 600, "Colorizing boxa cmap", rp->display);
pixColorGrayCmap(pix14, box, L_PAINT_DARK, 0, 255, 255);
pixaAddPix(pixa, pix14, L_CLONE);
regTestWritePixAndCheck(rp, pix14, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix14, 1200, 600, "Colorizing box cmap", rp->display);
boxDestroy(&box);
/* Generate a pdf of the intermediate results */
lept_mkdir("lept");
L_INFO("Writing to /tmp/lept/colorize.pdf\n", rp->testname);
pixaConvertToPdf(pixa, 90, 1.0, 0, 0, "Colorizing highlighted text",
"/tmp/lept/colorize.pdf");
pixaDestroy(&pixa);
fpixDestroy(&fpix);
boxDestroy(&box);
boxaDestroy(&boxa);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pix9);
pixDestroy(&pix10);
pixDestroy(&pix11);
pixDestroy(&pix12);
pixDestroy(&pix13);
pixDestroy(&pix14);
pixDestroy(&pix15);
/* Test the color detector */
pixa = pixaCreate(7);
bmf = bmfCreate("./fonts", 4);
pix1 = TestForRedColor(rp, "brev06.75.jpg", 1, bmf); /* 14 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev10.75.jpg", 0, bmf); /* 15 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev14.75.jpg", 1, bmf); /* 16 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev20.75.jpg", 1, bmf); /* 17 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev36.75.jpg", 0, bmf); /* 18 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev53.75.jpg", 1, bmf); /* 19 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev56.75.jpg", 1, bmf); /* 20 */
pixaAddPix(pixa, pix1, L_INSERT);
/* Generate a pdf of the color detector results */
L_INFO("Writing to /tmp/lept/colordetect.pdf\n", rp->testname);
pixaConvertToPdf(pixa, 45, 1.0, 0, 0, "Color detection",
"/tmp/lept/colordetect.pdf");
pixaDestroy(&pixa);
bmfDestroy(&bmf);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char *filein, *fileout;
char bigbuf[512];
l_int32 iplot;
l_float32 gam;
l_float64 gamma[NPLOTS] = {.5, 1.0, 1.5, 2.0, 2.5};
GPLOT *gplot;
NUMA *na, *nax;
PIX *pixs, *pixd;
static char mainName[] = "gammatest";
if (argc != 4)
exit(ERROR_INT(" Syntax: gammatest filein gam fileout", mainName, 1));
filein = argv[1];
gam = atof(argv[2]);
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
#if 1
startTimer();
pixGammaTRC(pixs, pixs, gam, MINVAL, MAXVAL);
fprintf(stderr, "Time for gamma: %7.3f sec\n", stopTimer());
pixWrite(fileout, pixs, IFF_JFIF_JPEG);
pixDestroy(&pixs);
#endif
#if 0
startTimer();
pixd = pixGammaTRC(NULL, pixs, gam, MINVAL, MAXVAL);
fprintf(stderr, "Time for gamma: %7.3f sec\n", stopTimer());
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixs);
pixDestroy(&pixd);
#endif
na = numaGammaTRC(gam, MINVAL, MAXVAL);
gplotSimple1(na, GPLOT_X11, "/tmp/junkroot", "gamma trc");
numaDestroy(&na);
#if 1 /* plot gamma TRC maps */
gplot = gplotCreate("/tmp/junkmap", GPLOT_X11,
"Mapping function for gamma correction",
"value in", "value out");
nax = numaMakeSequence(0.0, 1.0, 256);
for (iplot = 0; iplot < NPLOTS; iplot++) {
na = numaGammaTRC(gamma[iplot], 30, 215);
sprintf(bigbuf, "gamma = %3.1f", gamma[iplot]);
gplotAddPlot(gplot, nax, na, GPLOT_LINES, bigbuf);
numaDestroy(&na);
}
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
#endif
return 0;
}
main(int argc,
char **argv)
{
char fname[256];
l_int32 i, w, h, nbins, factor, success, display;
l_int32 spike;
l_uint32 *array, *marray;
FILE *fp;
NUMA *na, *nan, *nai, *narbin;
PIX *pixs, *pixt, *pixd;
PIXA *pixa;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Find the rank bin colors */
pixs = pixRead("map1.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
factor = L_MAX(1, (l_int32)sqrt((l_float64)(w * h / 20000.0)));
nbins = 10;
pixGetRankColorArray(pixs, nbins, L_SELECT_MIN, factor, &array, 2);
for (i = 0; i < nbins; i++)
fprintf(stderr, "%d: %x\n", i, array[i]);
pixd = pixDisplayColorArray(array, nbins, 200, 5, 1);
pixWrite("/tmp/rankhisto.0.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.0.png", 0, &success);
pixDisplayWithTitle(pixd, 100, 100, NULL, display);
pixDestroy(&pixd);
/* Modify the rank bin colors by mapping them such
* that the lightest color is mapped to white */
marray = (l_uint32 *)CALLOC(nbins, sizeof(l_uint32));
for (i = 0; i < nbins; i++)
pixelLinearMapToTargetColor(array[i], array[nbins - 1],
0xffffff00, &marray[i]);
pixd = pixDisplayColorArray(marray, nbins, 200, 5, 1);
pixWrite("/tmp/rankhisto.1.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.1.png", 1, &success);
pixDisplayWithTitle(pixd, 100, 600, NULL, display);
pixDestroy(&pixd);
FREE(marray);
/* Save the histogram plots */
#ifndef _WIN32
sleep(2); /* give gnuplot time to write out the files */
#else
Sleep(2000);
#endif /* _WIN32 */
pixa = PixSavePlots1();
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/rankhisto.2.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.2.png", 2, &success);
pixDisplayWithTitle(pixd, 100, 600, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
/* Map to the lightest bin; then do TRC adjustment */
pixt = pixLinearMapToTargetColor(NULL, pixs, array[nbins - 1], 0xffffff00);
pixd = pixGammaTRC(NULL, pixt, 1.0, 0, 240);
pixWrite("/tmp/rankhisto.3.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.3.png", 3, &success);
pixDisplayWithTitle(pixd, 600, 100, NULL, display);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Now test the edge cases for the histogram and rank LUT,
* where all the histo data is piled up at one place.
* We only require that the result be sensible. */
for (i = 0; i < 3; i++) {
if (i == 0)
spike = 0;
else if (i == 1)
spike = 50;
else
spike = 99;
na = numaMakeConstant(0, 100);
numaReplaceNumber(na, spike, 200.0);
nan = numaNormalizeHistogram(na, 1.0);
numaDiscretizeRankAndIntensity(nan, 10, &narbin, &nai, NULL, NULL);
snprintf(fname, sizeof(fname), "/tmp/rtnan%d", i + 1);
gplotSimple1(nan, GPLOT_PNG, fname, "Normalized Histogram");
snprintf(fname, sizeof(fname), "/tmp/rtnai%d", i + 1);
gplotSimple1(nai, GPLOT_PNG, fname, "Intensity vs. rank bin");
snprintf(fname, sizeof(fname), "/tmp/rtnarbin%d", i + 1);
gplotSimple1(narbin, GPLOT_PNG, fname, "LUT: rank bin vs. Intensity");
numaDestroy(&na);
numaDestroy(&nan);
numaDestroy(&narbin);
numaDestroy(&nai);
}
#ifndef _WIN32
sleep(2); /* give gnuplot time to write out the files */
#else
Sleep(2000);
#endif /* _WIN32 */
pixa = PixSavePlots2();
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/rankhisto.4.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.4.png", 4, &success);
pixDisplayWithTitle(pixd, 500, 600, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
pixDestroy(&pixs);
FREE(array);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc, char* argv[])
{
PIX *pixs, *pixb, *pixt;
int minb;
if (argc < 2) {
USAGE: fprintf(stderr, "Usage: %s </path/to/text-image>\n"
"\t\t[binarize-threshold] [minw:minh:maxw:maxh]\n",
strrchr(argv[0], '/') + 1);
return EINVAL;
}
if (2 < argc) { errno = 0;
minb = strtol(argv[2], NULL, 10);
if (errno < 0) {
fprintf(stderr, "strtol: %s\n", strerror(errno));
goto USAGE;
}
} else minb = 180;
if (!(pixs = pixRead(argv[1]))) ;
if (1 && (pixt = pixBackgroundNormMorph(pixs, NULL, 4, 5, 248))) {
pixDestroy(&pixs); pixs = pixt;
} else
if (0 && (pixt = pixBackgroundNorm(pixs, NULL, NULL,
10, 15, 60, 40, 248, 2, 1))) {
pixDestroy(&pixs); pixs = pixt;
}
if (1 && (pixt = pixFindSkewAndDeskew(pixs, 1, NULL, NULL))) {
pixDestroy(&pixs); pixs = pixt;
} if (0 && pixDisplay(pixs, 0, 0)) ;
if (1) { PTA *ptas, *ptad;
if (!(pixb = pixConvertTo1(pixs, minb))) ;
// pixt = pixDeskewLocal(pixs, 10, 0, 0, 0.0, 0.0, 0.0))
if (!pixGetLocalSkewTransform(pixb,
10, 0, 0, 0.0, 0.0, 0.0, &ptas, &ptad)) {
if ((pixt = pixProjectiveSampledPta(pixs,
ptad, ptas, L_BRING_IN_WHITE))) {
pixDestroy(&pixs); pixs = pixt;
} ptaDestroy(&ptas); ptaDestroy(&ptad);
} pixDestroy(&pixb);
}
if (0 && (pixt = pixGammaTRC(NULL, pixs, 1.0, 30, 180))) {
pixDestroy(&pixs); pixs = pixt;
}
if (!(pixb = pixConvertTo1(pixs, minb))) ;
if (0) { pixDestroy(&pixs); pixs = pixCopy(pixs, pixb); } // XXX:
if (1) {
BOX* box;
int i, n, j, m;
PIX *pixi, *pixl;
BOXA *boxi, *boxl;
int x, y, w, h, wid;
int X = INT_MAX, Y = INT_MAX, W = 0, H;
// XXX: do smaller(or no) pixOpenBrick
if (pixGetRegionsBinary(pixb, &pixi, &pixl, NULL, 0)) ;
boxl = pixConnComp(pixl, NULL, 4);
n = boxaGetCount(boxl);
for (i = 0; i < n; ++i) { BOXA* boxa;
box = boxaGetBox(boxl, i, L_CLONE);
boxGetGeometry(box, &x, &y, &w, &h);
if (w < 30 || h < 30 || w < h || h < (w / 40)) {
boxDestroy(&box); continue;
boxaRemoveBox(boxl, i);
}
if (x < X) X = x; if (y < Y) Y = y; if (W < w) W = w;
pixt = pixClipRectangle(pixb, box, NULL);
boxDestroy(&box);
// XXX: for English
if (0) pixt = pixDilateBrick(pixt, pixt, h >> 1, h >> 1); else
pixt = pixDilateBrick(pixt, pixt, 16 < h ? h >> 4 : 1, h << 1);
if (0 && pixDisplay(pixt, 0, 0)) ;
boxa = pixConnComp(pixt, NULL, 8);
pixDestroy(&pixt);
wid = (h * 3) >> 2;
//boxaShift(boxa, x, y);
m = boxaGetCount(boxa);
for (j = 0; j < m; ++j) {
int x0, y0, w0;
box = boxaGetBox(boxa, j, L_CLONE);
boxGetGeometry(box, &x0, &y0, &w0, NULL);
// merge adjacent 2 or 3 small boxes
if (1 && w0 < wid && (j + 1) < m) {
BOX* boxn; int xn, wn;
boxn = boxaGetBox(boxa, j + 1, L_CLONE);
boxGetGeometry(boxn, &xn, NULL, &wn, NULL);
if ((w0 = xn + wn - x0) < h) {
boxaSparseClearBox(boxa, ++j);
if (w0 < wid && (j + 1) < m) {
boxDestroy(&boxn);
boxn = boxaGetBox(boxa, j + 1, L_CLONE);
boxGetGeometry(boxn, &xn, NULL, &wn, NULL);
if ((wn = xn + wn - x0) < h) {
boxaSparseClearBox(boxa, ++j);
w0 = wn;
}
}
boxSetGeometry(box, -1, -1, w0, -1);
} boxDestroy(&boxn);
}
boxSetGeometry(box, x + x0, y + y0, -1, -1);
boxDestroy(&box);
} boxaSparseCompact(boxa);
if (1 && (pixt = pixDrawBoxa(pixs, boxa, 1, 0xff000000))) {
pixDestroy(&pixs); pixs = pixt;
} boxaDestroy(&boxa);
} H = y + h;
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;
}
Pix* dynamicRange(Pix* pix){
return pixGammaTRC(NULL, pix, 1.0, 30, 180);
}
int main(int argc,
char **argv)
{
char textstr[256];
l_int32 w, h, d, i;
l_uint32 srcval, dstval;
l_float32 scalefact, sat, fract;
L_BMF *bmf8;
L_KERNEL *kel;
NUMA *na;
PIX *pix, *pixs, *pixs1, *pixs2, *pixd;
PIX *pixt0, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa, *pixaf;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pix = pixRead(filein);
pixGetDimensions(pix, &w, &h, &d);
if (d != 32)
return ERROR_INT("file not 32 bpp", argv[0], 1);
scalefact = (l_float32)WIDTH / (l_float32)w;
pixs = pixScale(pix, scalefact, scalefact);
w = pixGetWidth(pixs);
pixaf = pixaCreate(5);
/* TRC: vary gamma */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixGammaTRC(NULL, pixs, 0.3 + 0.15 * i, 0, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 32);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixt1, 0, 100, "TRC Gamma", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* TRC: vary black point */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixGammaTRC(NULL, pixs, 1.0, 5 * i, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixt1, 300, 100, "TRC", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary hue */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixModifyHue(NULL, pixs, 0.01 + 0.05 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixt1, 600, 100, "Hue", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary saturation */
pixa = pixaCreate(20);
na = numaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixModifySaturation(NULL, pixs, -0.9 + 0.1 * i);
pixMeasureSaturation(pixt0, 1, &sat);
pixaAddPix(pixa, pixt0, L_INSERT);
numaAddNumber(na, sat);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
gplotSimple1(na, GPLOT_PNG, "/tmp/regout/enhance.7", "Average Saturation");
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixt1, 900, 100, "Saturation", rp->display);
numaDestroy(&na);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary contrast */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixContrastTRC(NULL, pixs, 0.1 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixt1, 0, 400, "Contrast", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary sharpening */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixUnsharpMasking(pixs, 3, 0.01 + 0.15 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixt1, 300, 400, "Sharp", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Hue constant mapping to lighter background */
pixa = pixaCreate(11);
bmf8 = bmfCreate("fonts", 8);
pixt0 = pixRead("candelabrum-11.jpg");
composeRGBPixel(230, 185, 144, &srcval); /* select typical bg pixel */
for (i = 0; i <= 10; i++) {
fract = 0.10 * i;
pixelFractionalShift(230, 185, 144, fract, &dstval);
pixt1 = pixLinearMapToTargetColor(NULL, pixt0, srcval, dstval);
snprintf(textstr, 50, "Fract = %5.1f", fract);
pixt2 = pixAddSingleTextblock(pixt1, bmf8, textstr, 0xff000000,
L_ADD_BELOW, NULL);
pixSaveTiledOutline(pixt2, pixa, 1.0, (i % 4 == 0) ? 1 : 0, 30, 2, 32);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
pixDestroy(&pixt0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixd, 600, 400, "Constant hue", rp->display);
bmfDestroy(&bmf8);
pixaDestroy(&pixa);
pixDestroy(&pixd);
/* Delayed testing of saturation plot */
regTestCheckFile(rp, "/tmp/regout/enhance.7.png"); /* 7 */
/* Display results */
pixd = pixaDisplay(pixaf, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd, 100, 100, "All", rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixaf);
pixDestroy(&pix);
pixDestroy(&pixs);
/* -----------------------------------------------*
* Test global color transforms *
* -----------------------------------------------*/
/* Make identical cmap and rgb images */
pix = pixRead("wet-day.jpg");
pixs1 = pixOctreeColorQuant(pix, 200, 0);
pixs2 = pixRemoveColormap(pixs1, REMOVE_CMAP_TO_FULL_COLOR);
regTestComparePix(rp, pixs1, pixs2); /* 9 */
/* Make a diagonal color transform matrix */
kel = kernelCreate(3, 3);
kernelSetElement(kel, 0, 0, 0.7);
kernelSetElement(kel, 1, 1, 0.4);
kernelSetElement(kel, 2, 2, 1.3);
/* Apply to both cmap and rgb images. */
pixt1 = pixMultMatrixColor(pixs1, kel);
pixt2 = pixMultMatrixColor(pixs2, kel);
regTestComparePix(rp, pixt1, pixt2); /* 10 */
kernelDestroy(&kel);
/* Apply the same transform in the simpler interface */
pixt3 = pixMultConstantColor(pixs1, 0.7, 0.4, 1.3);
pixt4 = pixMultConstantColor(pixs2, 0.7, 0.4, 1.3);
regTestComparePix(rp, pixt3, pixt4); /* 11 */
regTestComparePix(rp, pixt1, pixt3); /* 12 */
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 13 */
pixDestroy(&pix);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 d;
PIX *pixs, *pixc, *pixr, *pixg, *pixb, *pixsg, *pixsm, *pixd;
PIXA *pixa;
static char mainName[] = "livre_adapt";
if (argc != 1)
exit(ERROR_INT(" Syntax: livre_adapt", mainName, 1));
/* Read the image in at 150 ppi. */
pixDisplayWrite(NULL, -1);
if ((pixs = pixRead("brothers.150.jpg")) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
pixDisplayWriteFormat(pixs, 2, IFF_JFIF_JPEG);
/* Normalize for uneven illumination on RGB image */
pixBackgroundNormRGBArraysMorph(pixs, NULL, 4, 5, 200,
&pixr, &pixg, &pixb);
pixd = pixApplyInvBackgroundRGBMap(pixs, pixr, pixg, pixb, 4, 4);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixd);
/* Convert the RGB image to grayscale. */
pixsg = pixConvertRGBToLuminance(pixs);
pixDisplayWriteFormat(pixsg, 2, IFF_JFIF_JPEG);
/* Remove the text in the fg. */
pixc = pixCloseGray(pixsg, 25, 25);
pixDisplayWriteFormat(pixc, 2, IFF_JFIF_JPEG);
/* Smooth the bg with a convolution. */
pixsm = pixBlockconv(pixc, 15, 15);
pixDisplayWriteFormat(pixsm, 2, IFF_JFIF_JPEG);
pixDestroy(&pixc);
/* Normalize for uneven illumination on gray image. */
pixBackgroundNormGrayArrayMorph(pixsg, NULL, 4, 5, 200, &pixg);
pixc = pixApplyInvBackgroundGrayMap(pixsg, pixg, 4, 4);
pixDisplayWriteFormat(pixc, 2, IFF_JFIF_JPEG);
pixDestroy(&pixg);
/* Increase the dynamic range. */
pixd = pixGammaTRC(NULL, pixc, 1.0, 30, 180);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixc);
/* Threshold to 1 bpp. */
pixb = pixThresholdToBinary(pixd, 120);
pixDisplayWriteFormat(pixb, 2, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixb);
/* Generate the output image */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 350, 4, 0, 25, 2);
pixWrite("/tmp/adapt.jpg", pixd, IFF_JFIF_JPEG);
pixDisplayWithTitle(pixd, 100, 100, NULL, 1);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixsg);
return 0;
}