main(int argc,
char **argv)
{
l_int32 ws, hs;
BOX *box;
BOXA *boxa;
PIX *pixs, *pixc, *pix32, *pixt, *pixd;
PIXA *pixat, *pixas, *pixac;
static char mainName[] = "pixadisp_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: pixadisp_reg", mainName, 1));
if ((pixs = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
box = boxCreate(683, 799, 970, 479);
pixc = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
pixDisplayWrite(pixc, 1);
if ((pix32 = pixRead("marge.jpg")) == NULL)
exit(ERROR_INT("pix32 not made", mainName, 1));
/* Generate pixas from pixs and pixac from pixc */
boxa = pixConnComp(pixs, &pixat, 8);
pixas = pixaSelectBySize(pixat, 60, 60, L_SELECT_IF_BOTH,
L_SELECT_IF_LTE, NULL);
pixaDestroy(&pixat);
boxaDestroy(&boxa);
boxa = pixConnComp(pixc, &pixac, 8);
boxaDestroy(&boxa);
/* pixaDisplay() */
pixGetDimensions(pixs, &ws, &hs, NULL);
pixd = pixaDisplay(pixas, ws, hs);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayRandomCmap() */
pixd = pixaDisplayRandomCmap(pixas, ws, hs); /* black bg */
pixDisplayWrite(pixd, 1);
pixcmapResetColor(pixGetColormap(pixd), 0, 255, 255, 255); /* white bg */
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayOnLattice() */
pixd = pixaDisplayOnLattice(pixac, 50, 50);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayUnsplit() */
pixat = pixaSplitPix(pix32, 5, 7, 10, 0x0000ff00);
pixd = pixaDisplayUnsplit(pixat, 5, 7, 10, 0x00ff0000);
pixDisplayWrite(pixd, 1);
pixaDestroy(&pixat);
pixDestroy(&pixd);
/* pixaDisplayTiled() */
pixd = pixaDisplayTiled(pixac, 1000, 0, 10);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayTiledInRows() */
pixd = pixaDisplayTiledInRows(pixac, 1, 1000, 1.0, 0, 10, 2);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayTiledAndScaled() */
pixd = pixaDisplayTiledAndScaled(pixac, 1, 25, 20, 0, 5, 0);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
pixat = pixaCreate(10);
pixd = pixRankFilter(pix32, 8, 8, 0.5);
pixaAddPix(pixat, pixd, L_INSERT);
pixt = pixScale(pix32, 0.5, 0.5);
pixd = pixRankFilter(pixt, 8, 8, 0.5);
pixaAddPix(pixat, pixd, L_INSERT);
pixDestroy(&pixt);
pixt = pixScale(pix32, 0.25, 0.25);
pixd = pixRankFilter(pixt, 8, 8, 0.5);
pixaAddPix(pixat, pixd, L_INSERT);
pixDestroy(&pixt);
pixd = pixaDisplayTiledAndScaled(pixat, 32, 500, 1, 0, 25, 0);
pixDisplayWrite(pixd, 1);
pixaDestroy(&pixat);
pixDestroy(&pixd);
pixaDestroy(&pixas);
pixaDestroy(&pixac);
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pix32);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}
/*!
* pixaGenerateFont()
*
* Input: dir (directory holding image of character set)
* size (4, 6, 8, ... , 20, in pts at 300 ppi)
* &bl1 (<return> baseline of row 1)
* &bl2 (<return> baseline of row 2)
* &bl3 (<return> baseline of row 3)
* Return: pixa of font bitmaps for 95 characters, or null on error
*
* These font generation functions use 9 sets, each with bitmaps
* of 94 ascii characters, all in Palatino-Roman font.
* Each input bitmap has 3 rows of characters. The range of
* ascii values in each row is as follows:
* row 0: 32-57 (32 is a space)
* row 1: 58-91 (92, '\', is not represented in this font)
* row 2: 93-126
* We LR flip the '/' char to generate a bitmap for the missing
* '\' character, so that we have representations of all 95
* printable chars.
*
* Computation of the bitmaps and baselines for a single
* font takes from 40 to 200 msec on a 2 GHz processor,
* depending on the size. Use pixaGetFont() to read the
* generated character set directly from files that were
* produced in prog/genfonts.c using this function.
*/
PIXA *
pixaGenerateFont(const char *dir,
l_int32 size,
l_int32 *pbl0,
l_int32 *pbl1,
l_int32 *pbl2)
{
char *pathname;
l_int32 fileno;
l_int32 i, j, nrows, nrowchars, nchars, h, yval;
l_int32 width, height;
l_int32 baseline[3];
l_int32 *tab;
BOX *box, *box1, *box2;
BOXA *boxar, *boxac, *boxacs;
PIX *pixs, *pixt1, *pixt2, *pixt3;
PIX *pixr, *pixrc, *pixc;
PIXA *pixa;
PROCNAME("pixaGenerateFont");
if (!pbl0 || !pbl1 || !pbl2)
return (PIXA *)ERROR_PTR("&bl not all defined", procName, NULL);
*pbl0 = *pbl1 = *pbl2 = 0;
fileno = (size / 2) - 2;
if (fileno < 0 || fileno > NFONTS)
return (PIXA *)ERROR_PTR("font size invalid", procName, NULL);
tab = makePixelSumTab8();
pathname = genPathname(dir, inputfonts[fileno]);
if ((pixs = pixRead(pathname)) == NULL)
return (PIXA *)ERROR_PTR("pixs not all defined", procName, NULL);
FREE(pathname);
pixa = pixaCreate(95);
pixt1 = pixMorphSequence(pixs, "c1.35 + c101.1", 0);
boxar = pixConnComp(pixt1, NULL, 8); /* one box for each row */
pixDestroy(&pixt1);
nrows = boxaGetCount(boxar);
#if DEBUG_FONT_GEN
fprintf(stderr, "For font %s, number of rows is %d\n",
inputfonts[fileno], nrows);
#endif /* DEBUG_FONT_GEN */
if (nrows != 3) {
L_INFO_INT2("nrows = %d; skipping font %d", procName, nrows, fileno);
return (PIXA *)ERROR_PTR("3 rows not generated", procName, NULL);
}
for (i = 0; i < nrows; i++) {
box = boxaGetBox(boxar, i, L_CLONE);
pixr = pixClipRectangle(pixs, box, NULL); /* row of chars */
pixGetTextBaseline(pixr, tab, &yval);
baseline[i] = yval;
#if DEBUG_BASELINE
{ PIX *pixbl;
fprintf(stderr, "row %d, yval = %d, h = %d\n",
i, yval, pixGetHeight(pixr));
pixbl = pixCopy(NULL, pixr);
pixRenderLine(pixbl, 0, yval, pixGetWidth(pixbl), yval, 1,
L_FLIP_PIXELS);
if (i == 0 )
pixWrite("junktl0", pixbl, IFF_PNG);
else if (i == 1)
pixWrite("junktl1", pixbl, IFF_PNG);
else
pixWrite("junktl2", pixbl, IFF_PNG);
pixDestroy(&pixbl);
}
#endif /* DEBUG_BASELINE */
boxDestroy(&box);
pixrc = pixCloseSafeBrick(NULL, pixr, 1, 35);
boxac = pixConnComp(pixrc, NULL, 8);
boxacs = boxaSort(boxac, L_SORT_BY_X, L_SORT_INCREASING, NULL);
if (i == 0) { /* consolidate the two components of '"' */
box1 = boxaGetBox(boxacs, 1, L_CLONE);
box2 = boxaGetBox(boxacs, 2, L_CLONE);
box1->w = box2->x + box2->w - box1->x; /* increase width */
boxDestroy(&box1);
boxDestroy(&box2);
boxaRemoveBox(boxacs, 2);
}
h = pixGetHeight(pixr);
nrowchars = boxaGetCount(boxacs);
for (j = 0; j < nrowchars; j++) {
box = boxaGetBox(boxacs, j, L_COPY);
if (box->w <= 2 && box->h == 1) { /* skip 1x1, 2x1 components */
boxDestroy(&box);
continue;
}
box->y = 0;
box->h = h - 1;
pixc = pixClipRectangle(pixr, box, NULL);
boxDestroy(&box);
if (i == 0 && j == 0) /* add a pix for the space; change later */
pixaAddPix(pixa, pixc, L_COPY);
if (i == 2 && j == 0) /* add a pix for the '\'; change later */
pixaAddPix(pixa, pixc, L_COPY);
pixaAddPix(pixa, pixc, L_INSERT);
}
pixDestroy(&pixr);
pixDestroy(&pixrc);
boxaDestroy(&boxac);
boxaDestroy(&boxacs);
}
nchars = pixaGetCount(pixa);
if (nchars != 95)
return (PIXA *)ERROR_PTR("95 chars not generated", procName, NULL);
*pbl0 = baseline[0];
*pbl1 = baseline[1];
*pbl2 = baseline[2];
/* Fix the space character up; it should have no ON pixels,
* and be about twice as wide as the '!' character. */
pixt2 = pixaGetPix(pixa, 0, L_CLONE);
width = 2 * pixGetWidth(pixt2);
height = pixGetHeight(pixt2);
pixDestroy(&pixt2);
pixt2 = pixCreate(width, height, 1);
pixaReplacePix(pixa, 0, pixt2, NULL);
/* Fix up the '\' character; use a LR flip of the '/' char */
pixt2 = pixaGetPix(pixa, 15, L_CLONE);
pixt3 = pixFlipLR(NULL, pixt2);
pixDestroy(&pixt2);
pixaReplacePix(pixa, 60, pixt3, NULL);
#if DEBUG_CHARS
{ PIX *pixd;
pixd = pixaDisplayTiled(pixa, 1500, 0, 10);
pixDisplay(pixd, 100 * i, 200);
pixDestroy(&pixd);
}
#endif /* DEBUG_CHARS */
pixDestroy(&pixs);
boxaDestroy(&boxar);
FREE(tab);
return pixa;
}
/*!
* 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;
}
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 *pixtm1; /* image of closed textlines, 150 ppi */
PIX *pixtm2; /* image of refined text line mask, 150 ppi */
PIX *pixtm3; /* image of refined text line mask, 300 ppi */
PIX *pixtb1; /* image of text block mask, 150 ppi */
PIX *pixtb2; /* image of text block mask, 300 ppi */
PIX *pixnon; /* image of non-text or halftone, 150 ppi */
PIX *pixt1, *pixt2, *pixt3;
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);
pixDisplayWrite(NULL, -1);
/* Reduce to 150 ppi */
pixt1 = pixScaleToGray2(pixs);
pixDisplayWriteFormat(pixt1, L_MAX(ws_flag, L_MAX(ht_flag, block_flag)),
IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/orig.gray.150.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixr = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0);
/* Get seed for halftone parts */
pixt1 = pixReduceRankBinaryCascade(pixr, 4, 4, 3, 0);
pixt2 = pixOpenBrick(NULL, pixt1, 5, 5);
pixhs = pixExpandBinaryPower2(pixt2, 8);
pixDisplayWriteFormat(pixhs, ht_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/htseed.150.png", pixhs, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Get mask for connected regions */
pixm = pixCloseSafeBrick(NULL, pixr, 4, 4);
pixDisplayWriteFormat(pixm, ht_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/ccmask.150.png", pixm, IFF_PNG);
/* Fill seed into mask to get halftone mask */
pixhm1 = pixSeedfillBinary(NULL, pixhs, pixm, 4);
pixDisplayWriteFormat(pixhm1, ht_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/htmask.150.png", pixhm1, IFF_PNG);
pixhm2 = pixExpandBinaryPower2(pixhm1, 2);
/* Extract halftone stuff */
pixht = pixAnd(NULL, pixhm1, pixr);
if (which == 1) pixWrite("/tmp/lept/ht.150.png", pixht, IFF_PNG);
/* Extract non-halftone stuff */
pixnht = pixXor(NULL, pixht, pixr);
pixDisplayWriteFormat(pixnht, text_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/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 (which == 1) pixWrite("/tmp/lept/invert.150.png", pixi, IFF_PNG);
pixDisplayWriteFormat(pixi, ws_flag, 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. */
pixt1 = pixMorphCompSequence(pixi, "o80.60", 0);
pixt2 = pixSubtract(NULL, pixi, pixt1);
pixDisplayWriteFormat(pixt2, ws_flag, IFF_PNG);
pixDestroy(&pixt1);
/* Identify vertical whitespace by opening inverted image */
pixt3 = pixOpenBrick(NULL, pixt2, 5, 1); /* removes thin vertical lines */
pixvws = pixOpenBrick(NULL, pixt3, 1, 200); /* gets long vertical lines */
pixDisplayWriteFormat(pixvws, L_MAX(text_flag, ws_flag), IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/vertws.150.png", pixvws, IFF_PNG);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* Get proto (early processed) text line mask. */
/* First close the characters and words in the textlines */
pixtm1 = pixCloseSafeBrick(NULL, pixnht, 30, 1);
pixDisplayWriteFormat(pixtm1, text_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/textmask1.150.png", pixtm1, IFF_PNG);
/* Next open back up the vertical whitespace corridors */
pixtm2 = pixSubtract(NULL, pixtm1, pixvws);
if (which == 1) pixWrite("/tmp/lept/textmask2.150.png", pixtm2, IFF_PNG);
/* Do a small opening to remove noise */
pixOpenBrick(pixtm2, pixtm2, 3, 3);
pixDisplayWriteFormat(pixtm2, text_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/textmask3.150.png", pixtm2, IFF_PNG);
pixtm3 = pixExpandBinaryPower2(pixtm2, 2);
/* Join pixels vertically to make text block mask */
pixtb1 = pixMorphSequence(pixtm2, "c1.10 + o4.1", 0);
pixDisplayWriteFormat(pixtb1, block_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/textblock1.150.png", pixtb1, 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 */
pixt1 = pixMorphSequenceByComponent(pixtb1, "c30.30 + d3.3", 8, 0, 0, NULL);
pixCloseSafeBrick(pixt1, pixt1, 10, 1);
pixDisplayWriteFormat(pixt1, block_flag, IFF_PNG);
pixt2 = pixSubtract(NULL, pixt1, pixvws);
pixt3 = pixSelectBySize(pixt2, 25, 5, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GTE, NULL);
pixDisplayWriteFormat(pixt3, block_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/lept/textblock2.150.png", pixt3, IFF_PNG);
pixtb2 = pixExpandBinaryPower2(pixt3, 2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* Identify the outlines of each textblock */
ptaa = pixGetOuterBordersPtaa(pixtb2);
pixt1 = pixRenderRandomCmapPtaa(pixtb2, ptaa, 1, 8, 1);
cmap = pixGetColormap(pixt1);
pixcmapResetColor(cmap, 0, 130, 130, 130); /* set interior to gray */
if (which == 1) pixWrite("/tmp/lept/textblock3.300.png", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 480, 360, "textblock mask with outlines", DFLAG);
ptaaDestroy(&ptaa);
pixDestroy(&pixt1);
/* Fill line mask (as seed) into the original */
pixt1 = pixSeedfillBinary(NULL, pixtm3, pixs, 8);
pixOr(pixtm3, pixtm3, pixt1);
pixDestroy(&pixt1);
if (which == 1) pixWrite("/tmp/lept/textmask.300.png", pixtm3, IFF_PNG);
pixDisplayWithTitle(pixtm3, 480, 360, "textline mask 4", DFLAG);
/* Fill halftone mask (as seed) into the original */
pixt1 = pixSeedfillBinary(NULL, pixhm2, pixs, 8);
pixOr(pixhm2, pixhm2, pixt1);
pixDestroy(&pixt1);
if (which == 1) pixWrite("/tmp/lept/htmask.300.png", pixhm2, IFF_PNG);
pixDisplayWithTitle(pixhm2, 520, 390, "halftonemask 2", DFLAG);
/* Find objects that are neither text nor halftones */
pixt1 = pixSubtract(NULL, pixs, pixtm3); /* remove text pixels */
pixnon = pixSubtract(NULL, pixt1, pixhm2); /* remove halftone pixels */
if (which == 1) pixWrite("/tmp/lept/other.300.png", pixnon, IFF_PNG);
pixDisplayWithTitle(pixnon, 540, 420, "other stuff", DFLAG);
pixDestroy(&pixt1);
/* Write out b.b. for text line mask and halftone mask components */
boxatm = pixConnComp(pixtm3, NULL, 4);
boxahm = pixConnComp(pixhm2, NULL, 8);
if (which == 1) boxaWrite("/tmp/lept/textmask.boxa", boxatm);
if (which == 1) boxaWrite("/tmp/lept/htmask.boxa", boxahm);
pixa = pixaReadFiles("/tmp/lept/display", "file");
pixt1 = pixaDisplayTiledAndScaled(pixa, 8, 250, 4, 0, 25, 2);
snprintf(buf, sizeof(buf), "/tmp/lept/segout.%d.png", which);
pixWrite(buf, pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* clean up to test with valgrind */
pixDestroy(&pixr);
pixDestroy(&pixhs);
pixDestroy(&pixm);
pixDestroy(&pixhm1);
pixDestroy(&pixhm2);
pixDestroy(&pixht);
pixDestroy(&pixnht);
pixDestroy(&pixi);
pixDestroy(&pixvws);
pixDestroy(&pixtm1);
pixDestroy(&pixtm2);
pixDestroy(&pixtm3);
pixDestroy(&pixtb1);
pixDestroy(&pixtb2);
pixDestroy(&pixnon);
boxaDestroy(&boxatm);
boxaDestroy(&boxahm);
return 0;
}
main(int argc,
char **argv)
{
l_int32 h;
l_float32 scalefactor;
BOX *box;
BOXA *boxa1, *boxa2;
BOXAA *baa;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmdir("segtest");
lept_mkdir("segtest");
baa = boxaaCreate(5);
/* Image region input. */
pix1 = pixRead("wet-day.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/0.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/0.jpg"); /* 0 */
box = boxCreate(105, 161, 620, 872); /* image region */
boxa1 = boxaCreate(1);
boxaAddBox(boxa1, box, L_INSERT);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Compute image region at w = 2 * WIDTH */
pix1 = pixRead("candelabrum-11.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pix3 = pixConvertTo1(pix2, 100);
pix4 = pixExpandBinaryPower2(pix3, 2); /* w = 2 * WIDTH */
pix5 = pixGenHalftoneMask(pix4, NULL, NULL, 1);
pix6 = pixMorphSequence(pix5, "c20.1 + c1.20", 0);
pix7 = pixMaskConnComp(pix6, 8, &boxa1);
pix8 = pixReduceBinary2(pix7, NULL); /* back to w = WIDTH */
pix9 = pixBackgroundNormSimple(pix2, pix8, NULL);
pixWrite("/tmp/segtest/1.jpg", pix9, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/1.jpg"); /* 1 */
boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5); /* back to w = WIDTH */
boxaaAddBoxa(baa, boxa2, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pix9);
boxaDestroy(&boxa1);
/* Use mask to find image region */
pix1 = pixRead("lion-page.00016.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/2.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/2.jpg"); /* 2 */
pix3 = pixRead("lion-mask.00016.tif");
pix4 = pixScaleToSize(pix3, WIDTH, 0);
boxa1 = pixConnComp(pix4, NULL, 8);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Compute image region at full res */
pix1 = pixRead("rabi.png");
scalefactor = (l_float32)WIDTH / (l_float32)pixGetWidth(pix1);
pix2 = pixScaleToGray(pix1, scalefactor);
pixWrite("/tmp/segtest/3.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/3.jpg"); /* 3 */
pix3 = pixGenHalftoneMask(pix1, NULL, NULL, 0);
pix4 = pixMorphSequence(pix3, "c20.1 + c1.20", 0);
boxa1 = pixConnComp(pix4, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, scalefactor, scalefactor);
boxaaAddBoxa(baa, boxa2, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
boxaDestroy(&boxa1);
/* Page with no image regions */
pix1 = pixRead("lucasta-47.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
boxa1 = boxaCreate(1);
pixWrite("/tmp/segtest/4.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/4.jpg"); /* 4 */
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Page that is all image */
pix1 = pixRead("map1.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/5.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/5.jpg"); /* 5 */
h = pixGetHeight(pix2);
box = boxCreate(0, 0, WIDTH, h);
boxa1 = boxaCreate(1);
boxaAddBox(boxa1, box, L_INSERT);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Save the boxaa file */
boxaaWrite("/tmp/segtest/seg.baa", baa);
regTestCheckFile(rp, "/tmp/segtest/seg.baa"); /* 6 */
/* Do the conversion */
l_pdfSetDateAndVersion(FALSE);
convertSegmentedFilesToPdf("/tmp/segtest", ".jpg", 100, L_G4_ENCODE,
140, baa, 75, 0.6, "Segmentation Test",
"/tmp/pdfseg.7.pdf");
regTestCheckFile(rp, "/tmp/pdfseg.7.pdf"); /* 7 */
boxaaDestroy(&baa);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 i, n;
l_float32 pi, angle, val;
BOX *box;
BOXA *boxa, *boxa1, *boxa2;
NUMA *na1, *na2;
PIX *pix, *pix1, *pix2, *pix3, *pixd;
PIXA *pixa1, *pixa2, *pixa3, *pixa4;
static char mainName[] = "inserttest";
#if 1
pi = 3.1415926535;
na1 = numaCreate(500);
for (i = 0; i < 500; i++) {
angle = 0.02293 * i * pi;
val = (l_float32)sin(angle);
numaAddNumber(na1, val);
}
numaWrite("/tmp/junknuma1", na1);
na2 = numaCopy(na1);
n = numaGetCount(na2);
for (i = 0; i < n; i++) {
numaGetFValue(na2, i, &val);
numaRemoveNumber(na2, i);
numaInsertNumber(na2, i, val);
}
numaWrite("/tmp/junknuma2", na2);
numaDestroy(&na1);
numaDestroy(&na2);
#endif
#if 1
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa1 = pixConnComp(pix2, NULL, 8);
boxaWrite("/tmp/junkboxa1", boxa1);
boxa2 = boxaCopy(boxa1, L_COPY);
n = boxaGetCount(boxa2);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa2, i, L_COPY);
boxaRemoveBox(boxa2, i);
boxaInsertBox(boxa2, i, box);
}
boxaWrite("/tmp/junkboxa2", boxa2);
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa = pixConnComp(pix2, &pixa1, 8);
boxaDestroy(&boxa);
pixaWrite("/tmp/junkpixa1", pixa1);
pixa2 = pixaCopy(pixa1, L_COPY);
n = pixaGetCount(pixa2);
/* Remove and insert each one */
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa2, i, L_COPY);
box = pixaGetBox(pixa2, i, L_COPY);
pixaRemovePix(pixa2, i);
pixaInsertPix(pixa2, i, pix, box);
}
pixaWrite("/tmp/junkpixa2", pixa2);
/* Move the last to the beginning; do it n times */
pixa3 = pixaCopy(pixa2, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa3, n - 1, L_CLONE);
box = pixaGetBox(pixa3, n - 1, L_CLONE);
pixaInsertPix(pixa3, 0, pix, box);
pixaRemovePix(pixa3, n);
}
pixaWrite("/tmp/junkpixa3", pixa3);
/* Move the first one to the end; do it n times */
pixa4 = pixaCopy(pixa3, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa4, 0, L_CLONE);
box = pixaGetBox(pixa4, 0, L_CLONE);
pixaInsertPix(pixa4, n, pix, box); /* make sure insert works at end */
pixaRemovePix(pixa4, 0);
}
pixaWrite("/tmp/junkpixa4", pixa4);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixaDestroy(&pixa4);
#endif
return 0;
}
