/*!
* pixDisplayWriteFormat()
*
* Input: pix (1, 2, 4, 8, 16, 32 bpp)
* reduction (-1 to reset/erase; 0 to disable;
* otherwise this is a reduction factor)
* format (IFF_PNG or IFF_JFIF_JPEG)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) This writes files if reduction > 0. These can be displayed using
* pixDisplayMultiple("/tmp/junk_write_display*");
* (2) All previously written files can be erased by calling with
* reduction < 0; the value of pixs is ignored.
* (3) If reduction > 1 and depth == 1, this does a scale-to-gray
* reduction.
* (4) This function uses a static internal variable to number
* output files written by a single process. Behavior
* with a shared library may be unpredictable.
* (5) Output file format is as follows:
* format == IFF_JFIF_JPEG:
* png if d < 8 or d == 16 or if the output pix
* has a colormap. Otherwise, output is jpg.
* format == IFF_PNG:
* png (lossless) on all images.
* (6) For 16 bpp, the choice of full dynamic range with log scale
* is the best for displaying these images. Alternative outputs are
* pix8 = pixMaxDynamicRange(pixt, L_LINEAR_SCALE);
* pix8 = pixConvert16To8(pixt, 0); // low order byte
* pix8 = pixConvert16To8(pixt, 1); // high order byte
*/
l_int32
pixDisplayWriteFormat(PIX *pixs,
l_int32 reduction,
l_int32 format)
{
char buffer[L_BUF_SIZE];
l_float32 scale;
PIX *pixt, *pix8;
static l_int32 index = 0; /* caution: not .so or thread safe */
PROCNAME("pixDisplayWriteFormat");
if (reduction == 0) return 0;
if (reduction < 0) {
index = 0; /* reset; this will cause erasure at next call to write */
return 0;
}
if (format != IFF_JFIF_JPEG && format != IFF_PNG)
return ERROR_INT("invalid format", procName, 1);
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (index == 0) {
snprintf(buffer, L_BUF_SIZE,
"rm -f /tmp/junk_write_display.*.png /tmp/junk_write_display.*.jpg");
system(buffer);
}
index++;
if (reduction == 1)
pixt = pixClone(pixs);
else {
scale = 1. / (l_float32)reduction;
if (pixGetDepth(pixs) == 1)
pixt = pixScaleToGray(pixs, scale);
else
pixt = pixScale(pixs, scale, scale);
}
if (pixGetDepth(pixt) == 16) {
pix8 = pixMaxDynamicRange(pixt, L_LOG_SCALE);
snprintf(buffer, L_BUF_SIZE, "/tmp/junk_write_display.%03d.png", index);
pixWrite(buffer, pix8, IFF_PNG);
pixDestroy(&pix8);
}
else if (pixGetDepth(pixt) < 8 || pixGetColormap(pixt) ||
format == IFF_PNG) {
snprintf(buffer, L_BUF_SIZE, "/tmp/junk_write_display.%03d.png", index);
pixWrite(buffer, pixt, IFF_PNG);
}
else {
snprintf(buffer, L_BUF_SIZE, "/tmp/junk_write_display.%03d.jpg", index);
pixWrite(buffer, pixt, format);
}
pixDestroy(&pixt);
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);
}
/*!
* \brief pixDisplayWriteFormat()
*
* \param[in] pix 1, 2, 4, 8, 16, 32 bpp
* \param[in] reduction -1 to erase and reset; 0 to disable;
* otherwise this is a reduction factor
* \param[in] format IFF_DEFAULT or IFF_PNG
* \return 0 if OK; 1 on error
*
* <pre>
* Notes:
* (1) This writes files with pathnames "/tmp/lept/display/file.*"
* if reduction \> 0. These can be collected into a pdf using
* pixDisplayMultiple();
* (2) Before writing a set of files, call
* pixDisplayWrite(NULL, -1);
* This erases any previously written files in that directory.
* (3) If reduction \> 1 and depth == 1, this does a scale-to-gray
* reduction.
* (4) This function uses a static internal variable to number
* output files written by a single process. Behavior
* with a shared library may be unpredictable.
* (5) Output file format is as follows:
* format == IFF_DEFAULT:
* png if d \< 8 or d == 16 or if the output pix
* has a colormap. Otherwise, output is jpg.
* format == IFF_PNG:
* png (lossless) on all images.
* (6) For 16 bpp, the choice of full dynamic range with log scale
* is the best for displaying these images. Alternative outputs are
* pix8 = pixMaxDynamicRange(pixt, L_LINEAR_SCALE);
* pix8 = pixConvert16To8(pixt, 0); // low order byte
* pix8 = pixConvert16To8(pixt, 1); // high order byte
* </pre>
*/
l_int32
pixDisplayWriteFormat(PIX *pixs,
l_int32 reduction,
l_int32 format)
{
char buf[L_BUF_SIZE];
char *fname;
l_float32 scale;
PIX *pix1, *pix2;
static l_int32 index = 0; /* caution: not .so or thread safe */
PROCNAME("pixDisplayWriteFormat");
if (reduction == 0) return 0;
if (reduction < 0) { /* initialize */
lept_rmdir("lept/display");
index = 0;
return 0;
}
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (format != IFF_DEFAULT && format != IFF_PNG) {
L_INFO("invalid format; using default\n", procName);
format = IFF_DEFAULT;
}
if (index == 0)
lept_mkdir("lept/display");
index++;
if (reduction == 1) {
pix1 = pixClone(pixs);
} else {
scale = 1. / (l_float32)reduction;
if (pixGetDepth(pixs) == 1)
pix1 = pixScaleToGray(pixs, scale);
else
pix1 = pixScale(pixs, scale, scale);
}
if (pixGetDepth(pix1) == 16) {
pix2 = pixMaxDynamicRange(pix1, L_LOG_SCALE);
snprintf(buf, L_BUF_SIZE, "file.%03d.png", index);
fname = genPathname("/tmp/lept/display", buf);
pixWrite(fname, pix2, IFF_PNG);
pixDestroy(&pix2);
} else if (pixGetDepth(pix1) < 8 || pixGetColormap(pix1) ||
format == IFF_PNG) {
snprintf(buf, L_BUF_SIZE, "file.%03d.png", index);
fname = genPathname("/tmp/lept/display", buf);
pixWrite(fname, pix1, IFF_PNG);
} else {
snprintf(buf, L_BUF_SIZE, "file.%03d.jpg", index);
fname = genPathname("/tmp/lept/display", buf);
pixWrite(fname, pix1, format);
}
LEPT_FREE(fname);
pixDestroy(&pix1);
return 0;
}
static void
TestDistance(PIXA *pixa,
PIX *pixs,
l_int32 conn,
l_int32 depth,
l_int32 bc,
l_int32 *pcount,
L_REGPARAMS *rp)
{
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5;
/* Test the distance function and display */
pixInvert(pixs, pixs);
pixt1 = pixDistanceFunction(pixs, conn, depth, bc);
regTestWritePixAndCheck(pixt1, IFF_PNG, pcount, rp);
pixSaveTiled(pixt1, pixa, 1, 1, 20, 0);
pixInvert(pixs, pixs);
pixt2 = pixMaxDynamicRange(pixt1, L_LOG_SCALE);
regTestWritePixAndCheck(pixt2, IFF_JFIF_JPEG, pcount, rp);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Test the distance function and display with contour rendering */
pixInvert(pixs, pixs);
pixt1 = pixDistanceFunction(pixs, conn, depth, bc);
regTestWritePixAndCheck(pixt1, IFF_PNG, pcount, rp);
pixSaveTiled(pixt1, pixa, 1, 1, 20, 0);
pixInvert(pixs, pixs);
pixt2 = pixRenderContours(pixt1, 2, 4, 1); /* binary output */
regTestWritePixAndCheck(pixt2, IFF_PNG, pcount, rp);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixt3 = pixRenderContours(pixt1, 2, 4, depth);
pixt4 = pixMaxDynamicRange(pixt3, L_LINEAR_SCALE);
regTestWritePixAndCheck(pixt4, IFF_JFIF_JPEG, pcount, rp);
pixSaveTiled(pixt4, pixa, 1, 0, 20, 0);
pixt5 = pixMaxDynamicRange(pixt3, L_LOG_SCALE);
regTestWritePixAndCheck(pixt5, IFF_JFIF_JPEG, pcount, rp);
pixSaveTiled(pixt5, pixa, 1, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
/* Label all pixels in each c.c. with a color equal to the
* max distance of any pixel within that c.c. from the bg.
* Note that we've normalized so the dynamic range extends
* to 255. For the image here, each unit of distance is
* represented by about 21 grayscale units. The largest
* distance is 12. */
if (depth == 8) {
pixt1 = pixDistanceFunction(pixs, conn, depth, bc);
pixt4 = pixMaxDynamicRange(pixt1, L_LOG_SCALE);
regTestWritePixAndCheck(pixt4, IFF_JFIF_JPEG, pcount, rp);
pixSaveTiled(pixt4, pixa, 1, 1, 20, 0);
pixt2 = pixCreateTemplate(pixt1);
pixSetMasked(pixt2, pixs, 255);
regTestWritePixAndCheck(pixt2, IFF_JFIF_JPEG, pcount, rp);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixSeedfillGray(pixt1, pixt2, 4);
pixt3 = pixMaxDynamicRange(pixt1, L_LINEAR_SCALE);
regTestWritePixAndCheck(pixt3, IFF_JFIF_JPEG, pcount, rp);
pixSaveTiled(pixt3, pixa, 1, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
}
return;
}
main(int argc,
char **argv)
{
l_int32 i, j, x, y, rval, gval, bval;
l_uint32 pixel;
l_float32 frval, fgval, fbval;
NUMA *nahue, *nasat, *napk;
PIX *pixs, *pixhsv, *pixh, *pixg, *pixf, *pixd;
PIX *pixr, *pixt1, *pixt2, *pixt3;
PIXA *pixa, *pixapk;
PTA *ptapk;
L_REGPARAMS *rp;
l_chooseDisplayProg(L_DISPLAY_WITH_XV);
if (regTestSetup(argc, argv, &rp))
return 1;
/* Make a graded frame color */
pixs = pixCreate(650, 900, 32);
for (i = 0; i < 900; i++) {
rval = 40 + i / 30;
for (j = 0; j < 650; j++) {
gval = 255 - j / 30;
bval = 70 + j / 30;
composeRGBPixel(rval, gval, bval, &pixel);
pixSetPixel(pixs, j, i, pixel);
}
}
/* Place an image inside the frame and convert to HSV */
pixt1 = pixRead("1555-3.jpg");
pixt2 = pixScale(pixt1, 0.5, 0.5);
pixRasterop(pixs, 100, 100, 2000, 2000, PIX_SRC, pixt2, 0, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDisplayWithTitle(pixs, 400, 0, "Input image", rp->display);
pixa = pixaCreate(0);
pixhsv = pixConvertRGBToHSV(NULL, pixs);
/* Work in the HS projection of HSV */
pixh = pixMakeHistoHS(pixhsv, 5, &nahue, &nasat);
pixg = pixMaxDynamicRange(pixh, L_LOG_SCALE);
pixf = pixConvertGrayToFalseColor(pixg, 1.0);
regTestWritePixAndCheck(rp, pixf, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixf, 100, 0, "False color HS histo", rp->display);
pixaAddPix(pixa, pixs, L_COPY);
pixaAddPix(pixa, pixhsv, L_INSERT);
pixaAddPix(pixa, pixg, L_INSERT);
pixaAddPix(pixa, pixf, L_INSERT);
gplotSimple1(nahue, GPLOT_PNG, "/tmp/junkhue", "Histogram of hue values");
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixt3 = pixRead("/tmp/junkhue.png");
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixt3, 100, 300, "Histo of hue", rp->display);
pixaAddPix(pixa, pixt3, L_INSERT);
gplotSimple1(nasat, GPLOT_PNG, "/tmp/junksat",
"Histogram of saturation values");
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixt3 = pixRead("/tmp/junksat.png");
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixt3, 100, 800, "Histo of saturation", rp->display);
pixaAddPix(pixa, pixt3, L_INSERT);
pixd = pixaDisplayTiledAndScaled(pixa, 32, 270, 7, 0, 30, 3);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixd, 0, 400, "Hue and Saturation Mosaic", rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
numaDestroy(&nahue);
numaDestroy(&nasat);
/* Find all the peaks */
pixFindHistoPeaksHSV(pixh, L_HS_HISTO, 20, 20, 6, 2.0,
&ptapk, &napk, &pixapk);
numaWriteStream(stderr, napk);
ptaWriteStream(stderr, ptapk, 1);
pixd = pixaDisplayTiledInRows(pixapk, 32, 1400, 1.0, 0, 30, 2);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixd, 0, 550, "Peaks in HS", rp->display);
pixDestroy(&pixh);
pixDestroy(&pixd);
pixaDestroy(&pixapk);
/* Make masks for each of the peaks */
pixa = pixaCreate(0);
pixr = pixScaleBySampling(pixs, 0.4, 0.4);
for (i = 0; i < 6; i++) {
ptaGetIPt(ptapk, i, &x, &y);
pixt1 = pixMakeRangeMaskHS(pixr, y, 20, x, 20, L_INCLUDE_REGION);
pixaAddPix(pixa, pixt1, L_INSERT);
pixGetAverageMaskedRGB(pixr, pixt1, 0, 0, 1, L_MEAN_ABSVAL,
&frval, &fgval, &fbval);
composeRGBPixel((l_int32)frval, (l_int32)fgval, (l_int32)fbval,
&pixel);
pixt2 = pixCreateTemplate(pixr);
pixSetAll(pixt2);
pixPaintThroughMask(pixt2, pixt1, 0, 0, pixel);
pixaAddPix(pixa, pixt2, L_INSERT);
pixt3 = pixCreateTemplate(pixr);
pixSetAllArbitrary(pixt3, pixel);
pixaAddPix(pixa, pixt3, L_INSERT);
}
pixd = pixaDisplayTiledAndScaled(pixa, 32, 225, 3, 0, 30, 3);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixd, 600, 0, "Masks over peaks", rp->display);
pixDestroy(&pixs);
pixDestroy(&pixr);
pixDestroy(&pixd);
pixaDestroy(&pixa);
ptaDestroy(&ptapk);
numaDestroy(&napk);
regTestCleanup(rp);
return 0;
}