void
PixTestEqual(PIX *pixs1,
PIX *pixs2,
PIX *pixm,
l_int32 set,
l_int32 connectivity)
{
l_int32 same;
PIX *pixc11, *pixc12, *pixc21, *pixc22, *pixmi;
pixmi = pixInvert(NULL, pixm);
pixc11 = pixCopy(NULL, pixs1);
pixc12 = pixCopy(NULL, pixs1);
pixc21 = pixCopy(NULL, pixs2);
pixc22 = pixCopy(NULL, pixs2);
/* Test inverse seed filling */
pixSeedfillGrayInv(pixc11, pixm, connectivity);
pixSeedfillGrayInvSimple(pixc12, pixm, connectivity);
pixEqual(pixc11, pixc12, &same);
if (same)
fprintf(stderr, "\nSuccess for inv set %d\n", set);
else
fprintf(stderr, "\nFailure for inv set %d\n", set);
/* Test seed filling */
pixSeedfillGray(pixc21, pixm, connectivity);
pixSeedfillGraySimple(pixc22, pixm, connectivity);
pixEqual(pixc21, pixc22, &same);
if (same)
fprintf(stderr, "Success for set %d\n", set);
else
fprintf(stderr, "Failure for set %d\n", set);
/* Display the filling results */
/* pixDisplay(pixc11, 220 * (set - 1), 100);
pixDisplay(pixc21, 220 * (set - 1), 320); */
pixDestroy(&pixmi);
pixDestroy(&pixc11);
pixDestroy(&pixc12);
pixDestroy(&pixc21);
pixDestroy(&pixc22);
return;
}
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;
}
int main(int argc,
char **argv) {
char *filein, *fileout;
l_int32 i;
l_uint32 val;
l_float32 size;
PIX *pixs, *pixd, *pixm, *pixmi, *pixt1, *pixt2, *pixt3;
static char mainName[] = "seedfilltest";
if (argc != 3)
return ERROR_INT(" Syntax: seedfilltest filein fileout", mainName, 1);
filein = argv[1];
fileout = argv[2];
pixd = NULL;
if ((pixm = pixRead(filein)) == NULL)
return ERROR_INT("pixm not made", mainName, 1);
pixmi = pixInvert(NULL, pixm);
size = pixGetWidth(pixm) * pixGetHeight(pixm);
pixs = pixCreateTemplate(pixm);
for (i = 0; i < 100; i++) {
pixGetPixel(pixm, XS + 5 * i, YS + 5 * i, &val);
if (val == 0) break;
}
if (i == 100)
return ERROR_INT("no seed pixel found", mainName, 1);
pixSetPixel(pixs, XS + 5 * i, YS + 5 * i, 1);
#if 0
/* hole filling; use "hole-filler.png" */
pixt1 = pixHDome(pixmi, 100, 4);
pixt2 = pixThresholdToBinary(pixt1, 10);
/* pixInvert(pixt1, pixt1); */
pixDisplay(pixt1, 100, 500);
pixDisplay(pixt2, 600, 500);
pixt3 = pixHolesByFilling(pixt2, 4);
pixDilateBrick(pixt3, pixt3, 7, 7);
pixd = pixConvertTo8(pixt3, FALSE);
pixDisplay(pixd, 0, 100);
pixSeedfillGray(pixd, pixmi, CONNECTIVITY);
pixInvert(pixd, pixd);
pixDisplay(pixmi, 500, 100);
pixDisplay(pixd, 1000, 100);
pixWrite("/tmp/junkpixm.png", pixmi, IFF_PNG);
pixWrite("/tmp/junkpixd.png", pixd, IFF_PNG);
#endif
#if 0
/* hole filling; use "hole-filler.png" */
pixt1 = pixThresholdToBinary(pixm, 110);
pixInvert(pixt1, pixt1);
pixDisplay(pixt1, 100, 500);
pixt2 = pixHolesByFilling(pixt1, 4);
pixd = pixConvertTo8(pixt2, FALSE);
pixDisplay(pixd, 0, 100);
pixSeedfillGray(pixd, pixmi, CONNECTIVITY);
pixInvert(pixd, pixd);
pixDisplay(pixmi, 500, 100);
pixDisplay(pixd, 1000, 100);
pixWrite("/tmp/junkpixm.png", pixmi, IFF_PNG);
pixWrite("/tmp/junkpixd.png", pixd, IFF_PNG);
#endif
#if 0
/* hole filling; use "hole-filler.png" */
pixd = pixInvert(NULL, pixm);
pixAddConstantGray(pixd, -50);
pixDisplay(pixd, 0, 100);
/* pixt1 = pixThresholdToBinary(pixd, 20);
pixDisplayWithTitle(pixt1, 600, 600, "pixt1", DFLAG); */
pixSeedfillGray(pixd, pixmi, CONNECTIVITY);
/* pixInvert(pixd, pixd); */
pixDisplay(pixmi, 500, 100);
pixDisplay(pixd, 1000, 100);
pixWrite("/tmp/junkpixm.png", pixmi, IFF_PNG);
pixWrite("/tmp/junkpixd.png", pixd, IFF_PNG);
#endif
#if 0
/* test in-place seedfill for speed */
pixd = pixClone(pixs);
startTimer();
pixSeedfillBinary(pixs, pixs, pixmi, CONNECTIVITY);
fprintf(stderr, "Filling rate: %7.4f Mpix/sec\n",
(size/1000000.) / stopTimer());
pixWrite(fileout, pixd, IFF_PNG);
pixOr(pixd, pixd, pixm);
pixWrite("/tmp/junkout1.png", pixd, IFF_PNG);
#endif
#if 0
/* test seedfill to dest for speed */
pixd = pixCreateTemplate(pixm);
startTimer();
for (i = 0; i < NTIMES; i++) {
pixSeedfillBinary(pixd, pixs, pixmi, CONNECTIVITY);
}
fprintf(stderr, "Filling rate: %7.4f Mpix/sec\n",
(size/1000000.) * NTIMES / stopTimer());
pixWrite(fileout, pixd, IFF_PNG);
pixOr(pixd, pixd, pixm);
pixWrite("/tmp/junkout1.png", pixd, IFF_PNG);
#endif
/* use same connectivity to compare with the result of the
* slow parallel operation */
#if 1
pixDestroy(&pixd);
pixd = pixSeedfillMorph(pixs, pixmi, 100, CONNECTIVITY);
pixOr(pixd, pixd, pixm);
pixWrite("/tmp/junkout2.png", pixd, IFF_PNG);
#endif
pixDestroy(&pixs);
pixDestroy(&pixm);
pixDestroy(&pixmi);
pixDestroy(&pixd);
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, j, same;
PIX *pixm, *pixmi, *pixs1, *pixs1_8;
PIX *pixs2, *pixs2_8, *pixs3, *pixs3_8;
PIX *pixb1, *pixb2, *pixb3, *pixmin, *pixd;
PIXA *pixac;
static char mainName[] = "grayfill_reg";
pixDisplayWrite(NULL, -1);
pixac = pixaCreate(0);
/* Mask */
pixm = pixCreate(200, 200, 8);
for (i = 0; i < 200; i++)
for (j = 0; j < 200; j++)
pixSetPixel(pixm, j, i, 20 + L_ABS((100 - i) * (100 - j)) / 50);
pixmi = pixInvert(NULL, pixm);
/* Seed1 */
pixs1 = pixCreate(200, 200, 8);
for (i = 99; i <= 101; i++)
for (j = 99; j <= 101; j++)
pixSetPixel(pixs1, j, i, 50 - i/100 - j/100);
pixs1_8 = pixCopy(NULL, pixs1);
/* Seed2 */
pixs2 = pixCreate(200, 200, 8);
for (i = 99; i <= 101; i++)
for (j = 99; j <= 101; j++)
pixSetPixel(pixs2, j, i, 205 - i/100 - j/100);
pixs2_8 = pixCopy(NULL, pixs2);
/* Inverse grayscale fill */
pixSaveTiled(pixm, pixac, 1, 1, 10, 8);
pixSaveTiled(pixs1, pixac, 1, 0, 10, 0);
pixSeedfillGrayInv(pixs1, pixm, 4);
pixSeedfillGrayInv(pixs1_8, pixm, 8);
pixSaveTiled(pixs1, pixac, 1, 0, 10, 0);
pixSaveTiled(pixs1_8, pixac, 1, 0, 10, 0);
pixb1 = pixThresholdToBinary(pixs1, 20);
pixSaveTiled(pixb1, pixac, 1, 0, 10, 0);
pixCombineMasked(pixs1, pixm, pixb1);
pixSaveTiled(pixs1, pixac, 1, 0, 10, 0);
pixDestroy(&pixs1);
pixDestroy(&pixs1_8);
pixDestroy(&pixb1);
/* Standard grayscale fill */
pixSaveTiled(pixmi, pixac, 1, 1, 10, 0);
pixSaveTiled(pixs2, pixac, 1, 0, 10, 0);
pixSeedfillGray(pixs2, pixmi, 4);
pixSeedfillGray(pixs2_8, pixmi, 8);
pixSaveTiled(pixs2, pixac, 1, 0, 10, 0);
pixSaveTiled(pixs2_8, pixac, 1, 0, 10, 0);
pixb2 = pixThresholdToBinary(pixs2, 205);
pixSaveTiled(pixb2, pixac, 1, 0, 10, 0);
pixDestroy(&pixs2);
pixDestroy(&pixs2_8);
pixDestroy(&pixb2);
/* Basin fill from minima as seed */
pixSaveTiled(pixm, pixac, 1, 1, 10, 8);
pixLocalExtrema(pixm, 0, 0, &pixmin, NULL);
pixSaveTiled(pixmin, pixac, 1, 0, 10, 0);
pixs3 = pixSeedfillGrayBasin(pixmin, pixm, 30, 4);
pixs3_8 = pixSeedfillGrayBasin(pixmin, pixm, 30, 8);
pixSaveTiled(pixs3, pixac, 1, 0, 10, 0);
pixSaveTiled(pixs3_8, pixac, 1, 0, 10, 0);
pixb3 = pixThresholdToBinary(pixs3, 60);
pixSaveTiled(pixb3, pixac, 1, 0, 10, 0);
pixDestroy(&pixs3);
pixDestroy(&pixs3_8);
pixDestroy(&pixb3);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/junkfill.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
/* Compare hybrid and iterative gray seedfills */
pixs1 = pixCopy(NULL, pixm);
pixs2 = pixCopy(NULL, pixm);
pixAddConstantGray(pixs1, -30);
pixAddConstantGray(pixs2, 60);
PixTestEqual(pixs1, pixs2, pixm, 1, 4);
PixTestEqual(pixs1, pixs2, pixm, 2, 8);
PixTestEqual(pixs2, pixs1, pixm, 3, 4);
PixTestEqual(pixs2, pixs1, pixm, 4, 8);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixm);
pixDestroy(&pixmi);
pixDestroy(&pixmin);
return 0;
}
