/*!
* pixGenTextblockMask()
*
* Input: pixs (1 bpp, textline mask, assumed to be 150 to 200 ppi)
* pixvws (vertical white space mask)
* debug (flag: 1 for debug output)
* Return: pixd (textblock mask), or null on error
*
* Notes:
* (1) Both the input masks (textline and vertical white space) and
* the returned textblock mask are at the same resolution.
* (2) The result is somewhat noisy, in that small "blocks" of
* text may be included. These can be removed by post-processing,
* using, e.g.,
* pixSelectBySize(pix, 60, 60, 4, L_SELECT_IF_EITHER,
* L_SELECT_IF_GTE, NULL);
*/
PIX *
pixGenTextblockMask(PIX *pixs,
PIX *pixvws,
l_int32 debug)
{
PIX *pixt1, *pixt2, *pixt3, *pixd;
PROCNAME("pixGenTextblockMask");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (!pixvws)
return (PIX *)ERROR_PTR("pixvws not defined", procName, NULL);
if (pixGetDepth(pixs) != 1)
return (PIX *)ERROR_PTR("pixs not 1 bpp", procName, NULL);
/* Join pixels vertically to make a textblock mask */
pixt1 = pixMorphSequence(pixs, "c1.10 + o4.1", 0);
pixDisplayWriteFormat(pixt1, debug, IFF_PNG);
/* Solidify the textblock mask and remove noise:
* (1) For each cc, close the blocks and dilate slightly
* to form a solid mask.
* (2) Small horizontal closing between components.
* (3) Open the white space between columns, again.
* (4) Remove small components. */
pixt2 = pixMorphSequenceByComponent(pixt1, "c30.30 + d3.3", 8, 0, 0, NULL);
pixCloseSafeBrick(pixt2, pixt2, 10, 1);
pixDisplayWriteFormat(pixt2, debug, IFF_PNG);
pixt3 = pixSubtract(NULL, pixt2, pixvws);
pixDisplayWriteFormat(pixt3, debug, IFF_PNG);
pixd = pixSelectBySize(pixt3, 25, 5, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GTE, NULL);
pixDisplayWriteFormat(pixd, debug, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
return pixd;
}
int main(int argc,
char **argv)
{
l_int32 size, i, n, n0;
BOXA *boxa;
GPLOT *gplot;
NUMA *nax, *nay1, *nay2;
PIX *pixs, *pixd;
static char mainName[] = "pixa1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: pixa1_reg", mainName, 1);
if ((pixs = pixRead("feyn.tif")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
/* ---------------- Remove small components --------------- */
boxa = pixConnComp(pixs, NULL, 8);
n0 = boxaGetCount(boxa);
nax = numaMakeSequence(0, 2, 51);
nay1 = numaCreate(51);
nay2 = numaCreate(51);
boxaDestroy(&boxa);
fprintf(stderr, "\n Select Large if Both\n");
fprintf(stderr, "Iter 0: n = %d\n", n0);
numaAddNumber(nay1, n0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_BOTH, L_SELECT_IF_GTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay1, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
fprintf(stderr, "\n Select Large if Either\n");
fprintf(stderr, "Iter 0: n = %d\n", n0);
numaAddNumber(nay2, n0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_EITHER, L_SELECT_IF_GTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay2, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
gplot = gplotCreate("/tmp/junkroot1", GPLOT_X11,
"Select large: number of cc vs size removed",
"min size", "number of c.c.");
gplotAddPlot(gplot, nax, nay1, GPLOT_LINES, "select if both");
gplotAddPlot(gplot, nax, nay2, GPLOT_LINES, "select if either");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
/* ---------------- Remove large components --------------- */
numaEmpty(nay1);
numaEmpty(nay2);
fprintf(stderr, "\n Select Small if Both\n");
fprintf(stderr, "Iter 0: n = %d\n", 0);
numaAddNumber(nay1, 0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_BOTH, L_SELECT_IF_LTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay1, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
fprintf(stderr, "\n Select Small if Either\n");
fprintf(stderr, "Iter 0: n = %d\n", 0);
numaAddNumber(nay2, 0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_EITHER, L_SELECT_IF_LTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay2, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
gplot = gplotCreate("/tmp/junkroot2", GPLOT_X11,
"Remove large: number of cc vs size removed",
"min size", "number of c.c.");
gplotAddPlot(gplot, nax, nay1, GPLOT_LINES, "select if both");
gplotAddPlot(gplot, nax, nay2, GPLOT_LINES, "select if either");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
numaDestroy(&nay1);
numaDestroy(&nay2);
pixDestroy(&pixs);
return 0;
}
l_int32
DoPageSegmentation(PIX *pixs, /* should be at least 300 ppi */
l_int32 which) /* 1, 2, 3, 4 */
{
char buf[256];
l_int32 zero;
BOXA *boxatm, *boxahm;
PIX *pixr; /* image reduced to 150 ppi */
PIX *pixhs; /* image of halftone seed, 150 ppi */
PIX *pixm; /* image of mask of components, 150 ppi */
PIX *pixhm1; /* image of halftone mask, 150 ppi */
PIX *pixhm2; /* image of halftone mask, 300 ppi */
PIX *pixht; /* image of halftone components, 150 ppi */
PIX *pixnht; /* image without halftone components, 150 ppi */
PIX *pixi; /* inverted image, 150 ppi */
PIX *pixvws; /* image of vertical whitespace, 150 ppi */
PIX *pixm1; /* image of closed textlines, 150 ppi */
PIX *pixm2; /* image of refined text line mask, 150 ppi */
PIX *pixm3; /* image of refined text line mask, 300 ppi */
PIX *pixb1; /* image of text block mask, 150 ppi */
PIX *pixb2; /* image of text block mask, 300 ppi */
PIX *pixnon; /* image of non-text or halftone, 150 ppi */
PIX *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
PIXCMAP *cmap;
PTAA *ptaa;
l_int32 ht_flag = 0;
l_int32 ws_flag = 0;
l_int32 text_flag = 0;
l_int32 block_flag = 0;
PROCNAME("DoPageSegmentation");
if (which == 1)
ht_flag = 1;
else if (which == 2)
ws_flag = 1;
else if (which == 3)
text_flag = 1;
else if (which == 4)
block_flag = 1;
else
return ERROR_INT("invalid parameter: not in [1...4]", procName, 1);
pixa = pixaCreate(0);
lept_mkdir("lept/livre");
/* Reduce to 150 ppi */
pix1 = pixScaleToGray2(pixs);
if (ws_flag || ht_flag || block_flag) pixaAddPix(pixa, pix1, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/orig.gray.150.png", pix1, IFF_PNG);
pixDestroy(&pix1);
pixr = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0);
/* Get seed for halftone parts */
pix1 = pixReduceRankBinaryCascade(pixr, 4, 4, 3, 0);
pix2 = pixOpenBrick(NULL, pix1, 5, 5);
pixhs = pixExpandBinaryPower2(pix2, 8);
if (ht_flag) pixaAddPix(pixa, pixhs, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/htseed.150.png", pixhs, IFF_PNG);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Get mask for connected regions */
pixm = pixCloseSafeBrick(NULL, pixr, 4, 4);
if (ht_flag) pixaAddPix(pixa, pixm, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/ccmask.150.png", pixm, IFF_PNG);
/* Fill seed into mask to get halftone mask */
pixhm1 = pixSeedfillBinary(NULL, pixhs, pixm, 4);
if (ht_flag) pixaAddPix(pixa, pixhm1, L_COPY);
if (which == 1) pixWrite("/tmp/lept/livre/htmask.150.png", pixhm1, IFF_PNG);
pixhm2 = pixExpandBinaryPower2(pixhm1, 2);
/* Extract halftone stuff */
pixht = pixAnd(NULL, pixhm1, pixr);
if (which == 1) pixWrite("/tmp/lept/livre/ht.150.png", pixht, IFF_PNG);
/* Extract non-halftone stuff */
pixnht = pixXor(NULL, pixht, pixr);
if (text_flag) pixaAddPix(pixa, pixnht, L_COPY);
if (which == 1) pixWrite("/tmp/lept/livre/text.150.png", pixnht, IFF_PNG);
pixZero(pixht, &zero);
if (zero)
fprintf(stderr, "No halftone parts found\n");
else
fprintf(stderr, "Halftone parts found\n");
/* Get bit-inverted image */
pixi = pixInvert(NULL, pixnht);
if (ws_flag) pixaAddPix(pixa, pixi, L_COPY);
if (which == 1) pixWrite("/tmp/lept/livre/invert.150.png", pixi, IFF_PNG);
/* The whitespace mask will break textlines where there
* is a large amount of white space below or above.
* We can prevent this by identifying regions of the
* inverted image that have large horizontal (bigger than
* the separation between columns) and significant
* vertical extent (bigger than the separation between
* textlines), and subtracting this from the whitespace mask. */
pix1 = pixMorphCompSequence(pixi, "o80.60", 0);
pix2 = pixSubtract(NULL, pixi, pix1);
if (ws_flag) pixaAddPix(pixa, pix2, L_COPY);
pixDestroy(&pix1);
/* Identify vertical whitespace by opening inverted image */
pix3 = pixOpenBrick(NULL, pix2, 5, 1); /* removes thin vertical lines */
pixvws = pixOpenBrick(NULL, pix3, 1, 200); /* gets long vertical lines */
if (text_flag || ws_flag) pixaAddPix(pixa, pixvws, L_COPY);
if (which == 1) pixWrite("/tmp/lept/livre/vertws.150.png", pixvws, IFF_PNG);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Get proto (early processed) text line mask. */
/* First close the characters and words in the textlines */
pixm1 = pixCloseSafeBrick(NULL, pixnht, 30, 1);
if (text_flag) pixaAddPix(pixa, pixm1, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/textmask1.150.png", pixm1, IFF_PNG);
/* Next open back up the vertical whitespace corridors */
pixm2 = pixSubtract(NULL, pixm1, pixvws);
if (which == 1)
pixWrite("/tmp/lept/livre/textmask2.150.png", pixm2, IFF_PNG);
/* Do a small opening to remove noise */
pixOpenBrick(pixm2, pixm2, 3, 3);
if (text_flag) pixaAddPix(pixa, pixm2, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/textmask3.150.png", pixm2, IFF_PNG);
pixm3 = pixExpandBinaryPower2(pixm2, 2);
/* Join pixels vertically to make text block mask */
pixb1 = pixMorphSequence(pixm2, "c1.10 + o4.1", 0);
if (block_flag) pixaAddPix(pixa, pixb1, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/textblock1.150.png", pixb1, IFF_PNG);
/* Solidify the textblock mask and remove noise:
* (1) For each c.c., close the blocks and dilate slightly
* to form a solid mask.
* (2) Small horizontal closing between components
* (3) Open the white space between columns, again
* (4) Remove small components */
pix1 = pixMorphSequenceByComponent(pixb1, "c30.30 + d3.3", 8, 0, 0, NULL);
pixCloseSafeBrick(pix1, pix1, 10, 1);
if (block_flag) pixaAddPix(pixa, pix1, L_COPY);
pix2 = pixSubtract(NULL, pix1, pixvws);
pix3 = pixSelectBySize(pix2, 25, 5, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GTE, NULL);
if (block_flag) pixaAddPix(pixa, pix3, L_COPY);
if (which == 1)
pixWrite("/tmp/lept/livre/textblock2.150.png", pix3, IFF_PNG);
pixb2 = pixExpandBinaryPower2(pix3, 2);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Identify the outlines of each textblock */
ptaa = pixGetOuterBordersPtaa(pixb2);
pix1 = pixRenderRandomCmapPtaa(pixb2, ptaa, 1, 8, 1);
cmap = pixGetColormap(pix1);
pixcmapResetColor(cmap, 0, 130, 130, 130); /* set interior to gray */
if (which == 1)
pixWrite("/tmp/lept/livre/textblock3.300.png", pix1, IFF_PNG);
pixDisplayWithTitle(pix1, 480, 360, "textblock mask with outlines", DFLAG);
ptaaDestroy(&ptaa);
pixDestroy(&pix1);
/* Fill line mask (as seed) into the original */
pix1 = pixSeedfillBinary(NULL, pixm3, pixs, 8);
pixOr(pixm3, pixm3, pix1);
pixDestroy(&pix1);
if (which == 1)
pixWrite("/tmp/lept/livre/textmask.300.png", pixm3, IFF_PNG);
pixDisplayWithTitle(pixm3, 480, 360, "textline mask 4", DFLAG);
/* Fill halftone mask (as seed) into the original */
pix1 = pixSeedfillBinary(NULL, pixhm2, pixs, 8);
pixOr(pixhm2, pixhm2, pix1);
pixDestroy(&pix1);
if (which == 1)
pixWrite("/tmp/lept/livre/htmask.300.png", pixhm2, IFF_PNG);
pixDisplayWithTitle(pixhm2, 520, 390, "halftonemask 2", DFLAG);
/* Find objects that are neither text nor halftones */
pix1 = pixSubtract(NULL, pixs, pixm3); /* remove text pixels */
pixnon = pixSubtract(NULL, pix1, pixhm2); /* remove halftone pixels */
pixDestroy(&pix1);
if (which == 1)
pixWrite("/tmp/lept/livre/other.300.png", pixnon, IFF_PNG);
pixDisplayWithTitle(pixnon, 540, 420, "other stuff", DFLAG);
/* Write out b.b. for text line mask and halftone mask components */
boxatm = pixConnComp(pixm3, NULL, 4);
boxahm = pixConnComp(pixhm2, NULL, 8);
if (which == 1) {
boxaWrite("/tmp/lept/livre/textmask.boxa", boxatm);
boxaWrite("/tmp/lept/livre/htmask.boxa", boxahm);
}
pix1 = pixaDisplayTiledAndScaled(pixa, 8, 250, 4, 0, 25, 2);
pixDisplay(pix1, 0, 375 * (which - 1));
snprintf(buf, sizeof(buf), "/tmp/lept/livre/segout.%d.png", which);
pixWrite(buf, pix1, IFF_PNG);
pixDestroy(&pix1);
pixaDestroy(&pixa);
/* clean up to test with valgrind */
pixDestroy(&pixr);
pixDestroy(&pixhs);
pixDestroy(&pixm);
pixDestroy(&pixhm1);
pixDestroy(&pixhm2);
pixDestroy(&pixht);
pixDestroy(&pixi);
pixDestroy(&pixnht);
pixDestroy(&pixvws);
pixDestroy(&pixm1);
pixDestroy(&pixm2);
pixDestroy(&pixm3);
pixDestroy(&pixb1);
pixDestroy(&pixb2);
pixDestroy(&pixnon);
boxaDestroy(&boxatm);
boxaDestroy(&boxahm);
return 0;
}
/*!
* pixGetRegionsBinary()
*
* Input: pixs (1 bpp, assumed to be 300 to 400 ppi)
* &pixhm (<optional return> halftone mask)
* &pixtm (<optional return> textline mask)
* &pixtb (<optional return> textblock mask)
* debug (flag: set to 1 for debug output)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) It is best to deskew the image before segmenting.
* (2) The debug flag enables a number of outputs. These
* are included to show how to generate and save/display
* these results.
*/
l_int32
pixGetRegionsBinary(PIX *pixs,
PIX **ppixhm,
PIX **ppixtm,
PIX **ppixtb,
l_int32 debug)
{
char *tempname;
l_int32 htfound, tlfound;
PIX *pixr, *pixt1, *pixt2;
PIX *pixtext; /* text pixels only */
PIX *pixhm2; /* halftone mask; 2x reduction */
PIX *pixhm; /* halftone mask; */
PIX *pixtm2; /* textline mask; 2x reduction */
PIX *pixtm; /* textline mask */
PIX *pixvws; /* vertical white space mask */
PIX *pixtb2; /* textblock mask; 2x reduction */
PIX *pixtbf2; /* textblock mask; 2x reduction; small comps filtered */
PIX *pixtb; /* textblock mask */
PROCNAME("pixGetRegionsBinary");
if (ppixhm) *ppixhm = NULL;
if (ppixtm) *ppixtm = NULL;
if (ppixtb) *ppixtb = NULL;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (pixGetDepth(pixs) != 1)
return ERROR_INT("pixs not 1 bpp", procName, 1);
/* 2x reduce, to 150 -200 ppi */
pixr = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0);
pixDisplayWrite(pixr, debug);
/* Get the halftone mask */
pixhm2 = pixGenHalftoneMask(pixr, &pixtext, &htfound, debug);
/* Get the textline mask from the text pixels */
pixtm2 = pixGenTextlineMask(pixtext, &pixvws, &tlfound, debug);
/* Get the textblock mask from the textline mask */
pixtb2 = pixGenTextblockMask(pixtm2, pixvws, debug);
pixDestroy(&pixr);
pixDestroy(&pixtext);
pixDestroy(&pixvws);
/* Remove small components from the mask, where a small
* component is defined as one with both width and height < 60 */
pixtbf2 = pixSelectBySize(pixtb2, 60, 60, 4, L_SELECT_IF_EITHER,
L_SELECT_IF_GTE, NULL);
pixDestroy(&pixtb2);
pixDisplayWriteFormat(pixtbf2, debug, IFF_PNG);
/* Expand all masks to full resolution, and do filling or
* small dilations for better coverage. */
pixhm = pixExpandReplicate(pixhm2, 2);
pixt1 = pixSeedfillBinary(NULL, pixhm, pixs, 8);
pixOr(pixhm, pixhm, pixt1);
pixDestroy(&pixt1);
pixDisplayWriteFormat(pixhm, debug, IFF_PNG);
pixt1 = pixExpandReplicate(pixtm2, 2);
pixtm = pixDilateBrick(NULL, pixt1, 3, 3);
pixDestroy(&pixt1);
pixDisplayWriteFormat(pixtm, debug, IFF_PNG);
pixt1 = pixExpandReplicate(pixtbf2, 2);
pixtb = pixDilateBrick(NULL, pixt1, 3, 3);
pixDestroy(&pixt1);
pixDisplayWriteFormat(pixtb, debug, IFF_PNG);
pixDestroy(&pixhm2);
pixDestroy(&pixtm2);
pixDestroy(&pixtbf2);
/* Debug: identify objects that are neither text nor halftone image */
if (debug) {
pixt1 = pixSubtract(NULL, pixs, pixtm); /* remove text pixels */
pixt2 = pixSubtract(NULL, pixt1, pixhm); /* remove halftone pixels */
pixDisplayWriteFormat(pixt2, 1, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
/* Debug: display textline components with random colors */
if (debug) {
l_int32 w, h;
BOXA *boxa;
PIXA *pixa;
boxa = pixConnComp(pixtm, &pixa, 8);
pixGetDimensions(pixtm, &w, &h, NULL);
pixt1 = pixaDisplayRandomCmap(pixa, w, h);
pixcmapResetColor(pixGetColormap(pixt1), 0, 255, 255, 255);
pixDisplay(pixt1, 100, 100);
pixDisplayWriteFormat(pixt1, 1, IFF_PNG);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
pixDestroy(&pixt1);
}
/* Debug: identify the outlines of each textblock */
if (debug) {
PIXCMAP *cmap;
PTAA *ptaa;
ptaa = pixGetOuterBordersPtaa(pixtb);
tempname = genTempFilename("/tmp", "tb_outlines.ptaa", 0, 0);
ptaaWrite(tempname, ptaa, 1);
FREE(tempname);
pixt1 = pixRenderRandomCmapPtaa(pixtb, ptaa, 1, 16, 1);
cmap = pixGetColormap(pixt1);
pixcmapResetColor(cmap, 0, 130, 130, 130);
pixDisplay(pixt1, 500, 100);
pixDisplayWriteFormat(pixt1, 1, IFF_PNG);
pixDestroy(&pixt1);
ptaaDestroy(&ptaa);
}
/* Debug: get b.b. for all mask components */
if (debug) {
BOXA *bahm, *batm, *batb;
bahm = pixConnComp(pixhm, NULL, 4);
batm = pixConnComp(pixtm, NULL, 4);
batb = pixConnComp(pixtb, NULL, 4);
tempname = genTempFilename("/tmp", "htmask.boxa", 0, 0);
boxaWrite(tempname, bahm);
FREE(tempname);
tempname = genTempFilename("/tmp", "textmask.boxa", 0, 0);
boxaWrite(tempname, batm);
FREE(tempname);
tempname = genTempFilename("/tmp", "textblock.boxa", 0, 0);
boxaWrite(tempname, batb);
FREE(tempname);
boxaDestroy(&bahm);
boxaDestroy(&batm);
boxaDestroy(&batb);
}
if (ppixhm)
*ppixhm = pixhm;
else
pixDestroy(&pixhm);
if (ppixtm)
*ppixtm = pixtm;
else
pixDestroy(&pixtm);
if (ppixtb)
*ppixtb = pixtb;
else
pixDestroy(&pixtb);
return 0;
}
/*!
* pixSplitIntoCharacters()
*
* Input: pixs (1 bpp, contains only deskewed text)
* minw (minimum component width for initial filtering; typ. 4)
* minh (minimum component height for initial filtering; typ. 4)
* &boxa (<optional return> character bounding boxes)
* &pixa (<optional return> character images)
* &pixdebug (<optional return> showing splittings)
*
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This is a simple function that attempts to find split points
* based on vertical pixel profiles.
* (2) It should be given an image that has an arbitrary number
* of text characters.
* (3) The returned pixa includes the boxes from which the
* (possibly split) components are extracted.
*/
l_int32
pixSplitIntoCharacters(PIX *pixs,
l_int32 minw,
l_int32 minh,
BOXA **pboxa,
PIXA **ppixa,
PIX **ppixdebug)
{
l_int32 ncomp, i, xoff, yoff;
BOXA *boxa1, *boxa2, *boxat1, *boxat2, *boxad;
BOXAA *baa;
PIX *pix, *pix1, *pix2, *pixdb;
PIXA *pixa1, *pixadb;
PROCNAME("pixSplitIntoCharacters");
if (pboxa) *pboxa = NULL;
if (ppixa) *ppixa = NULL;
if (ppixdebug) *ppixdebug = NULL;
if (!pixs || pixGetDepth(pixs) != 1)
return ERROR_INT("pixs not defined or not 1 bpp", procName, 1);
/* Remove the small stuff */
pix1 = pixSelectBySize(pixs, minw, minh, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GT, NULL);
/* Small vertical close for consolidation */
pix2 = pixMorphSequence(pix1, "c1.10", 0);
pixDestroy(&pix1);
/* Get the 8-connected components */
boxa1 = pixConnComp(pix2, &pixa1, 8);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
/* Split the components if obvious */
ncomp = pixaGetCount(pixa1);
boxa2 = boxaCreate(ncomp);
pixadb = (ppixdebug) ? pixaCreate(ncomp) : NULL;
for (i = 0; i < ncomp; i++) {
pix = pixaGetPix(pixa1, i, L_CLONE);
if (ppixdebug) {
boxat1 = pixSplitComponentWithProfile(pix, 10, 7, &pixdb);
if (pixdb)
pixaAddPix(pixadb, pixdb, L_INSERT);
} else {
boxat1 = pixSplitComponentWithProfile(pix, 10, 7, NULL);
}
pixaGetBoxGeometry(pixa1, i, &xoff, &yoff, NULL, NULL);
boxat2 = boxaTransform(boxat1, xoff, yoff, 1.0, 1.0);
boxaJoin(boxa2, boxat2, 0, -1);
pixDestroy(&pix);
boxaDestroy(&boxat1);
boxaDestroy(&boxat2);
}
pixaDestroy(&pixa1);
/* Generate the debug image */
if (ppixdebug) {
if (pixaGetCount(pixadb) > 0) {
*ppixdebug = pixaDisplayTiledInRows(pixadb, 32, 1500,
1.0, 0, 20, 1);
}
pixaDestroy(&pixadb);
}
/* Do a 2D sort on the bounding boxes, and flatten the result to 1D */
baa = boxaSort2d(boxa2, NULL, 0, 0, 5);
boxad = boxaaFlattenToBoxa(baa, NULL, L_CLONE);
boxaaDestroy(&baa);
boxaDestroy(&boxa2);
/* Optionally extract the pieces from the input image */
if (ppixa)
*ppixa = pixClipRectangles(pixs, boxad);
if (pboxa)
*pboxa = boxad;
else
boxaDestroy(&boxad);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 w, h, n, i, sum, sumi, empty;
BOX *box1, *box2, *box3, *box4;
BOXA *boxa, *boxat;
NUMA *na1, *na2, *na3, *na4, *na5;
NUMA *na2i, *na3i, *na4i, *nat, *naw, *nah;
PIX *pixs, *pixc, *pixt, *pixt2, *pixd, *pixcount;
PIXA *pixas, *pixad, *pixac;
pixDisplayWrite(NULL, -1);
/* Draw 4 filled boxes of different sizes */
pixs = pixCreate(200, 200, 1);
box1 = boxCreate(10, 10, 20, 30);
box2 = boxCreate(50, 10, 40, 20);
box3 = boxCreate(110, 10, 35, 5);
box4 = boxCreate(160, 10, 5, 15);
boxa = boxaCreate(4);
boxaAddBox(boxa, box1, L_INSERT);
boxaAddBox(boxa, box2, L_INSERT);
boxaAddBox(boxa, box3, L_INSERT);
boxaAddBox(boxa, box4, L_INSERT);
pixRenderBox(pixs, box1, 1, L_SET_PIXELS);
pixRenderBox(pixs, box2, 1, L_SET_PIXELS);
pixRenderBox(pixs, box3, 1, L_SET_PIXELS);
pixRenderBox(pixs, box4, 1, L_SET_PIXELS);
pixt = pixFillClosedBorders(pixs, 4);
pixDisplayWrite(pixt, 1);
pixt2 = pixCreateTemplate(pixs);
pixRenderHashBox(pixt2, box1, 6, 4, L_POS_SLOPE_LINE, 1, L_SET_PIXELS);
pixRenderHashBox(pixt2, box2, 7, 2, L_POS_SLOPE_LINE, 1, L_SET_PIXELS);
pixRenderHashBox(pixt2, box3, 4, 2, L_VERTICAL_LINE, 1, L_SET_PIXELS);
pixRenderHashBox(pixt2, box4, 3, 1, L_HORIZONTAL_LINE, 1, L_SET_PIXELS);
pixDisplayWrite(pixt2, 1);
/* Exercise the parameters */
pixd = pixSelectBySize(pixt, 0, 22, 8, L_SELECT_HEIGHT,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 0, 30, 8, L_SELECT_HEIGHT,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectBySize(pixt, 0, 5, 8, L_SELECT_HEIGHT,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectBySize(pixt, 0, 6, 8, L_SELECT_HEIGHT,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 20, 0, 8, L_SELECT_WIDTH,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 31, 0, 8, L_SELECT_WIDTH,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 21, 10, 8, L_SELECT_IF_EITHER,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectBySize(pixt, 20, 30, 8, L_SELECT_IF_EITHER,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 22, 32, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 6, 32, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 5, 25, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 25, 5, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.3, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.15, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.4, 8, L_SELECT_IF_LTE, NULL);
count_pieces(pixd, 2);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.45, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByPerimSizeRatio(pixt2, 2.3, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectByPerimSizeRatio(pixt2, 1.2, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByPerimSizeRatio(pixt2, 1.7, 8, L_SELECT_IF_LTE, NULL);
count_pieces(pixd, 1);
pixd = pixSelectByPerimSizeRatio(pixt2, 2.9, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByAreaFraction(pixt2, 0.3, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 0);
pixd = pixSelectByAreaFraction(pixt2, 0.9, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 4);
pixd = pixSelectByAreaFraction(pixt2, 0.5, 8, L_SELECT_IF_GTE, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByAreaFraction(pixt2, 0.7, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
boxat = boxaSelectBySize(boxa, 21, 10, L_SELECT_IF_EITHER,
L_SELECT_IF_LT, NULL);
count_pieces2(boxat, 3);
boxat = boxaSelectBySize(boxa, 22, 32, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
count_pieces2(boxat, 2);
boxaDestroy(&boxa);
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixs);
/* Here's the most general method for selecting components.
* We do it for area fraction, but any combination of
* size, area/perimeter ratio and area fraction can be used. */
pixs = pixRead("feyn.tif");
/* pixs = pixRead("rabi.png"); */
pixc = pixCopy(NULL, pixs); /* subtract bands from this */
pixt = pixCreateTemplate(pixs); /* add bands to this */
pixGetDimensions(pixs, &w, &h, NULL);
boxa = pixConnComp(pixs, &pixas, 8);
n = boxaGetCount(boxa);
fprintf(stderr, "total: %d\n", n);
na1 = pixaFindAreaFraction(pixas);
nat = numaCreate(0);
numaSetCount(nat, n); /* initialize to all 0 */
sum = sumi = 0;
pixac = pixaCreate(0);
for (i = 0; i < 12; i++) {
/* Compute within the intervals using an intersection. */
na2 = numaMakeThresholdIndicator(na1, edges[i], L_SELECT_IF_GTE);
if (i != 11)
na3 = numaMakeThresholdIndicator(na1, edges[i + 1], L_SELECT_IF_LT);
else
na3 = numaMakeThresholdIndicator(na1, edges[i + 1],
L_SELECT_IF_LTE);
na4 = numaLogicalOp(NULL, na2, na3, L_INTERSECTION);
sum += count_ones(na4, 0, 0, NULL);
/* Compute outside the intervals using a union, and invert */
na2i = numaMakeThresholdIndicator(na1, edges[i], L_SELECT_IF_LT);
if (i != 11)
na3i = numaMakeThresholdIndicator(na1, edges[i + 1],
L_SELECT_IF_GTE);
else
na3i = numaMakeThresholdIndicator(na1, edges[i + 1],
L_SELECT_IF_GT);
na4i = numaLogicalOp(NULL, na3i, na2i, L_UNION);
numaInvert(na4i, na4i);
sumi += count_ones(na4i, 0, 0, NULL);
/* Compare the two methods */
if (sum == sumi)
fprintf(stderr, "\nCorrect: sum = sumi = %d\n", sum);
else
fprintf(stderr, "\nWRONG: sum = %d, sumi = %d\n", sum, sumi);
/* Reconstruct the image, band by band. */
numaLogicalOp(nat, nat, na4, L_UNION);
pixad = pixaSelectWithIndicator(pixas, na4, NULL);
pixd = pixaDisplay(pixad, w, h);
pixOr(pixt, pixt, pixd); /* add them in */
pixcount = pixCopy(NULL, pixt); /* destroyed by count_pieces */
count_ones(na4, band[i], i, "band");
count_pieces(pixd, band[i]);
count_ones(nat, total[i], i, "total");
count_pieces(pixcount, total[i]);
pixaDestroy(&pixad);
/* Remove band successively from full image */
pixRemoveWithIndicator(pixc, pixas, na4);
pixSaveTiled(pixc, pixac, 0.25, 1 - i % 2, 25, 8);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
numaDestroy(&na2i);
numaDestroy(&na3i);
numaDestroy(&na4i);
}
/* Did we remove all components from pixc? */
pixZero(pixc, &empty);
if (!empty)
fprintf(stderr, "\nWRONG: not all pixels removed from pixc\n");
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pixt);
boxaDestroy(&boxa);
pixaDestroy(&pixas);
numaDestroy(&na1);
numaDestroy(&nat);
/* One last extraction. Get all components that have either
* a height of at least 50 or a width of between 30 and 35,
* and also have a relatively large perimeter/area ratio. */
pixs = pixRead("feyn.tif");
boxa = pixConnComp(pixs, &pixas, 8);
n = boxaGetCount(boxa);
pixaFindDimensions(pixas, &naw, &nah);
na1 = pixaFindPerimToAreaRatio(pixas);
na2 = numaMakeThresholdIndicator(nah, 50, L_SELECT_IF_GTE);
na3 = numaMakeThresholdIndicator(naw, 30, L_SELECT_IF_GTE);
na4 = numaMakeThresholdIndicator(naw, 35, L_SELECT_IF_LTE);
na5 = numaMakeThresholdIndicator(na1, 0.4, L_SELECT_IF_GTE);
numaLogicalOp(na3, na3, na4, L_INTERSECTION);
numaLogicalOp(na2, na2, na3, L_UNION);
numaLogicalOp(na2, na2, na5, L_INTERSECTION);
numaInvert(na2, na2); /* get components to be removed */
pixRemoveWithIndicator(pixs, pixas, na2);
pixSaveTiled(pixs, pixac, 0.25, 1, 25, 8);
pixDestroy(&pixs);
boxaDestroy(&boxa);
pixaDestroy(&pixas);
numaDestroy(&naw);
numaDestroy(&nah);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
numaDestroy(&na5);
pixDisplayMultiple("/tmp/display/file*");
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/comp.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
return 0;
}
