/*!
* pixaWriteStream()
*
* Input: stream
* pixa
* Return: 0 if OK, 1 on error
*/
l_int32
pixaWriteStream(FILE *fp,
PIXA *pixa)
{
l_int32 n, i;
PIX *pix;
PROCNAME("pixaWriteStream");
#if !HAVE_LIBPNG /* defined in environ.h */
return ERROR_INT("no libpng: can't write data", procName, 1);
#else
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!pixa)
return ERROR_INT("pixa not defined", procName, 1);
n = pixaGetCount(pixa);
fprintf(fp, "\nPixa Version %d\n", PIXA_VERSION_NUMBER);
fprintf(fp, "Number of pix = %d\n", n);
boxaWriteStream(fp, pixa->boxa);
for (i = 0; i < n; i++) {
if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL)
return ERROR_INT("pix not found", procName, 1);
fprintf(fp, " pix[%d]: xres = %d, yres = %d\n",
i, pix->xres, pix->yres);
pixWriteStreamPng(fp, pix, 0.0);
pixDestroy(&pix);
}
return 0;
#endif /* !HAVE_LIBPNG */
}
/*!
* pixaaWriteStream()
*
* Input: stream
* pixaa
* Return: 0 if OK, 1 on error
*/
l_int32
pixaaWriteStream(FILE *fp,
PIXAA *pixaa)
{
l_int32 n, i;
PIXA *pixa;
PROCNAME("pixaaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!pixaa)
return ERROR_INT("pixaa not defined", procName, 1);
n = pixaaGetCount(pixaa);
fprintf(fp, "\nPixaa Version %d\n", PIXAA_VERSION_NUMBER);
fprintf(fp, "Number of pixa = %d\n", n);
boxaWriteStream(fp, pixaa->boxa);
for (i = 0; i < n; i++) {
if ((pixa = pixaaGetPixa(pixaa, i, L_CLONE)) == NULL)
return ERROR_INT("pixa not found", procName, 1);
fprintf(fp, "\n\n --------------- pixa[%d] ---------------\n", i);
pixaWriteStream(fp, pixa);
pixaDestroy(&pixa);
}
return 0;
}
/*!
* boxaaWriteStream()
*
* Input: stream
* boxaa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaaWriteStream(FILE *fp,
BOXAA *baa)
{
l_int32 n, i, x, y, w, h;
BOX *box;
BOXA *boxa;
PROCNAME("boxaaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
n = boxaaGetCount(baa);
fprintf(fp, "\nBoxaa Version %d\n", BOXAA_VERSION_NUMBER);
fprintf(fp, "Number of boxa = %d\n", n);
for (i = 0; i < n; i++) {
if ((boxa = boxaaGetBoxa(baa, i, L_CLONE)) == NULL)
return ERROR_INT("boxa not found", procName, 1);
boxaGetExtent(boxa, NULL, NULL, &box);
boxGetGeometry(box, &x, &y, &w, &h);
fprintf(fp, "\nBoxa[%d] extent: x = %d, y = %d, w = %d, h = %d",
i, x, y, w, h);
boxaWriteStream(fp, boxa);
boxDestroy(&box);
boxaDestroy(&boxa);
}
return 0;
}
/*!
* boxaWrite()
*
* Input: filename
* boxa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaWrite(const char *filename,
BOXA *boxa)
{
FILE *fp;
PROCNAME("boxaWrite");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if ((fp = fopen(filename, "w")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
if (boxaWriteStream(fp, boxa))
return ERROR_INT("boxa not written to stream", procName, 1);
fclose(fp);
return 0;
}
int main(int argc,
char **argv)
{
l_uint8 *array1, *array2;
l_int32 n1, n2, n3;
size_t size1, size2;
FILE *fp;
BOXA *boxa1, *boxa2;
PIX *pixs, *pix1;
PIXA *pixa1;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn.tif");
/* --------------------------------------------------------------- *
* Test pixConnComp() and pixCountConnComp(), *
* with output to both boxa and pixa *
* --------------------------------------------------------------- */
/* First, test with 4-cc */
boxa1= pixConnComp(pixs, &pixa1, 4);
n1 = boxaGetCount(boxa1);
boxa2= pixConnComp(pixs, NULL, 4);
n2 = boxaGetCount(boxa2);
pixCountConnComp(pixs, 4, &n3);
fprintf(stderr, "Number of 4 c.c.: n1 = %d; n2 = %d, n3 = %d\n",
n1, n2, n3);
regTestCompareValues(rp, n1, n2, 0); /* 0 */
regTestCompareValues(rp, n1, n3, 0); /* 1 */
regTestCompareValues(rp, n1, 4452, 0); /* 2 */
pix1 = pixaDisplay(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 3 */
regTestComparePix(rp, pixs, pix1); /* 4 */
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixDestroy(&pix1);
/* Test with 8-cc */
boxa1= pixConnComp(pixs, &pixa1, 8);
n1 = boxaGetCount(boxa1);
boxa2= pixConnComp(pixs, NULL, 8);
n2 = boxaGetCount(boxa2);
pixCountConnComp(pixs, 8, &n3);
fprintf(stderr, "Number of 8 c.c.: n1 = %d; n2 = %d, n3 = %d\n",
n1, n2, n3);
regTestCompareValues(rp, n1, n2, 0); /* 5 */
regTestCompareValues(rp, n1, n3, 0); /* 6 */
regTestCompareValues(rp, n1, 4305, 0); /* 7 */
pix1 = pixaDisplay(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8 */
regTestComparePix(rp, pixs, pix1); /* 9 */
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixDestroy(&pix1);
/* --------------------------------------------------------------- *
* Test boxa I/O *
* --------------------------------------------------------------- */
lept_mkdir("lept/conn");
boxa1 = pixConnComp(pixs, NULL, 4);
fp = lept_fopen("/tmp/lept/conn/boxa1.ba", "wb+");
boxaWriteStream(fp, boxa1);
lept_fclose(fp);
fp = lept_fopen("/tmp/lept/conn/boxa1.ba", "rb");
boxa2 = boxaReadStream(fp);
lept_fclose(fp);
fp = lept_fopen("/tmp/lept/conn/boxa2.ba", "wb+");
boxaWriteStream(fp, boxa2);
lept_fclose(fp);
array1 = l_binaryRead("/tmp/lept/conn/boxa1.ba", &size1);
array2 = l_binaryRead("/tmp/lept/conn/boxa2.ba", &size2);
regTestCompareStrings(rp, array1, size1, array2, size2); /* 10 */
lept_free(array1);
lept_free(array2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* --------------------------------------------------------------- *
* Just for fun, display each component as a random color in *
* cmapped 8 bpp. Background is color 0; it is set to white. *
* --------------------------------------------------------------- */
boxa1 = pixConnComp(pixs, &pixa1, 4);
pix1 = pixaDisplayRandomCmap(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
cmap = pixGetColormap(pix1);
pixcmapResetColor(cmap, 0, 255, 255, 255); /* reset background to white */
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 11 */
if (rp->display) pixDisplay(pix1, 100, 100);
boxaDestroy(&boxa1);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char *filename;
l_int32 w, h, type, maxboxes;
l_float32 ovlap;
BOX *box;
BOXA *boxa, *boxat, *boxad;
PIX *pix, *pixt, *pixs, *pixd;
static char mainName[] = "partitiontest";
if (argc != 3 && argc != 5)
return ERROR_INT("syntax: partitiontest <fname> type [maxboxes ovlap]",
mainName, 1);
filename = argv[1];
type = atoi(argv[2]);
if (type == L_SORT_BY_WIDTH)
fprintf(stderr, "Sorting by width:\n");
else if (type == L_SORT_BY_HEIGHT)
fprintf(stderr, "Sorting by height:\n");
else if (type == L_SORT_BY_MAX_DIMENSION)
fprintf(stderr, "Sorting by maximum dimension:\n");
else if (type == L_SORT_BY_MIN_DIMENSION)
fprintf(stderr, "Sorting by minimum dimension:\n");
else if (type == L_SORT_BY_PERIMETER)
fprintf(stderr, "Sorting by perimeter:\n");
else if (type == L_SORT_BY_AREA)
fprintf(stderr, "Sorting by area:\n");
else {
fprintf(stderr, "Use one of the following for 'type':\n"
" 5: L_SORT_BY_WIDTH\n"
" 6: L_SORT_BY_HEIGHT\n"
" 7: L_SORT_BY_MIN_DIMENSION\n"
" 8: L_SORT_BY_MAX_DIMENSION\n"
" 9: L_SORT_BY_PERIMETER\n"
" 10: L_SORT_BY_AREA\n");
return ERROR_INT("invalid type: see source", mainName, 1);
}
if (argc == 5) {
maxboxes = atoi(argv[3]);
ovlap = atof(argv[4]);
} else {
maxboxes = 100;
ovlap = 0.2;
}
pix = pixRead(filename);
pixs = pixConvertTo1(pix, 128);
pixDilateBrick(pixs, pixs, 5, 5);
boxa = pixConnComp(pixs, NULL, 4);
pixGetDimensions(pixs, &w, &h, NULL);
box = boxCreate(0, 0, w, h);
startTimer();
boxaPermuteRandom(boxa, boxa);
boxat = boxaSelectBySize(boxa, 500, 500, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
boxad = boxaGetWhiteblocks(boxat, box, type, maxboxes, ovlap,
200, 0.15, 20000);
fprintf(stderr, "Time: %7.3f sec\n", stopTimer());
boxaWriteStream(stderr, boxad);
pixDisplayWrite(NULL, -1);
pixDisplayWrite(pixs, REDUCTION);
/* Display box outlines in a single color in a cmapped image */
pixd = pixDrawBoxa(pixs, boxad, 7, 0xe0708000);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixd);
/* Display box outlines in a single color in an RGB image */
pixt = pixConvertTo8(pixs, FALSE);
pixd = pixDrawBoxa(pixt, boxad, 7, 0x40a0c000);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Display box outlines with random colors in a cmapped image */
pixd = pixDrawBoxaRandom(pixs, boxad, 7);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixd);
/* Display box outlines with random colors in an RGB image */
pixt = pixConvertTo8(pixs, FALSE);
pixd = pixDrawBoxaRandom(pixt, boxad, 7);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Display boxes in the same color in a cmapped image */
pixd = pixPaintBoxa(pixs, boxad, 0x60e0a000);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixd);
/* Display boxes in the same color in an RGB image */
pixt = pixConvertTo8(pixs, FALSE);
pixd = pixPaintBoxa(pixt, boxad, 0xc030a000);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Display boxes in random colors in a cmapped image */
pixd = pixPaintBoxaRandom(pixs, boxad);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixd);
/* Display boxes in random colors in an RGB image */
pixt = pixConvertTo8(pixs, FALSE);
pixd = pixPaintBoxaRandom(pixt, boxad);
pixDisplayWrite(pixd, REDUCTION);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixDisplayMultiple("/tmp/junk_write_display*");
pixDestroy(&pix);
pixDestroy(&pixs);
boxDestroy(&box);
boxaDestroy(&boxa);
boxaDestroy(&boxat);
boxaDestroy(&boxad);
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout, *patternfile;
l_int32 w, h, i, n;
BOX *box, *boxe;
BOXA *boxa1, *boxa2;
PIX *pixs, *pixp, *pixpe;
PIX *pixd, *pixt1, *pixt2, *pixhmt;
SEL *sel_2h, *sel;
static char mainName[] = "findpattern1";
if (argc != 4)
exit(ERROR_INT(" Syntax: findpattern1 filein patternfile fileout",
mainName, 1));
filein = argv[1];
patternfile = argv[2];
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
if ((pixp = pixRead(patternfile)) == NULL)
exit(ERROR_INT("pixp not made", mainName, 1));
pixGetDimensions(pixp, &w, &h, NULL);
/* generate the hit-miss Sel with runs */
sel = pixGenerateSelWithRuns(pixp, NumHorLines, NumVertLines, 0,
MinRunlength, 7, 7, 0, 0, &pixpe);
/* display the Sel two ways */
selWriteStream(stderr, sel);
pixt1 = pixDisplayHitMissSel(pixpe, sel, 9, HitColor, MissColor);
pixDisplay(pixt1, 200, 200);
pixWrite("/tmp/junkpixt", pixt1, IFF_PNG);
/* use the Sel to find all instances in the page */
startTimer();
pixhmt = pixHMT(NULL, pixs, sel);
fprintf(stderr, "Time to find patterns = %7.3f\n", stopTimer());
/* small erosion to remove noise; typically not necessary if
* there are enough elements in the Sel */
sel_2h = selCreateBrick(1, 2, 0, 0, SEL_HIT);
pixt2 = pixErode(NULL, pixhmt, sel_2h);
/* display the result visually by placing the Sel at each
* location found */
pixd = pixDilate(NULL, pixt2, sel);
pixWrite(fileout, pixd, IFF_TIFF_G4);
/* display outut with an outline around each located pattern */
boxa1 = pixConnCompBB(pixt2, 8);
n = boxaGetCount(boxa1);
boxa2 = boxaCreate(n);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa1, i, L_COPY);
boxe = boxCreate(box->x - w / 2, box->y - h / 2, w + 4, h + 4);
boxaAddBox(boxa2, boxe, L_INSERT);
pixRenderBox(pixs, boxe, 4, L_FLIP_PIXELS);
boxDestroy(&box);
}
pixWrite("/tmp/junkoutline", pixs, IFF_TIFF_G4);
boxaWriteStream(stderr, boxa2);
pixDestroy(&pixs);
pixDestroy(&pixp);
pixDestroy(&pixpe);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixhmt);
pixDestroy(&pixd);
selDestroy(&sel);
selDestroy(&sel_2h);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
return 0;
}
main(int argc,
char **argv)
{
l_uint8 *array1, *array2;
l_int32 i, n, np, same, diff, nbytes1, nbytes2;
FILE *fp;
BOX *box;
BOXA *boxa, *boxa2;
PIX *pixs, *pixd;
PIXA *pixa;
PIXCMAP *cmap;
static char mainName[] = "conncomp_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: conncomp_reg", mainName, 1));
if ((pixs = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
/* Test pixConnComp() with output to both boxa and pixa */
/* First, test with 4-cc */
boxa = pixConnComp(pixs, &pixa, 4);
n = boxaGetCount(boxa);
fprintf(stderr, "Number of 4 c.c. b.b: %d\n", n);
np = pixaGetCount(pixa);
fprintf(stderr, "Number of 4 c.c. pix: %d\n", np);
pixd = pixaDisplay(pixa, pixGetWidth(pixs), pixGetHeight(pixs));
pixWrite("/tmp/junkout1.png", pixd, IFF_PNG);
pixEqual(pixs, pixd, &same);
if (same == 1)
fprintf(stderr, "Source and reconstructed pix are the same.\n");
else
fprintf(stderr, "Error: source and reconstructed pix differ!\n");
pixaDestroy(&pixa);
boxaDestroy(&boxa);
pixDestroy(&pixd);
/* Test with 8-cc */
boxa = pixConnComp(pixs, &pixa, 8);
n = boxaGetCount(boxa);
fprintf(stderr, "Number of 8 c.c. b.b: %d\n", n);
np = pixaGetCount(pixa);
fprintf(stderr, "Number of 8 c.c. pix: %d\n", np);
pixd = pixaDisplay(pixa, pixGetWidth(pixs), pixGetHeight(pixs));
pixWrite("/tmp/junkout2.png", pixd, IFF_PNG);
pixEqual(pixs, pixd, &same);
if (same == 1)
fprintf(stderr, "Source and reconstructed pix are the same.\n");
else
fprintf(stderr, "Error: source and reconstructed pix differ!\n");
pixaDestroy(&pixa);
boxaDestroy(&boxa);
pixDestroy(&pixd);
/* Test i/o */
boxa = pixConnComp(pixs, NULL, 4);
fp = fopen("/tmp/junk1.ba", "wb+");
boxaWriteStream(fp, boxa);
fclose(fp);
fp = fopen("/tmp/junk1.ba", "r");
boxa2 = boxaReadStream(fp);
fclose(fp);
fp = fopen("/tmp/junk2.ba", "wb+");
boxaWriteStream(fp, boxa2);
fclose(fp);
array1 = arrayRead("/tmp/junk1.ba", &nbytes1);
array2 = arrayRead("/tmp/junk2.ba", &nbytes2);
diff = strcmp((char *)array1, (char *)array2);
if (nbytes1 != nbytes2 || diff)
fprintf(stderr, "I/O error for boxes.\n");
else
fprintf(stderr, "I/O valid for boxes.\n");
FREE(array1);
FREE(array2);
boxaDestroy(&boxa);
boxaDestroy(&boxa2);
/* Just for fun, display each component as a random color
* in cmapped 8 bpp. Background is color 0; it is set to white. */
boxa = pixConnComp(pixs, &pixa, 4);
pixd = pixaDisplayRandomCmap(pixa, pixGetWidth(pixs), pixGetHeight(pixs));
cmap = pixGetColormap(pixd);
pixcmapResetColor(cmap, 0, 255, 255, 255); /* reset background to white */
pixDisplay(pixd, 100, 100);
boxaDestroy(&boxa);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
exit(0);
}
