/*!
* pixUpDownDetectGeneralDwa()
*
* Input: pixs (1 bpp, deskewed, English text)
* &conf (<return> confidence that text is rightside-up)
* mincount (min number of up + down; use 0 for default)
* npixels (number of pixels removed from each side of word box)
* debug (1 for debug output; 0 otherwise)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) See the notes in pixUpDownDetectGeneral() for usage.
*/
l_int32
pixUpDownDetectGeneralDwa(PIX *pixs,
l_float32 *pconf,
l_int32 mincount,
l_int32 npixels,
l_int32 debug)
{
char flipsel1[] = "flipsel1";
char flipsel2[] = "flipsel2";
char flipsel3[] = "flipsel3";
char flipsel4[] = "flipsel4";
l_int32 countup, countdown, nmax;
l_float32 nup, ndown;
PIX *pixt, *pixt0, *pixt1, *pixt2, *pixt3, *pixm;
PROCNAME("pixUpDownDetectGeneralDwa");
if (!pconf)
return ERROR_INT("&conf not defined", procName, 1);
*pconf = 0.0;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (mincount == 0)
mincount = DEFAULT_MIN_UP_DOWN_COUNT;
if (npixels < 0)
npixels = 0;
/* One of many reasonable pre-filtering sequences: (1, 8) and (30, 1).
* This closes holes in x-height characters and joins them at
* the x-height. There is more noise in the descender detection
* from this, but it works fairly well. */
pixt = pixMorphSequenceDwa(pixs, "c1.8 + c30.1", 0);
/* Be sure to add the border before the flip DWA operations! */
pixt0 = pixAddBorderGeneral(pixt, ADDED_BORDER, ADDED_BORDER,
ADDED_BORDER, ADDED_BORDER, 0);
pixDestroy(&pixt);
/* Optionally, make a mask of the word bounding boxes, shortening
* each of them by a fixed amount at each end. */
pixm = NULL;
if (npixels > 0) {
l_int32 i, nbox, x, y, w, h;
BOX *box;
BOXA *boxa;
pixt1 = pixMorphSequenceDwa(pixt0, "o10.1", 0);
boxa = pixConnComp(pixt1, NULL, 8);
pixm = pixCreateTemplate(pixt1);
pixDestroy(&pixt1);
nbox = boxaGetCount(boxa);
for (i = 0; i < nbox; i++) {
box = boxaGetBox(boxa, i, L_CLONE);
boxGetGeometry(box, &x, &y, &w, &h);
if (w > 2 * npixels)
pixRasterop(pixm, x + npixels, y - 6, w - 2 * npixels, h + 13,
PIX_SET, NULL, 0, 0);
boxDestroy(&box);
}
boxaDestroy(&boxa);
}
/* Find the ascenders and optionally filter with pixm.
* For an explanation of the procedure used for counting the result
* of the HMT, see comments in pixUpDownDetectGeneral(). */
pixt1 = pixFlipFHMTGen(NULL, pixt0, flipsel1);
pixt2 = pixFlipFHMTGen(NULL, pixt0, flipsel2);
pixOr(pixt1, pixt1, pixt2);
if (pixm)
pixAnd(pixt1, pixt1, pixm);
pixt3 = pixReduceRankBinaryCascade(pixt1, 1, 1, 0, 0);
pixCountPixels(pixt3, &countup, NULL);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* Find the ascenders and optionally filter with pixm. */
pixt1 = pixFlipFHMTGen(NULL, pixt0, flipsel3);
pixt2 = pixFlipFHMTGen(NULL, pixt0, flipsel4);
pixOr(pixt1, pixt1, pixt2);
if (pixm)
pixAnd(pixt1, pixt1, pixm);
pixt3 = pixReduceRankBinaryCascade(pixt1, 1, 1, 0, 0);
pixCountPixels(pixt3, &countdown, NULL);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* Evaluate statistically, generating a confidence that is
* related to the probability with a gaussian distribution. */
nup = (l_float32)(countup);
ndown = (l_float32)(countdown);
nmax = L_MAX(countup, countdown);
if (nmax > mincount)
*pconf = 2. * ((nup - ndown) / sqrt(nup + ndown));
if (debug) {
if (pixm) pixWrite("junkpixm2", pixm, IFF_PNG);
fprintf(stderr, "nup = %7.3f, ndown = %7.3f, conf = %7.3f\n",
nup, ndown, *pconf);
if (*pconf > DEFAULT_MIN_UP_DOWN_CONF)
fprintf(stderr, "Text is rightside-up\n");
if (*pconf < -DEFAULT_MIN_UP_DOWN_CONF)
fprintf(stderr, "Text is upside-down\n");
}
pixDestroy(&pixt0);
pixDestroy(&pixm);
return 0;
}
/*!
* pixaaDisplay()
*
* Input: pixaa
* w, h (if set to 0, determines the size from the
* b.b. of the components in pixaa)
* Return: pix, or null on error
*
* Notes:
* (1) Each pix of the pixaa is displayed at the location given by
* its box, translated by the box of the containing pixa
* if it exists.
*/
PIX *
pixaaDisplay(PIXAA *pixaa,
l_int32 w,
l_int32 h)
{
l_int32 i, j, n, nbox, na, d, wmax, hmax, x, y, xb, yb, wb, hb;
BOXA *boxa1; /* top-level boxa */
BOXA *boxa;
PIX *pixt, *pixd;
PIXA *pixa;
PROCNAME("pixaaDisplay");
if (!pixaa)
return (PIX *)ERROR_PTR("pixaa not defined", procName, NULL);
n = pixaaGetCount(pixaa);
if (n == 0)
return (PIX *)ERROR_PTR("no components", procName, NULL);
/* If w and h not input, determine the minimum size required
* to contain the origin and all c.c. */
boxa1 = pixaaGetBoxa(pixaa, L_CLONE);
nbox = boxaGetCount(boxa1);
if (w == 0 || h == 0) {
if (nbox == n)
boxaGetExtent(boxa1, &w, &h, NULL);
else { /* have to use the lower-level boxa for each pixa */
wmax = hmax = 0;
for (i = 0; i < n; i++) {
pixa = pixaaGetPixa(pixaa, i, L_CLONE);
boxa = pixaGetBoxa(pixa, L_CLONE);
boxaGetExtent(boxa, &w, &h, NULL);
wmax = L_MAX(wmax, w);
hmax = L_MAX(hmax, h);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
}
w = wmax;
h = hmax;
}
}
/* Get depth from first pix */
pixa = pixaaGetPixa(pixaa, 0, L_CLONE);
pixt = pixaGetPix(pixa, 0, L_CLONE);
d = pixGetDepth(pixt);
pixaDestroy(&pixa);
pixDestroy(&pixt);
if ((pixd = pixCreate(w, h, d)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
x = y = 0;
for (i = 0; i < n; i++) {
pixa = pixaaGetPixa(pixaa, i, L_CLONE);
if (nbox == n)
boxaGetBoxGeometry(boxa1, i, &x, &y, NULL, NULL);
na = pixaGetCount(pixa);
for (j = 0; j < na; j++) {
pixaGetBoxGeometry(pixa, j, &xb, &yb, &wb, &hb);
pixt = pixaGetPix(pixa, j, L_CLONE);
pixRasterop(pixd, x + xb, y + yb, wb, hb, PIX_PAINT, pixt, 0, 0);
pixDestroy(&pixt);
}
pixaDestroy(&pixa);
}
boxaDestroy(&boxa1);
return pixd;
}
/*!
* pixGetWordsInTextlines()
*
* Input: pixs (1 bpp, typ. 300 ppi)
* reduction (1 for input res; 2 for 2x reduction of input res)
* minwidth, minheight (of saved components; smaller are discarded)
* maxwidth, maxheight (of saved components; larger are discarded)
* &boxad (<return> word boxes sorted in textline line order)
* &pixad (<return> word images sorted in textline line order)
* &naindex (<return> index of textline for each word)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) The input should be at a resolution of about 300 ppi.
* The word masks and word images can be computed at either
* 150 ppi or 300 ppi. For the former, set reduction = 2.
* (2) The four size constraints on saved components are all
* scaled by @reduction.
* (3) The result are word images (and their b.b.), extracted in
* textline order, at either full res or 2x reduction,
* and with a numa giving the textline index for each word.
* (4) The pixa and boxa interfaces should make this type of
* application simple to put together. The steps are:
* - optionally reduce by 2x
* - generate first estimate of word masks
* - get b.b. of these, and remove the small and big ones
* - extract pixa of the word images, using the b.b.
* - sort actual word images in textline order (2d)
* - flatten them to a pixa (1d), saving the textline index
* for each pix
* (5) In an actual application, it may be desirable to pre-filter
* the input image to remove large components, to extract
* single columns of text, and to deskew them. For example,
* to remove both large components and small noisy components
* that can interfere with the statistics used to estimate
* parameters for segmenting by words, but still retain text lines,
* the following image preprocessing can be done:
* Pix *pixt = pixMorphSequence(pixs, "c40.1", 0);
* Pix *pixf = pixSelectBySize(pixt, 0, 60, 8,
* L_SELECT_HEIGHT, L_SELECT_IF_LT, NULL);
* pixAnd(pixf, pixf, pixs); // the filtered image
* The closing turns text lines into long blobs, but does not
* significantly increase their height. But if there are many
* small connected components in a dense texture, this is likely
* to generate tall components that will be eliminated in pixf.
*/
l_int32
pixGetWordsInTextlines(PIX *pixs,
l_int32 reduction,
l_int32 minwidth,
l_int32 minheight,
l_int32 maxwidth,
l_int32 maxheight,
BOXA **pboxad,
PIXA **ppixad,
NUMA **pnai)
{
l_int32 maxdil;
BOXA *boxa1, *boxad;
BOXAA *baa;
NUMA *nai;
NUMAA *naa;
PIXA *pixa1, *pixad;
PIX *pix1;
PIXAA *paa;
PROCNAME("pixGetWordsInTextlines");
if (!pboxad || !ppixad || !pnai)
return ERROR_INT("&boxad, &pixad, &nai not all defined", procName, 1);
*pboxad = NULL;
*ppixad = NULL;
*pnai = NULL;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (reduction != 1 && reduction != 2)
return ERROR_INT("reduction not in {1,2}", procName, 1);
if (reduction == 1) {
pix1 = pixClone(pixs);
maxdil = 18;
} else { /* reduction == 2 */
pix1 = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0);
maxdil = 9;
}
/* Get the bounding boxes of the words from the word mask. */
pixWordBoxesByDilation(pix1, maxdil, minwidth, minheight,
maxwidth, maxheight, &boxa1, NULL);
/* Generate a pixa of the word images */
pixa1 = pixaCreateFromBoxa(pix1, boxa1, NULL); /* mask over each word */
/* Sort the bounding boxes of these words by line. We use the
* index mapping to allow identical sorting of the pixa. */
baa = boxaSort2d(boxa1, &naa, -1, -1, 4);
paa = pixaSort2dByIndex(pixa1, naa, L_CLONE);
/* Flatten the word paa */
pixad = pixaaFlattenToPixa(paa, &nai, L_CLONE);
boxad = pixaGetBoxa(pixad, L_COPY);
*pnai = nai;
*pboxad = boxad;
*ppixad = pixad;
pixDestroy(&pix1);
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaaDestroy(&baa);
pixaaDestroy(&paa);
numaaDestroy(&naa);
return 0;
}
l_int32 main(int argc,
char **argv)
{
char *boxatxt;
l_int32 i;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa, *baa1;
NUMAA *naa1;
PIX *pixdb, *pix1, *pix2, *pix3, *pix4;
PIXA *pixa1, *pixa2, *pixa3, *pixat;
L_RECOG *recog;
L_RECOGA *recoga;
SARRAY *sa1;
/* ----- Example identifying samples using training data ----- */
#if 1
/* Read the training data */
pixat = pixaRead("recog/sets/train06.pa");
recog = recogCreateFromPixa(pixat, 0, 0, L_USE_ALL, 128, 1, "fonts");
recoga = recogaCreateFromRecog(recog);
pixaDestroy(&pixat);
/* Read the data from all samples */
pix1 = pixRead("recog/sets/samples06.png");
boxatxt = pixGetText(pix1);
boxa1 = boxaReadMem((l_uint8 *)boxatxt, strlen(boxatxt));
pixa1 = pixaCreateFromBoxa(pix1, boxa1, NULL);
pixDestroy(&pix1); /* destroys boxa1 */
/* Identify components in the sample data */
pixa2 = pixaCreate(0);
pixa3 = pixaCreate(0);
for (i = 0; i < 9; i++) {
/* if (i != 4) continue; */ /* dots form separate boxa */
/* if (i != 8) continue; */ /* broken 2 in '24' */
pix1 = pixaGetPix(pixa1, i, L_CLONE);
/* Show the 2d box data in the sample */
boxa2 = pixConnComp(pix1, NULL, 8);
baa = boxaSort2d(boxa2, NULL, 6, 6, 5);
pix2 = boxaaDisplay(baa, 3, 1, 0xff000000, 0x00ff0000, 0, 0);
pixaAddPix(pixa3, pix2, L_INSERT);
boxaaDestroy(&baa);
boxaDestroy(&boxa2);
/* Get the numbers in the sample */
recogaIdentifyMultiple(recoga, pix1, 0, 5, 3, &boxa3, NULL, &pixdb, 0);
sa1 = recogaExtractNumbers(recoga, boxa3, 0.7, -1, &baa1, &naa1);
sarrayWriteStream(stderr, sa1);
boxaaWriteStream(stderr, baa1);
numaaWriteStream(stderr, naa1);
pixaAddPix(pixa2, pixdb, L_INSERT);
/* pixaWrite("/tmp/pixa.pa", pixa2); */
pixDestroy(&pix1);
boxaDestroy(&boxa3);
boxaaDestroy(&baa1);
numaaDestroy(&naa1);
sarrayDestroy(&sa1);
}
pix3 = pixaDisplayLinearly(pixa2, L_VERT, 1.0, 0, 20, 1, NULL);
pixWrite("/tmp/pix3.png", pix3, IFF_PNG);
pix4 = pixaDisplayTiledInRows(pixa3, 32, 1500, 1.0, 0, 20, 2);
pixDisplay(pix4, 500, 0);
pixWrite("/tmp/pix4.png", pix4, IFF_PNG);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixDestroy(&pix1);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
recogaDestroy(&recoga);
#endif
return 0;
}
int main(int argc,
char **argv)
{
l_int32 index;
l_uint32 val32;
BOX *box, *box1, *box2, *box3, *box4, *box5;
BOXA *boxa;
L_KERNEL *kel;
PIX *pixs, *pixg, *pixb, *pixd, *pixt, *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Color non-white pixels on RGB */
pixs = pixRead("lucasta-frag.jpg");
pixt = pixConvert8To32(pixs);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_DARK, 220, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 0 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_DARK, 220, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-white pixels on colormap */
pixt = pixThresholdTo4bpp(pixs, 6, 1);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_DARK, 220, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_DARK, 220, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 3 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-black pixels on RGB */
pixt = pixConvert8To32(pixs);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_LIGHT, 20, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_LIGHT, 80, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-black pixels on colormap */
pixt = pixThresholdTo4bpp(pixs, 6, 1);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_LIGHT, 20, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 6 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_LIGHT, 20, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 7 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Add highlight color to RGB */
pixt = pixConvert8To32(pixs);
box = boxCreate(507, 5, 385, 45);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
pixDisplayWrite(pixb, 1);
composeRGBPixel(50, 0, 250, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
box = boxCreate(236, 107, 262, 40);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
composeRGBPixel(250, 0, 50, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
box = boxCreate(222, 208, 247, 43);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
composeRGBPixel(60, 250, 60, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 8 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Add highlight color to colormap */
pixt = pixThresholdTo4bpp(pixs, 5, 1);
cmap = pixGetColormap(pixt);
pixcmapGetIndex(cmap, 255, 255, 255, &index);
box = boxCreate(507, 5, 385, 45);
pixSetSelectCmap(pixt, box, index, 50, 0, 250);
boxDestroy(&box);
box = boxCreate(236, 107, 262, 40);
pixSetSelectCmap(pixt, box, index, 250, 0, 50);
boxDestroy(&box);
box = boxCreate(222, 208, 247, 43);
pixSetSelectCmap(pixt, box, index, 60, 250, 60);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 9 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Paint lines on RGB */
pixt = pixConvert8To32(pixs);
pixRenderLineArb(pixt, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt, 30, 40, 440, 40, 5, 100, 200, 25);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxArb(pixt, box, 3, 200, 200, 25);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 10 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Paint lines on colormap */
pixt = pixThresholdTo4bpp(pixs, 5, 1);
pixRenderLineArb(pixt, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt, 30, 40, 440, 40, 5, 100, 200, 25);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxArb(pixt, box, 3, 200, 200, 25);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 11 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Blend lines on RGB */
pixt = pixConvert8To32(pixs);
pixRenderLineBlend(pixt, 450, 20, 850, 320, 5, 200, 50, 125, 0.35);
pixRenderLineBlend(pixt, 30, 40, 440, 40, 5, 100, 200, 25, 0.35);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxBlend(pixt, box, 3, 200, 200, 25, 0.6);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 12 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Colorize gray on cmapped image. */
pix1 = pixRead("lucasta.150.jpg");
pix2 = pixThresholdTo4bpp(pix1, 7, 1);
box1 = boxCreate(73, 206, 140, 27);
pixColorGrayCmap(pix2, box1, L_PAINT_LIGHT, 130, 207, 43);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 13 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "One box added");
box2 = boxCreate(255, 404, 197, 25);
pixColorGrayCmap(pix2, box2, L_PAINT_LIGHT, 230, 67, 119);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 14 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Two boxes added");
box3 = boxCreate(122, 756, 224, 22);
pixColorGrayCmap(pix2, box3, L_PAINT_DARK, 230, 67, 119);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 15 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Three boxes added");
box4 = boxCreate(11, 780, 147, 22);
pixColorGrayCmap(pix2, box4, L_PAINT_LIGHT, 70, 137, 229);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 16 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Four boxes added");
box5 = boxCreate(163, 605, 78, 22);
pixColorGrayCmap(pix2, box5, L_PAINT_LIGHT, 70, 137, 229);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 17 */
pixaAddPix(pixa, pix2, L_INSERT);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Five boxes added");
pixDestroy(&pix1);
boxDestroy(&box1);
boxDestroy(&box2);
boxDestroy(&box3);
boxDestroy(&box4);
boxDestroy(&box5);
pixDestroy(&pixs);
/* Make a gray image and identify the fg pixels (val > 230) */
pixs = pixRead("feyn-fract.tif");
pix1 = pixConvertTo8(pixs, 0);
kel = makeGaussianKernel(2, 2, 1.5, 1.0);
pix2 = pixConvolve(pix1, kel, 8, 1);
pix3 = pixThresholdToBinary(pix2, 230);
boxa = pixConnComp(pix3, NULL, 8);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix3);
kernelDestroy(&kel);
/* Color the individual components in the gray image */
pix4 = pixColorGrayRegions(pix2, boxa, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 18 */
pixaAddPix(pixa, pix4, L_INSERT);
pixDisplayWithTitle(pix4, 0, 0, NULL, rp->display);
/* Threshold to 10 levels of gray */
pix3 = pixThresholdOn8bpp(pix2, 10, 1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 19 */
pixaAddPix(pixa, pix3, L_COPY);
/* Color the individual components in the cmapped image */
pix4 = pixColorGrayRegions(pix3, boxa, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 20 */
pixaAddPix(pixa, pix4, L_INSERT);
pixDisplayWithTitle(pix4, 0, 100, NULL, rp->display);
boxaDestroy(&boxa);
/* Color the entire gray image (not component-wise) */
pixColorGray(pix2, NULL, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 21 */
pixaAddPix(pixa, pix2, L_INSERT);
/* Color the entire cmapped image (not component-wise) */
pixColorGray(pix3, NULL, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 22 */
pixaAddPix(pixa, pix3, L_INSERT);
/* Reconstruct cmapped images */
pixd = ReconstructByValue(rp, "weasel2.4c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 23 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = ReconstructByValue(rp, "weasel4.11c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 24 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = ReconstructByValue(rp, "weasel8.240c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 25 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Fake reconstruct cmapped images, with one color into a band */
pixd = FakeReconstructByBand(rp, "weasel2.4c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 26 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = FakeReconstructByBand(rp, "weasel4.11c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 27 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = FakeReconstructByBand(rp, "weasel8.240c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 28 */
pixaAddPix(pixa, pixd, L_INSERT);
/* If in testing mode, make a pdf */
if (rp->display) {
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0,
"Colorize and paint", "/tmp/paint.pdf");
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
void static
TestBoxa(L_REGPARAMS *rp,
l_int32 index)
{
l_uint8 *data;
l_int32 w, h, medw, medh, isame;
size_t size;
l_float32 scalefact, devw, devh, ratiowh, fvarp, fvarm;
BOXA *boxa1, *boxa2, *boxa3;
PIX *pix1;
boxa1 = boxaRead(boxafiles[index]);
/* Read and display initial boxa */
boxaGetExtent(boxa1, &w, &h, NULL);
scalefact = 100.0 / (l_float32)w;
boxa2 = boxaTransform(boxa1, 0, 0, scalefact, scalefact);
boxaWriteMem(&data, &size, boxa2);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 0, 13, 26 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa2, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 1, 14, 27 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
/* Find the median sizes */
boxaMedianDimensions(boxa2, &medw, &medh, NULL, NULL, NULL, NULL,
NULL, NULL);
if (rp->display)
fprintf(stderr, "median width = %d, median height = %d\n", medw, medh);
/* Check for deviations from median by pairs: method 1 */
boxaSizeConsistency1(boxa2, L_CHECK_HEIGHT, 0.0, 0.0,
&fvarp, &fvarm, &isame);
regTestCompareValues(rp, varp[index], fvarp, 0.003); /* 2, 15, 28 */
regTestCompareValues(rp, varm[index], fvarm, 0.003); /* 3, 16, 29 */
regTestCompareValues(rp, same[index], isame, 0); /* 4, 17, 30 */
if (rp->display)
fprintf(stderr, "fvarp = %7.4f, fvarm = %7.4f, same = %d\n",
fvarp, fvarm, isame);
/* Check for deviations from median by pairs: method 2 */
boxaSizeConsistency2(boxa2, &devw, &devh, 0);
regTestCompareValues(rp, devwidth[index], devw, 0.001); /* 5, 18, 31 */
regTestCompareValues(rp, devheight[index], devh, 0.001); /* 6, 19, 32 */
if (rp->display)
fprintf(stderr, "dev width = %7.4f, dev height = %7.4f\n", devw, devh);
/* Reconcile widths */
boxa3 = boxaReconcileSizeByMedian(boxa2, L_CHECK_WIDTH, 0.05, 0.04, 1.03,
NULL, NULL, &ratiowh);
boxaWriteMem(&data, &size, boxa3);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 7, 20, 33 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa3, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8, 21, 34 */
pixDisplayWithTitle(pix1, 500, 0, NULL, rp->display);
if (rp->display)
fprintf(stderr, "ratio median width/height = %6.3f\n", ratiowh);
boxaDestroy(&boxa3);
pixDestroy(&pix1);
/* Reconcile heights */
boxa3 = boxaReconcileSizeByMedian(boxa2, L_CHECK_HEIGHT, 0.05, 0.04, 1.03,
NULL, NULL, NULL);
boxaWriteMem(&data, &size, boxa3);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 9, 22, 35 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa3, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 10, 23, 36 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
boxaDestroy(&boxa3);
pixDestroy(&pix1);
/* Reconcile both widths and heights */
boxa3 = boxaReconcileSizeByMedian(boxa2, L_CHECK_BOTH, 0.05, 0.04, 1.03,
NULL, NULL, NULL);
boxaWriteMem(&data, &size, boxa3);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 11, 24, 37 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa3, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12, 25, 38 */
pixDisplayWithTitle(pix1, 1500, 0, NULL, rp->display);
boxaDestroy(&boxa3);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
}
int main(int argc,
char **argv) {
char buffer[512];
char *tempfile1, *tempfile2;
l_uint8 *data;
l_int32 i, j, w, h, seq, ret, same;
size_t nbytes;
const char *title;
BOX *box;
BOXA *boxa1, *boxa2;
L_BYTEA *ba;
L_PDF_DATA *lpd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixt, *pixg, *pixgc, *pixc;
static char mainName[] = "pdfiotest";
if (argc != 1)
return ERROR_INT("syntax: pdfiotest", mainName, 1);
l_pdfSetDateAndVersion(0);
lept_mkdir("pdf");
#if 1
/* --------------- Single image tests ------------------- */
fprintf(stderr, "\n*** Writing single images as pdf files\n");
convertToPdf("weasel2.4c.png", L_FLATE_ENCODE, 0, "/tmp/pdf/file01.pdf",
0, 0, 72, "weasel2.4c.png", NULL, 0);
convertToPdf("test24.jpg", L_JPEG_ENCODE, 0, "/tmp/pdf/file02.pdf",
0, 0, 72, "test24.jpg", NULL, 0);
convertToPdf("feyn.tif", L_G4_ENCODE, 0, "/tmp/pdf/file03.pdf",
0, 0, 300, "feyn.tif", NULL, 0);
pixs = pixRead("feyn.tif");
pixConvertToPdf(pixs, L_G4_ENCODE, 0, "/tmp/pdf/file04.pdf", 0, 0, 300,
"feyn.tif", NULL, 0);
pixDestroy(&pixs);
pixs = pixRead("test24.jpg");
pixConvertToPdf(pixs, L_JPEG_ENCODE, 5, "/tmp/pdf/file05.pdf", 0, 0, 72,
"test24.jpg", NULL, 0);
pixDestroy(&pixs);
pixs = pixRead("feyn.tif");
pixt = pixScaleToGray2(pixs);
pixWrite("/tmp/pdf/feyn8.png", pixt, IFF_PNG);
convertToPdf("/tmp/pdf/feyn8.png", L_JPEG_ENCODE, 0, "/tmp/pdf/file06.pdf",
0, 0, 150, "feyn8.png", NULL, 0);
pixDestroy(&pixs);
pixDestroy(&pixt);
convertToPdf("weasel4.16g.png", L_FLATE_ENCODE, 0, "/tmp/pdf/file07.pdf",
0, 0, 30, "weasel4.16g.png", NULL, 0);
pixs = pixRead("test24.jpg");
pixg = pixConvertTo8(pixs, 0);
box = boxCreate(100, 100, 100, 100);
pixc = pixClipRectangle(pixs, box, NULL);
pixgc = pixClipRectangle(pixg, box, NULL);
pixWrite("/tmp/pdf/pix32.jpg", pixc, IFF_JFIF_JPEG);
pixWrite("/tmp/pdf/pix8.jpg", pixgc, IFF_JFIF_JPEG);
convertToPdf("/tmp/pdf/pix32.jpg", L_FLATE_ENCODE, 0, "/tmp/pdf/file08.pdf",
0, 0, 72, "pix32.jpg", NULL, 0);
convertToPdf("/tmp/pdf/pix8.jpg", L_FLATE_ENCODE, 0, "/tmp/pdf/file09.pdf",
0, 0, 72, "pix8.jpg", NULL, 0);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixc);
pixDestroy(&pixgc);
boxDestroy(&box);
#endif
#if 1
/* --------------- Multiple image tests ------------------- */
fprintf(stderr, "\n*** Writing multiple images as single page pdf files\n");
pix1 = pixRead("feyn-fract.tif");
pix2 = pixRead("weasel8.240c.png");
/* l_pdfSetDateAndVersion(0); */
/* First, write the 1 bpp image through the mask onto the weasels */
for (i = 0; i < 5; i++) {
for (j = 0; j < 10; j++) {
seq = (i == 0 && j == 0) ? L_FIRST_IMAGE : L_NEXT_IMAGE;
title = (i == 0 && j == 0) ? "feyn-fract.tif" : NULL;
pixConvertToPdf(pix2, L_FLATE_ENCODE, 0, NULL, 100 * j,
100 * i, 70, title, &lpd, seq);
}
}
pixConvertToPdf(pix1, L_G4_ENCODE, 0, "/tmp/pdf/file10.pdf", 0, 0, 80,
NULL, &lpd, L_LAST_IMAGE);
/* Now, write the 1 bpp image over the weasels */
l_pdfSetG4ImageMask(0);
for (i = 0; i < 5; i++) {
for (j = 0; j < 10; j++) {
seq = (i == 0 && j == 0) ? L_FIRST_IMAGE : L_NEXT_IMAGE;
title = (i == 0 && j == 0) ? "feyn-fract.tif" : NULL;
pixConvertToPdf(pix2, L_FLATE_ENCODE, 0, NULL, 100 * j,
100 * i, 70, title, &lpd, seq);
}
}
pixConvertToPdf(pix1, L_G4_ENCODE, 0, "/tmp/pdf/file11.pdf", 0, 0, 80,
NULL, &lpd, L_LAST_IMAGE);
l_pdfSetG4ImageMask(1);
pixDestroy(&pix1);
pixDestroy(&pix2);
#endif
#if 1
/* -------- pdf convert segmented with no image regions -------- */
fprintf(stderr, "\n*** Writing segmented images without image regions\n");
pix1 = pixRead("rabi.png");
pix2 = pixScaleToGray2(pix1);
pixWrite("/tmp/pdf/rabi8.jpg", pix2, IFF_JFIF_JPEG);
pix3 = pixThresholdTo4bpp(pix2, 16, 1);
pixWrite("/tmp/pdf/rabi4.png", pix3, IFF_PNG);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 1 bpp input */
convertToPdfSegmented("rabi.png", 300, L_G4_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/pdf/file12.pdf");
convertToPdfSegmented("rabi.png", 300, L_JPEG_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/pdf/file13.pdf");
convertToPdfSegmented("rabi.png", 300, L_FLATE_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/pdf/file14.pdf");
/* 8 bpp input, no cmap */
convertToPdfSegmented("/tmp/pdf/rabi8.jpg", 150, L_G4_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/pdf/file15.pdf");
convertToPdfSegmented("/tmp/pdf/rabi8.jpg", 150, L_JPEG_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/pdf/file16.pdf");
convertToPdfSegmented("/tmp/pdf/rabi8.jpg", 150, L_FLATE_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/pdf/file17.pdf");
/* 4 bpp input, cmap */
convertToPdfSegmented("/tmp/pdf/rabi4.png", 150, L_G4_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/pdf/file18.pdf");
convertToPdfSegmented("/tmp/pdf/rabi4.png", 150, L_JPEG_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/pdf/file19.pdf");
convertToPdfSegmented("/tmp/pdf/rabi4.png", 150, L_FLATE_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/pdf/file20.pdf");
#endif
#if 1
/* ---------- pdf convert segmented with image regions ---------- */
fprintf(stderr, "\n*** Writing segmented images with image regions\n");
/* Get the image region(s) for rabi.png. There are two
* small bogus regions at the top, but we'll keep them for
* the demonstration. */
pix1 = pixRead("rabi.png");
pixSetResolution(pix1, 300, 300);
pixGetDimensions(pix1, &w, &h, NULL);
pix2 = pixGenHalftoneMask(pix1, NULL, NULL, 0);
pix3 = pixMorphSequence(pix2, "c20.1 + c1.20", 0);
boxa1 = pixConnComp(pix3, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 1 bpp input */
convertToPdfSegmented("rabi.png", 300, L_G4_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/pdf/file21.pdf");
convertToPdfSegmented("rabi.png", 300, L_JPEG_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/pdf/file22.pdf");
convertToPdfSegmented("rabi.png", 300, L_FLATE_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/pdf/file23.pdf");
/* 8 bpp input, no cmap */
convertToPdfSegmented("/tmp/pdf/rabi8.jpg", 150, L_G4_ENCODE, 128, boxa2,
0, 0.5, NULL, "/tmp/pdf/file24.pdf");
convertToPdfSegmented("/tmp/pdf/rabi8.jpg", 150, L_JPEG_ENCODE, 128, boxa2,
0, 0.5, NULL, "/tmp/pdf/file25.pdf");
convertToPdfSegmented("/tmp/pdf/rabi8.jpg", 150, L_FLATE_ENCODE, 128, boxa2,
0, 0.5, NULL, "/tmp/pdf/file26.pdf");
/* 4 bpp input, cmap */
convertToPdfSegmented("/tmp/pdf/rabi4.png", 150, L_G4_ENCODE, 128, boxa2,
0, 0.5, NULL, "/tmp/pdf/file27.pdf");
convertToPdfSegmented("/tmp/pdf/rabi4.png", 150, L_JPEG_ENCODE, 128, boxa2,
0, 0.5, NULL, "/tmp/pdf/file28.pdf");
convertToPdfSegmented("/tmp/pdf/rabi4.png", 150, L_FLATE_ENCODE, 128, boxa2,
0, 0.5, NULL, "/tmp/pdf/file29.pdf");
/* 4 bpp input, cmap, data output */
data = NULL;
convertToPdfDataSegmented("/tmp/pdf/rabi4.png", 150, L_G4_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/pdf/file30.pdf", "w", data, nbytes);
lept_free(data);
convertToPdfDataSegmented("/tmp/pdf/rabi4.png", 150, L_JPEG_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/pdf/file31.pdf", "w", data, nbytes);
lept_free(data);
convertToPdfDataSegmented("/tmp/pdf/rabi4.png", 150, L_FLATE_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/pdf/file32.pdf", "w", data, nbytes);
lept_free(data);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
/* -------- pdf convert segmented from color image -------- */
fprintf(stderr, "\n*** Writing color segmented images\n");
pix1 = pixRead("candelabrum-11.jpg");
pix2 = pixScale(pix1, 3.0, 3.0);
pixWrite("/tmp/pdf/candelabrum3.jpg", pix2, IFF_JFIF_JPEG);
GetImageMask(pix2, 200, &boxa1, "/tmp/pdf/seg1.jpg");
convertToPdfSegmented("/tmp/pdf/candelabrum3.jpg", 200, L_G4_ENCODE,
100, boxa1, 0, 0.25, NULL, "/tmp/pdf/file33.pdf");
convertToPdfSegmented("/tmp/pdf/candelabrum3.jpg", 200, L_JPEG_ENCODE,
100, boxa1, 0, 0.25, NULL, "/tmp/pdf/file34.pdf");
convertToPdfSegmented("/tmp/pdf/candelabrum3.jpg", 200, L_FLATE_ENCODE,
100, boxa1, 0, 0.25, NULL, "/tmp/pdf/file35.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
pix1 = pixRead("lion-page.00016.jpg");
pix2 = pixScale(pix1, 3.0, 3.0);
pixWrite("/tmp/pdf/lion16.jpg", pix2, IFF_JFIF_JPEG);
pix3 = pixRead("lion-mask.00016.tif");
boxa1 = pixConnComp(pix3, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, 3.0, 3.0);
convertToPdfSegmented("/tmp/pdf/lion16.jpg", 200, L_G4_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/pdf/file36.pdf");
convertToPdfSegmented("/tmp/pdf/lion16.jpg", 200, L_JPEG_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/pdf/file37.pdf");
convertToPdfSegmented("/tmp/pdf/lion16.jpg", 200, L_FLATE_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/pdf/file38.pdf");
/* Quantize the non-image part and flate encode.
* This is useful because it results in a smaller file than
* when you flate-encode the un-quantized non-image regions. */
pix4 = pixScale(pix3, 3.0, 3.0); /* higher res mask, for combining */
pix5 = QuantizeNonImageRegion(pix2, pix4, 12);
pixWrite("/tmp/pdf/lion16-quant.png", pix5, IFF_PNG);
convertToPdfSegmented("/tmp/pdf/lion16-quant.png", 200, L_FLATE_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/pdf/file39.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
/* ------------------ Test multipage pdf generation ----------------- */
fprintf(stderr, "\n*** Writing multipage pdfs from single page pdfs\n");
/* Generate a multi-page pdf from all these files */
startTimer();
concatenatePdf("/tmp/pdf", "file", "/tmp/pdf/cat_lept.pdf");
fprintf(stderr, "All files have been concatenated: /tmp/pdf/cat_lept.pdf\n"
"Concatenation time: %7.3f\n", stopTimer());
#endif
#if 1
/* -------------------- Test corruption recovery ------------------- */
/* Put two good pdf files in a directory */
lept_mkdir("good");
lept_cp("testfile1.pdf", "good", NULL, NULL);
lept_cp("testfile2.pdf", "good", NULL, NULL);
concatenatePdf("/tmp/good", "file", "/tmp/pdf/good.pdf");
/* Make a version with the pdf id removed, so that it is not
* recognized as a pdf */
ba = l_byteaInitFromFile("testfile2.pdf");
data = l_byteaGetData(ba, &nbytes);
l_binaryWrite("testfile0.notpdf.pdf", "w", data + 10, nbytes - 10);
/* Make a version with a corrupted trailer */
if (data)
data[2297] = '2'; /* munge trailer object 6: change 458 --> 428 */
l_binaryWrite("testfile2.bad.pdf", "w", data, nbytes);
/* Put these two bad files, along with a good file, in a directory */
lept_mkdir("bad");
lept_mv("testfile0.notpdf.pdf", "bad", NULL, NULL);
lept_cp("testfile1.pdf", "bad", NULL, NULL);
lept_mv("testfile2.bad.pdf", "bad", NULL, NULL);
l_byteaDestroy(&ba);
/* Run concat on the bad files. In the /tmp/bad/ directory,
* the "not pdf" file should be ignored, and the corrupted pdf
* file should be properly parsed, so the resulting
* concatenated files should be identical. */
fprintf(stderr, "\nWe attempt to build from the bad directory\n");
concatenatePdf("/tmp/bad", "file", "/tmp/pdf/bad.pdf");
filesAreIdentical("/tmp/pdf/good.pdf", "/tmp/pdf/bad.pdf", &same);
if (same)
fprintf(stderr, "Fixed: files are the same\n"
"Attempt succeeded\n\n");
else
fprintf(stderr, "Busted: files are different\n");
/* pdftk fails because the first file is not a pdf */
fprintf(stderr, "pdftk attempts to build from the bad directory\n");
tempfile1 = genPathname("/tmp/bad", "*.pdf");
tempfile2 = genPathname("/tmp", "pdftk.bad.pdf");
snprintf(buffer, sizeof(buffer), "pdftk %s output %s",
tempfile1, tempfile2);
ret = system(buffer); /* pdftk */
lept_free(tempfile1);
lept_free(tempfile2);
fprintf(stderr, "Attempt failed\n\n");
#endif
#if 1
fprintf(stderr, "\n*** pdftk writes multipage pdfs from images\n");
tempfile1 = genPathname("/tmp/pdf", "file*.pdf");
tempfile2 = genPathname("/tmp/pdf", "cat_pdftk.pdf");
snprintf(buffer, sizeof(buffer), "pdftk %s output %s",
tempfile1, tempfile2);
ret = system(buffer); /* pdftk */
lept_free(tempfile1);
lept_free(tempfile2);
#endif
#if 1
/* -- Test simple interface for generating multi-page pdf from images -- */
fprintf(stderr, "\n*** Writing multipage pdfs from images\n");
/* Put four image files in a directory. They will be encoded thus:
* file1.png: flate (8 bpp, only 10 colors)
* file2.jpg: dct (8 bpp, 256 colors because of the jpeg encoding)
* file3.tif: g4 (1 bpp)
* file4.jpg: dct (32 bpp) */
lept_mkdir("image");
pix1 = pixRead("feyn.tif");
pix2 = pixRead("rabi.png");
pix3 = pixScaleToGray3(pix1);
pix4 = pixScaleToGray3(pix2);
pix5 = pixScale(pix1, 0.33, 0.33);
pix6 = pixRead("test24.jpg");
pixWrite("/tmp/image/file1.png", pix3, IFF_PNG); /* 10 colors */
pixWrite("/tmp/image/file2.jpg", pix4, IFF_JFIF_JPEG); /* 256 colors */
pixWrite("/tmp/image/file3.tif", pix5, IFF_TIFF_G4);
pixWrite("/tmp/image/file4.jpg", pix6, IFF_JFIF_JPEG);
startTimer();
convertFilesToPdf("/tmp/image", "file", 100, 0.8, 0, 75, "4 file test",
"/tmp/pdf/fourimages.pdf");
fprintf(stderr, "4-page pdf generated: /tmp/pdf/fourimages.pdf\n"
"Time: %7.3f\n", stopTimer());
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
#endif
return 0;
}
void Java_com_googlecode_leptonica_android_Boxa_nativeDestroy(JNIEnv *env, jclass clazz,
jlong nativeBoxa) {
BOXA *boxa = (BOXA *) nativeBoxa;
boxaDestroy(&boxa);
}
int main(int argc,
char **argv)
{
l_uint8 *array1, *array2;
l_int32 i, n1, n2, n3;
size_t size1, size2;
FILE *fp;
BOXA *boxa1, *boxa2;
PIX *pixs, *pix1, *pix2, *pix3;
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, 0);
boxaDestroy(&boxa1);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixDestroy(&pixs);
/* --------------------------------------------------------------- *
* Test iterative covering of connected components by rectangles *
* --------------------------------------------------------------- */
pixa1 = pixaCreate(0);
pix1 = pixRead("rabi.png");
pix2 = pixReduceRankBinaryCascade(pix1, 1, 1, 1, 0);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 12 - */
pixaAddPix(pixa1, pix2, L_INSERT);
for (i = 1; i < 6; i++) {
pix3 = pixMakeCoveringOfRectangles(pix2, i);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 13 - 17 */
pixaAddPix(pixa1, pix3, L_INSERT);
}
pix3 = pixaDisplayTiledInRows(pixa1, 1, 2500, 1.0, 0, 30, 0);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 18 */
pixDisplayWithTitle(pix3, 100, 900, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix3);
pixaDestroy(&pixa1);
return regTestCleanup(rp);
}
/**********************************************************************
* cube_recognize
*
* Call cube on the current word, and write the result to word.
* Sets up a fake result and returns false if something goes wrong.
**********************************************************************/
bool Tesseract::cube_recognize(CubeObject *cube_obj, BLOCK* block,
WERD_RES *word) {
// Run cube
WordAltList *cube_alt_list = cube_obj->RecognizeWord();
if (!cube_alt_list || cube_alt_list->AltCount() <= 0) {
if (cube_debug_level > 0) {
tprintf("Cube returned nothing for word at:");
word->word->bounding_box().print();
}
word->SetupFake(unicharset);
return false;
}
// Get cube's best result and its probability, mapped to tesseract's
// certainty range
char_32 *cube_best_32 = cube_alt_list->Alt(0);
double cube_prob = CubeUtils::Cost2Prob(cube_alt_list->AltCost(0));
float cube_certainty = convert_prob_to_tess_certainty(cube_prob);
string cube_best_str;
CubeUtils::UTF32ToUTF8(cube_best_32, &cube_best_str);
// Retrieve Cube's character bounding boxes and CharSamples,
// corresponding to the most recent call to RecognizeWord().
Boxa *char_boxes = NULL;
CharSamp **char_samples = NULL;;
int num_chars;
if (!extract_cube_state(cube_obj, &num_chars, &char_boxes, &char_samples)
&& cube_debug_level > 0) {
tprintf("Cube WARNING (Tesseract::cube_recognize): Cannot extract "
"cube state.\n");
word->SetupFake(unicharset);
return false;
}
// Convert cube's character bounding boxes to a BoxWord.
BoxWord cube_box_word;
TBOX tess_word_box = word->word->bounding_box();
if (word->denorm.block() != NULL)
tess_word_box.rotate(word->denorm.block()->re_rotation());
bool box_word_success = create_cube_box_word(char_boxes, num_chars,
tess_word_box,
&cube_box_word);
boxaDestroy(&char_boxes);
if (!box_word_success) {
if (cube_debug_level > 0) {
tprintf("Cube WARNING (Tesseract::cube_recognize): Could not "
"create cube BoxWord\n");
}
word->SetupFake(unicharset);
return false;
}
// Fill tesseract result's fields with cube results
fill_werd_res(cube_box_word, cube_best_str.c_str(), word);
// Create cube's best choice.
BLOB_CHOICE** choices = new BLOB_CHOICE*[num_chars];
for (int i = 0; i < num_chars; ++i) {
UNICHAR_ID uch_id =
cube_cntxt_->CharacterSet()->UnicharID(char_samples[i]->StrLabel());
choices[i] = new BLOB_CHOICE(uch_id, -cube_certainty, cube_certainty,
-1, -1, 0, 0, 0, 0, BCC_STATIC_CLASSIFIER);
}
word->FakeClassifyWord(num_chars, choices);
// within a word, cube recognizes the word in reading order.
word->best_choice->set_unichars_in_script_order(true);
delete [] choices;
delete [] char_samples;
// Some sanity checks
ASSERT_HOST(word->best_choice->length() == word->reject_map.length());
if (cube_debug_level || classify_debug_level) {
tprintf("Cube result: %s r=%g, c=%g\n",
word->best_choice->unichar_string().string(),
word->best_choice->rating(),
word->best_choice->certainty());
}
return true;
}
/**********************************************************************
* cube_recognize
*
* Call cube on the current word, and write the result to word.
* Sets up a fake result and returns false if something goes wrong.
**********************************************************************/
bool Tesseract::cube_recognize(CubeObject *cube_obj, BLOCK* block,
WERD_RES *word) {
if (!word->SetupForCubeRecognition(unicharset, this, block)) {
return false; // Graphics block.
}
// Run cube
WordAltList *cube_alt_list = cube_obj->RecognizeWord();
if (!cube_alt_list || cube_alt_list->AltCount() <= 0) {
if (cube_debug_level > 0) {
tprintf("Cube returned nothing for word at:");
word->word->bounding_box().print();
}
word->SetupFake(unicharset);
return false;
}
// Get cube's best result and its probability, mapped to tesseract's
// certainty range
char_32 *cube_best_32 = cube_alt_list->Alt(0);
double cube_prob = CubeUtils::Cost2Prob(cube_alt_list->AltCost(0));
float cube_certainty = convert_prob_to_tess_certainty(cube_prob);
std::string cube_best_str;
CubeUtils::UTF32ToUTF8(cube_best_32, &cube_best_str);
// Retrieve Cube's character bounding boxes and CharSamples,
// corresponding to the most recent call to RecognizeWord().
Boxa *char_boxes = NULL;
CharSamp **char_samples = NULL;;
int num_chars;
if (!extract_cube_state(cube_obj, &num_chars, &char_boxes, &char_samples)
&& cube_debug_level > 0) {
tprintf("Cube WARNING (Tesseract::cube_recognize): Cannot extract "
"cube state.\n");
word->SetupFake(unicharset);
return false;
}
// Convert cube's character bounding boxes to a BoxWord.
BoxWord cube_box_word;
TBOX tess_word_box = word->word->bounding_box();
if (word->denorm.block() != NULL)
tess_word_box.rotate(word->denorm.block()->re_rotation());
bool box_word_success = create_cube_box_word(char_boxes, num_chars,
tess_word_box,
&cube_box_word);
boxaDestroy(&char_boxes);
if (!box_word_success) {
if (cube_debug_level > 0) {
tprintf("Cube WARNING (Tesseract::cube_recognize): Could not "
"create cube BoxWord\n");
}
word->SetupFake(unicharset);
return false;
}
// Create cube's best choice.
WERD_CHOICE* cube_werd_choice = create_werd_choice(
char_samples, num_chars, cube_best_str.c_str(), cube_certainty,
unicharset, cube_cntxt_->CharacterSet());
delete []char_samples;
if (!cube_werd_choice) {
if (cube_debug_level > 0) {
tprintf("Cube WARNING (Tesseract::cube_recognize): Could not "
"create cube WERD_CHOICE\n");
}
word->SetupFake(unicharset);
return false;
}
if (cube_debug_level || classify_debug_level) {
tprintf("Cube result: %s r=%g, c=%g\n",
cube_werd_choice->unichar_string().string(),
cube_werd_choice->rating(),
cube_werd_choice->certainty());
}
// Fill tesseract result's fields with cube results
fill_werd_res(cube_box_word, cube_werd_choice, cube_best_str.c_str(), word);
return true;
}
main(int argc,
char **argv)
{
l_int32 w, h;
BOXA *boxa;
PIX *pixs, *pixt1, *pixt2, *pixg, *pixb, *pixd, *pixc;
PIX *pixm, *pixm2, *pixd2, *pixs2;
PIXA *pixa, *pixac;
PIXCMAP *cmap, *cmapg;
static char mainName[] = "misctest1";
pixac = pixaCreate(0);
/* Combine two grayscale images using a mask */
pixd = pixRead("feyn.tif");
pixs = pixRead("rabi.png");
pixm = pixRead("pageseg2-seed.png");
pixd2 = pixScaleToGray2(pixd);
pixs2 = pixScaleToGray2(pixs);
pixSaveTiled(pixd2, pixac, 2, 1, 40, 32);
pixSaveTiled(pixs2, pixac, 2, 0, 40, 0);
pixSaveTiled(pixm, pixac, 2, 0, 40, 0);
pixCombineMaskedGeneral(pixd2, pixs2, pixm, 100, 100);
pixSaveTiled(pixd2, pixac, 2, 1, 40, 0);
pixDisplayWithTitle(pixd2, 100, 100, NULL, SHOW);
pixDestroy(&pixd2);
pixDestroy(&pixs2);
/* Combine two binary images using a mask */
pixm2 = pixExpandBinaryReplicate(pixm, 2);
pixt1 = pixCopy(NULL, pixd);
pixCombineMaskedGeneral(pixd, pixs, pixm2, 200, 200);
pixSaveTiled(pixd, pixac, 4, 0, 40, 0);
pixDisplayWithTitle(pixd, 700, 100, NULL, SHOW);
pixCombineMasked(pixt1, pixs, pixm2);
pixSaveTiled(pixt1, pixac, 4, 0, 40, 0);
pixDestroy(&pixd);
pixDestroy(&pixt1);
pixDestroy(&pixs);
pixDestroy(&pixm);
pixDestroy(&pixm2);
/* Do a restricted seedfill */
pixs = pixRead("pageseg2-seed.png");
pixm = pixRead("pageseg2-mask.png");
pixd = pixSeedfillBinaryRestricted(NULL, pixs, pixm, 8, 50, 175);
pixSaveTiled(pixs, pixac, 2, 1, 40, 0);
pixSaveTiled(pixm, pixac, 2, 0, 40, 0);
pixSaveTiled(pixd, pixac, 2, 0, 40, 0);
pixDestroy(&pixs);
pixDestroy(&pixm);
pixDestroy(&pixd);
/* Colorize a grayscale image */
pixs = pixRead("lucasta.150.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
pixb = pixThresholdToBinary(pixs, 128);
boxa = pixConnComp(pixb, &pixa, 8);
pixSaveTiled(pixs, pixac, 1, 1, 40, 0);
cmap = pixcmapGrayToColor(0x6f90c0);
pixSetColormap(pixs, cmap);
pixSaveTiled(pixs, pixac, 1, 0, 40, 0);
pixc = pixaDisplayRandomCmap(pixa, w, h);
pixcmapResetColor(pixGetColormap(pixc), 0, 255, 255, 255);
pixSaveTiled(pixc, pixac, 1, 0, 40, 0);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixc);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
/* Convert color to gray */
pixs = pixRead("weasel4.16c.png");
pixSaveTiled(pixs, pixac, 1, 1, 20, 0);
pixc = pixConvertTo32(pixs);
pixt1 = pixConvertRGBToGray(pixc, 3., 7., 5.);
pixSaveTiled(pixt1, pixac, 1, 0, 20, 0);
pixt2 = pixConvertRGBToGrayFast(pixc);
pixSaveTiled(pixt2, pixac, 1, 0, 20, 0);
pixg = pixCopy(NULL, pixs);
cmap = pixGetColormap(pixs);
cmapg = pixcmapColorToGray(cmap, 4., 6., 3.);
pixSetColormap(pixg, cmapg);
pixSaveTiled(pixg, pixac, 1, 0, 20, 0);
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixg);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplayWithTitle(pixd, 100, 100, NULL, 1);
pixWrite("junkmisc1.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
return 0;
}
/*!
* boxaCombineOverlaps()
*
* Input: boxas
* Return: boxad (where each set of boxes in boxas that overlap are
* combined into a single bounding box in boxad), or
* null on error.
*
* Notes:
* (1) If there are no overlapping boxes, it simply returns a copy
* of @boxas.
* (2) The alternative method of painting each rectanle and finding
* the 4-connected components gives the wrong result, because
* two non-overlapping rectangles, when rendered, can still
* be 4-connected, and hence they will be joined.
* (3) A bad case is to have n boxes, none of which overlap.
* Then you have one iteration with O(n^2) compares. This
* is still faster than painting each rectangle and finding
* the connected components, even for thousands of rectangles.
*/
BOXA *
boxaCombineOverlaps(BOXA *boxas)
{
l_int32 i, j, n1, n2, inter, interfound, niters;
BOX *box1, *box2, *box3;
BOXA *boxat1, *boxat2;
PROCNAME("boxaCombineOverlaps");
if (!boxas)
return (BOXA *)ERROR_PTR("boxas not defined", procName, NULL);
boxat1 = boxaCopy(boxas, L_COPY);
n1 = boxaGetCount(boxat1);
niters = 0;
/* fprintf(stderr, "%d iters: %d boxes\n", niters, n1); */
while (1) { /* loop until no change from previous iteration */
niters++;
boxat2 = boxaCreate(n1);
for (i = 0; i < n1; i++) {
box1 = boxaGetBox(boxat1, i, L_COPY);
if (i == 0) {
boxaAddBox(boxat2, box1, L_INSERT);
continue;
}
n2 = boxaGetCount(boxat2);
/* Now test box1 against all boxes already put in boxat2.
* If it is found to intersect with an existing box,
* replace that box by the union of the two boxes,
* and break to the outer loop. If no overlap is
* found, add box1 to boxat2. */
interfound = FALSE;
for (j = 0; j < n2; j++) {
box2 = boxaGetBox(boxat2, j, L_CLONE);
boxIntersects(box1, box2, &inter);
if (inter == 1) {
box3 = boxBoundingRegion(box1, box2);
boxaReplaceBox(boxat2, j, box3);
boxDestroy(&box1);
boxDestroy(&box2);
interfound = TRUE;
break;
}
boxDestroy(&box2);
}
if (interfound == FALSE)
boxaAddBox(boxat2, box1, L_INSERT);
}
n2 = boxaGetCount(boxat2);
/* fprintf(stderr, "%d iters: %d boxes\n", niters, n2); */
if (n2 == n1) /* we're done */
break;
else {
n1 = n2;
boxaDestroy(&boxat1);
boxat1 = boxat2;
}
}
boxaDestroy(&boxat1);
return boxat2;
}
int 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;
PIXA *pixa1, *pixa2, *pixa3, *pixa4;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmfile("/tmp/regout/insert3.ba");
lept_rmfile("/tmp/regout/insert4.ba");
lept_rmfile("/tmp/regout/insert6.pa");
lept_rmfile("/tmp/regout/insert7.pa");
lept_rmfile("/tmp/regout/insert9.pa");
lept_rmfile("/tmp/regout/insert10.pa");
/* ----------------- Test numa operations -------------------- */
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/regout/insert0.na", 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/regout/insert1.na", na2);
regTestCheckFile(rp, "/tmp/regout/insert0.na"); /* 0 */
regTestCheckFile(rp, "/tmp/regout/insert1.na"); /* 1 */
regTestCompareFiles(rp, 0, 1); /* 2 */
numaDestroy(&na1);
numaDestroy(&na2);
/* ----------------- Test boxa operations -------------------- */
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa1 = pixConnComp(pix2, NULL, 8);
boxaWrite("/tmp/regout/insert3.ba", boxa1);
boxa2 = boxaCopy(boxa1, L_COPY);
n = boxaGetCount(boxa2);
for (i = 0; i < n; i++) {
boxaRemoveBoxAndSave(boxa2, i, &box);
boxaInsertBox(boxa2, i, box);
}
boxaWrite("/tmp/regout/insert4.ba", boxa2);
regTestCheckFile(rp, "/tmp/regout/insert3.ba"); /* 3 */
regTestCheckFile(rp, "/tmp/regout/insert4.ba"); /* 4 */
regTestCompareFiles(rp, 3, 4); /* 5 */
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* ----------------- Test pixa operations -------------------- */
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/regout/insert6.pa", pixa1);
regTestCheckFile(rp, "/tmp/regout/insert6.pa"); /* 6 */
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Remove and insert each one */
pixa2 = pixaCopy(pixa1, L_COPY);
n = pixaGetCount(pixa2);
for (i = 0; i < n; i++) {
pixaRemovePixAndSave(pixa2, i, &pix, &box);
pixaInsertPix(pixa2, i, pix, box);
}
pixaWrite("/tmp/regout/insert7.pa", pixa2);
regTestCheckFile(rp, "/tmp/regout/insert7.pa"); /* 7 */
regTestCompareFiles(rp, 6, 7); /* 8 */
/* 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/regout/insert9.pa", pixa3);
regTestCheckFile(rp, "/tmp/regout/insert9.pa"); /* 9 */
/* 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/regout/insert10.pa", pixa4);
regTestCheckFile(rp, "/tmp/regout/insert10.pa"); /* 10 */
regTestCompareFiles(rp, 9, 10); /* 11 */
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixaDestroy(&pixa4);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 i;
BOXA *boxa;
NUMA *nas, *nab;
PIX *pixs;
PIXA *pixa, *pixas;
static char mainName[] = "pixalloc_reg";
/* ----------------- Custom with a few large pix -----------------*/
/* Set up pms */
nas = numaCreate(4); /* small */
numaAddNumber(nas, 5);
numaAddNumber(nas, 4);
numaAddNumber(nas, 3);
numaAddNumber(nas, 2);
setPixMemoryManager(pmsCustomAlloc, pmsCustomDealloc);
pmsCreate(200000, 400000, nas, "/tmp/junk1.log");
/* Make the pix and do successive copies and removals of the copies */
pixas = GenerateSetOfMargePix();
startTimer();
for (i = 0; i < ntimes; i++)
CopyStoreClean(pixas, nlevels, ncopies);
fprintf(stderr, "Time (big pix; custom) = %7.3f sec\n", stopTimer());
/* Clean up */
numaDestroy(&nas);
pixaDestroy(&pixas);
pmsDestroy();
/* ----------------- Standard with a few large pix -----------------*/
setPixMemoryManager(malloc, free);
/* Make the pix and do successive copies and removals of the copies */
startTimer();
pixas = GenerateSetOfMargePix();
for (i = 0; i < ntimes; i++)
CopyStoreClean(pixas, nlevels, ncopies);
fprintf(stderr, "Time (big pix; standard) = %7.3f sec\n", stopTimer());
pixaDestroy(&pixas);
/* ----------------- Custom with many small pix -----------------*/
/* Set up pms */
nab = numaCreate(10);
numaAddNumber(nab, 2000);
numaAddNumber(nab, 2000);
numaAddNumber(nab, 2000);
numaAddNumber(nab, 500);
numaAddNumber(nab, 100);
numaAddNumber(nab, 100);
numaAddNumber(nab, 100);
setPixMemoryManager(pmsCustomAlloc, pmsCustomDealloc);
if (logging) /* use logging == 0 for speed comparison */
pmsCreate(20, 40, nab, "/tmp/junk2.log");
else
pmsCreate(20, 40, nab, NULL);
pixs = pixRead("feyn.tif");
startTimer();
for (i = 0; i < 5; i++) {
boxa = pixConnComp(pixs, &pixa, 8);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
}
numaDestroy(&nab);
pixDestroy(&pixs);
pmsDestroy();
fprintf(stderr, "Time (custom) = %7.3f sec\n", stopTimer());
/* ----------------- Standard with many small pix -----------------*/
setPixMemoryManager(malloc, free);
pixs = pixRead("feyn.tif");
startTimer();
for (i = 0; i < 5; i++) {
boxa = pixConnComp(pixs, &pixa, 8);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
}
pixDestroy(&pixs);
fprintf(stderr, "Time (standard) = %7.3f sec\n", stopTimer());
return 0;
}
int main(int argc, char* argv[])
{
PIX *pixs, *pixb, *pixt;
int minb;
if (argc < 2) {
USAGE: fprintf(stderr, "Usage: %s </path/to/text-image>\n"
"\t\t[binarize-threshold] [minw:minh:maxw:maxh]\n",
strrchr(argv[0], '/') + 1);
return EINVAL;
}
if (2 < argc) { errno = 0;
minb = strtol(argv[2], NULL, 10);
if (errno < 0) {
fprintf(stderr, "strtol: %s\n", strerror(errno));
goto USAGE;
}
} else minb = 180;
if (!(pixs = pixRead(argv[1]))) ;
if (1 && (pixt = pixBackgroundNormMorph(pixs, NULL, 4, 5, 248))) {
pixDestroy(&pixs); pixs = pixt;
} else
if (0 && (pixt = pixBackgroundNorm(pixs, NULL, NULL,
10, 15, 60, 40, 248, 2, 1))) {
pixDestroy(&pixs); pixs = pixt;
}
if (1 && (pixt = pixFindSkewAndDeskew(pixs, 1, NULL, NULL))) {
pixDestroy(&pixs); pixs = pixt;
} if (0 && pixDisplay(pixs, 0, 0)) ;
if (1) { PTA *ptas, *ptad;
if (!(pixb = pixConvertTo1(pixs, minb))) ;
// pixt = pixDeskewLocal(pixs, 10, 0, 0, 0.0, 0.0, 0.0))
if (!pixGetLocalSkewTransform(pixb,
10, 0, 0, 0.0, 0.0, 0.0, &ptas, &ptad)) {
if ((pixt = pixProjectiveSampledPta(pixs,
ptad, ptas, L_BRING_IN_WHITE))) {
pixDestroy(&pixs); pixs = pixt;
} ptaDestroy(&ptas); ptaDestroy(&ptad);
} pixDestroy(&pixb);
}
if (0 && (pixt = pixGammaTRC(NULL, pixs, 1.0, 30, 180))) {
pixDestroy(&pixs); pixs = pixt;
}
if (!(pixb = pixConvertTo1(pixs, minb))) ;
if (0) { pixDestroy(&pixs); pixs = pixCopy(pixs, pixb); } // XXX:
if (1) {
BOX* box;
int i, n, j, m;
PIX *pixi, *pixl;
BOXA *boxi, *boxl;
int x, y, w, h, wid;
int X = INT_MAX, Y = INT_MAX, W = 0, H;
// XXX: do smaller(or no) pixOpenBrick
if (pixGetRegionsBinary(pixb, &pixi, &pixl, NULL, 0)) ;
boxl = pixConnComp(pixl, NULL, 4);
n = boxaGetCount(boxl);
for (i = 0; i < n; ++i) { BOXA* boxa;
box = boxaGetBox(boxl, i, L_CLONE);
boxGetGeometry(box, &x, &y, &w, &h);
if (w < 30 || h < 30 || w < h || h < (w / 40)) {
boxDestroy(&box); continue;
boxaRemoveBox(boxl, i);
}
if (x < X) X = x; if (y < Y) Y = y; if (W < w) W = w;
pixt = pixClipRectangle(pixb, box, NULL);
boxDestroy(&box);
// XXX: for English
if (0) pixt = pixDilateBrick(pixt, pixt, h >> 1, h >> 1); else
pixt = pixDilateBrick(pixt, pixt, 16 < h ? h >> 4 : 1, h << 1);
if (0 && pixDisplay(pixt, 0, 0)) ;
boxa = pixConnComp(pixt, NULL, 8);
pixDestroy(&pixt);
wid = (h * 3) >> 2;
//boxaShift(boxa, x, y);
m = boxaGetCount(boxa);
for (j = 0; j < m; ++j) {
int x0, y0, w0;
box = boxaGetBox(boxa, j, L_CLONE);
boxGetGeometry(box, &x0, &y0, &w0, NULL);
// merge adjacent 2 or 3 small boxes
if (1 && w0 < wid && (j + 1) < m) {
BOX* boxn; int xn, wn;
boxn = boxaGetBox(boxa, j + 1, L_CLONE);
boxGetGeometry(boxn, &xn, NULL, &wn, NULL);
if ((w0 = xn + wn - x0) < h) {
boxaSparseClearBox(boxa, ++j);
if (w0 < wid && (j + 1) < m) {
boxDestroy(&boxn);
boxn = boxaGetBox(boxa, j + 1, L_CLONE);
boxGetGeometry(boxn, &xn, NULL, &wn, NULL);
if ((wn = xn + wn - x0) < h) {
boxaSparseClearBox(boxa, ++j);
w0 = wn;
}
}
boxSetGeometry(box, -1, -1, w0, -1);
} boxDestroy(&boxn);
}
boxSetGeometry(box, x + x0, y + y0, -1, -1);
boxDestroy(&box);
} boxaSparseCompact(boxa);
if (1 && (pixt = pixDrawBoxa(pixs, boxa, 1, 0xff000000))) {
pixDestroy(&pixs); pixs = pixt;
} boxaDestroy(&boxa);
} H = y + h;
int main(int argc,
char **argv)
{
l_int32 i, n, w, h, nactual, imax;
BOX *box;
BOXA *boxa;
PIX *pixs, *pixd, *pix;
PIXA *pixas, *pixat, *pixac;
L_PTRA *papix, *pabox, *papix2, *pabox2;
static char mainName[] = "ptra1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: ptra1_reg", mainName, 1);
pixac = pixaCreate(0);
if ((pixs = pixRead("lucasta.1.300.tif")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, NULL);
boxa = pixConnComp(pixs, &pixas, 8);
pixDestroy(&pixs);
boxaDestroy(&boxa);
n = pixaGetCount(pixas);
/* Fill ptras with clones and reconstruct */
fprintf(stderr, "Fill with clones and reconstruct\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1);
/* Remove every other one for the first half;
* with compaction at each removal */
fprintf(stderr, "Remove every other in 1st half, with compaction\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_COPY);
for (i = 0; i < n / 2; i++) {
if (i % 2 == 0) {
pix = (PIX *)ptraRemove(papix, i, L_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_COMPACTION);
pixDestroy(&pix);
boxDestroy(&box);
}
}
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Remove every other one for the entire set,
* but without compaction at each removal */
fprintf(stderr,
"Remove every other in 1st half, without & then with compaction\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_COPY);
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
pix = (PIX *)ptraRemove(papix, i, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_NO_COMPACTION);
pixDestroy(&pix);
boxDestroy(&box);
}
}
ptraCompactArray(papix); /* now do the compaction */
ptraCompactArray(pabox);
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Fill ptras using insert at head, and reconstruct */
fprintf(stderr, "Insert at head and reconstruct\n");
papix = ptraCreate(n);
pabox = ptraCreate(n);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixas, i, L_CLONE);
box = pixaGetBox(pixas, i, L_CLONE);
ptraInsert(papix, 0, pix, L_MIN_DOWNSHIFT);
ptraInsert(pabox, 0, box, L_FULL_DOWNSHIFT);
}
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1);
/* Reverse the arrays by swapping */
fprintf(stderr, "Reverse by swapping\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
for (i = 0; i < n / 2; i++) {
ptraSwap(papix, i, n - i - 1);
ptraSwap(pabox, i, n - i - 1);
}
ptraCompactArray(papix); /* already compact; shouldn't do anything */
ptraCompactArray(pabox);
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Remove at the top of the array and push the hole to the end
* by neighbor swapping (!). This is O(n^2), so it's not a
* recommended way to copy a ptra. [joke] */
fprintf(stderr,
"Remove at top, pushing hole to end by swapping -- O(n^2)\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
papix2 = ptraCreate(0);
pabox2 = ptraCreate(0);
while (1) {
ptraGetActualCount(papix, &nactual);
if (nactual == 0) break;
ptraGetMaxIndex(papix, &imax);
pix = (PIX *)ptraRemove(papix, 0, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, 0, L_NO_COMPACTION);
ptraAdd(papix2, pix);
ptraAdd(pabox2, box);
for (i = 1; i <= imax; i++) {
ptraSwap(papix, i - 1, i);
ptraSwap(pabox, i - 1, i);
}
}
ptraCompactArray(papix); /* should be empty */
ptraCompactArray(pabox); /* ditto */
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1); /* nothing there */
pixat = ReconstructPixa(papix2, pabox2, CHOOSE_RECON);
ptraDestroy(&papix2, 0, 1);
ptraDestroy(&pabox2, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Remove and insert one position above, allowing minimum downshift.
* If you specify L_AUTO_DOWNSHIFT, because there is only 1 hole,
* it will do a full downshift at each insert. This is a
* situation where the heuristic (expected number of holes)
* fails to do the optimal thing. */
fprintf(stderr, "Remove and insert one position above (min downshift)\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
for (i = 1; i < n; i++) {
pix = (PIX *)ptraRemove(papix, i, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_NO_COMPACTION);
ptraInsert(papix, i - 1, pix, L_MIN_DOWNSHIFT);
ptraInsert(pabox, i - 1, box, L_MIN_DOWNSHIFT);
}
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1);
/* Remove and insert one position above, but this time
* forcing a full downshift at each step. */
fprintf(stderr, "Remove and insert one position above (full downshift)\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
for (i = 1; i < n; i++) {
pix = (PIX *)ptraRemove(papix, i, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_NO_COMPACTION);
ptraInsert(papix, i - 1, pix, L_AUTO_DOWNSHIFT);
ptraInsert(pabox, i - 1, box, L_AUTO_DOWNSHIFT);
}
/* ptraCompactArray(papix);
ptraCompactArray(pabox); */
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/junkptra1.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
pixaDestroy(&pixas);
return 0;
}
/*!
* pixFindBaselines()
*
* Input: pixs (1 bpp)
* &pta (<optional return> pairs of pts corresponding to
* approx. ends of each text line)
* debug (usually 0; set to 1 for debugging output)
* Return: na (of baseline y values), or null on error
*
* Notes:
* (1) Input binary image must have text lines already aligned
* horizontally. This can be done by either rotating the
* image with pixDeskew(), or, if a projective transform
* is required, by doing pixDeskewLocal() first.
* (2) Input null for &pta if you don't want this returned.
* The pta will come in pairs of points (left and right end
* of each baseline).
* (3) Caution: this will not work properly on text with multiple
* columns, where the lines are not aligned between columns.
* If there are multiple columns, they should be extracted
* separately before finding the baselines.
* (4) This function constructs different types of output
* for baselines; namely, a set of raster line values and
* a set of end points of each baseline.
* (5) This function was designed to handle short and long text lines
* without using dangerous thresholds on the peak heights. It does
* this by combining the differential signal with a morphological
* analysis of the locations of the text lines. One can also
* combine this data to normalize the peak heights, by weighting
* the differential signal in the region of each baseline
* by the inverse of the width of the text line found there.
* (6) There are various debug sections that can be turned on
* with the debug flag.
*/
NUMA *
pixFindBaselines(PIX *pixs,
PTA **ppta,
l_int32 debug)
{
l_int32 w, h, i, j, nbox, val1, val2, ndiff, bx, by, bw, bh;
l_int32 imaxloc, peakthresh, zerothresh, inpeak;
l_int32 mintosearch, max, maxloc, nloc, locval;
l_int32 *array;
l_float32 maxval;
BOXA *boxa1, *boxa2, *boxa3;
GPLOT *gplot;
NUMA *nasum, *nadiff, *naloc, *naval;
PIX *pixt1, *pixt2;
PTA *pta;
PROCNAME("pixFindBaselines");
if (!pixs)
return (NUMA *)ERROR_PTR("pixs not defined", procName, NULL);
pta = NULL;
if (ppta) {
pta = ptaCreate(0);
*ppta = pta;
}
/* Close up the text characters, removing noise */
pixt1 = pixMorphSequence(pixs, "c25.1 + e3.1", 0);
/* Save the difference of adjacent row sums.
* The high positive-going peaks are the baselines */
if ((nasum = pixCountPixelsByRow(pixt1, NULL)) == NULL)
return (NUMA *)ERROR_PTR("nasum not made", procName, NULL);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
nadiff = numaCreate(h);
numaGetIValue(nasum, 0, &val2);
for (i = 0; i < h - 1; i++) {
val1 = val2;
numaGetIValue(nasum, i + 1, &val2);
numaAddNumber(nadiff, val1 - val2);
}
if (debug) /* show the difference signal */
gplotSimple1(nadiff, GPLOT_X11, "junkdiff", "difference");
/* Use the zeroes of the profile to locate each baseline. */
array = numaGetIArray(nadiff);
ndiff = numaGetCount(nadiff);
numaGetMax(nadiff, &maxval, &imaxloc);
/* Use this to begin locating a new peak: */
peakthresh = (l_int32)maxval / PEAK_THRESHOLD_RATIO;
/* Use this to begin a region between peaks: */
zerothresh = (l_int32)maxval / ZERO_THRESHOLD_RATIO;
naloc = numaCreate(0);
naval = numaCreate(0);
inpeak = FALSE;
for (i = 0; i < ndiff; i++) {
if (inpeak == FALSE) {
if (array[i] > peakthresh) { /* transition to in-peak */
inpeak = TRUE;
mintosearch = i + MIN_DIST_IN_PEAK; /* accept no zeros
* between i and mintosearch */
max = array[i];
maxloc = i;
}
}
else { /* inpeak == TRUE; look for max */
if (array[i] > max) {
max = array[i];
maxloc = i;
mintosearch = i + MIN_DIST_IN_PEAK;
}
else if (i > mintosearch && array[i] <= zerothresh) { /* leave */
inpeak = FALSE;
numaAddNumber(naval, max);
numaAddNumber(naloc, maxloc);
}
}
}
/* If array[ndiff-1] is max, eg. no descenders, baseline at bottom */
if (inpeak) {
numaAddNumber(naval, max);
numaAddNumber(naloc, maxloc);
}
FREE(array);
if (debug) { /* show the raster locations for the peaks */
gplot = gplotCreate("junkloc", GPLOT_X11, "Peak locations",
"rasterline", "height");
gplotAddPlot(gplot, naloc, naval, GPLOT_POINTS, "locs");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
}
/* Generate an approximate profile of text line width.
* First, filter the boxes of text, where there may be
* more than one box for a given textline. */
pixt2 = pixMorphSequence(pixt1, "r11 + c25.1 + o7.1 +c1.3", 0);
boxa1 = pixConnComp(pixt2, NULL, 4);
boxa2 = boxaTransform(boxa1, 0, 0, 4., 4.);
boxa3 = boxaSort(boxa2, L_SORT_BY_Y, L_SORT_INCREASING, NULL);
/* Then find the baseline segments */
if (pta) {
nloc = numaGetCount(naloc);
nbox = boxaGetCount(boxa3);
for (i = 0; i < nbox; i++) {
boxaGetBoxGeometry(boxa3, i, &bx, &by, &bw, &bh);
for (j = 0; j < nloc; j++) {
numaGetIValue(naloc, j, &locval);
if (L_ABS(locval - (by + bh)) > 25)
continue;
ptaAddPt(pta, bx, locval);
ptaAddPt(pta, bx + bw, locval);
break;
}
}
}
if (debug) { /* display baselines */
PIX *pixd;
l_int32 npts, x1, y1, x2, y2;
if (pta) {
pixd = pixConvertTo32(pixs);
npts = ptaGetCount(pta);
for (i = 0; i < npts; i += 2) {
ptaGetIPt(pta, i, &x1, &y1);
ptaGetIPt(pta, i + 1, &x2, &y2);
pixRenderLineArb(pixd, x1, y1, x2, y2, 1, 255, 0, 0);
}
pixDisplay(pixd, 200, 200);
pixWrite("junkbaselines", pixd, IFF_PNG);
pixDestroy(&pixd);
}
}
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
numaDestroy(&nasum);
numaDestroy(&nadiff);
numaDestroy(&naval);
return naloc;
}
int main(int argc,
char **argv)
{
l_int32 i, n, w, h;
BOXA *boxa;
NUMA *naindex, *naw, *nah, *naw_med, *nah_med;
PIX *pixs, *pixt;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate arrays of word widths and heights */
pixs = pixRead("feyn.tif");
pixGetWordBoxesInTextlines(pixs, 1, 6, 6, 500, 50, &boxa, &naindex);
n = boxaGetCount(boxa);
naw = numaCreate(0);
nah = numaCreate(0);
for (i = 0; i < n; i++) {
boxaGetBoxGeometry(boxa, i, NULL, NULL, &w, &h);
numaAddNumber(naw, w);
numaAddNumber(nah, h);
}
boxaDestroy(&boxa);
numaDestroy(&naindex);
/* Make the rank bin arrays of median values, with 10 bins */
lept_rmfile("/tmp/lept/regout/w_10bin.png"); /* remove existing ones */
lept_rmfile("/tmp/lept/regout/h_10bin.png");
lept_rmfile("/tmp/lept/regout/w_30bin.png");
lept_rmfile("/tmp/lept/regout/h_30bin.png");
numaGetRankBinValues(naw, 10, NULL, &naw_med);
numaGetRankBinValues(nah, 10, NULL, &nah_med);
gplotSimple1(naw_med, GPLOT_PNG, "/tmp/lept/regout/w_10bin",
"width vs rank bins (10)");
gplotSimple1(nah_med, GPLOT_PNG, "/tmp/lept/regout/h_10bin",
"height vs rank bins (10)");
numaDestroy(&naw_med);
numaDestroy(&nah_med);
/* Make the rank bin arrays of median values, with 30 bins */
numaGetRankBinValues(naw, 30, NULL, &naw_med);
numaGetRankBinValues(nah, 30, NULL, &nah_med);
gplotSimple1(naw_med, GPLOT_PNG, "/tmp/lept/regout/w_30bin",
"width vs rank bins (30)");
gplotSimple1(nah_med, GPLOT_PNG, "/tmp/lept/regout/h_30bin",
"height vs rank bins (30)");
numaDestroy(&naw_med);
numaDestroy(&nah_med);
/* Save as golden files, or check against them */
regTestCheckFile(rp, "/tmp/lept/regout/w_10bin.png"); /* 0 */
regTestCheckFile(rp, "/tmp/lept/regout/h_10bin.png"); /* 1 */
regTestCheckFile(rp, "/tmp/lept/regout/w_30bin.png"); /* 2 */
regTestCheckFile(rp, "/tmp/lept/regout/h_30bin.png"); /* 3 */
/* Display results for debugging */
pixt = pixRead("/tmp/lept/regout/w_10bin.png");
pixDisplayWithTitle(pixt, 0, 0, NULL, rp->display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/lept/regout/h_10bin.png");
pixDisplayWithTitle(pixt, 650, 0, NULL, rp->display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/lept/regout/w_30bin.png");
pixDisplayWithTitle(pixt, 0, 550, NULL, rp->display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/lept/regout/h_30bin.png");
pixDisplayWithTitle(pixt, 650, 550, NULL, rp->display);
pixDestroy(&pixt);
pixDestroy(&pixs);
numaDestroy(&naw);
numaDestroy(&nah);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 w, h, d, w2, h2, i, ncols, ignore;
l_float32 angle, conf;
BOX *box;
BOXA *boxa, *boxa2;
PIX *pix, *pixs, *pixb, *pixb2, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIXA *pixam; /* mask with a single component over each column */
PIXA *pixac, *pixad, *pixat;
PIXAA *pixaa, *pixaa2;
SEL *selsplit;
static char mainName[] = "arabic_lines";
if (argc != 1)
return ERROR_INT(" Syntax: arabic_lines", mainName, 1);
pixDisplayWrite(NULL, -1); /* init debug output */
/* Binarize input */
pixs = pixRead("arabic.png");
pixGetDimensions(pixs, &w, &h, &d);
pix = pixConvertTo1(pixs, 128);
/* Deskew */
pixb = pixFindSkewAndDeskew(pix, 1, &angle, &conf);
pixDestroy(&pix);
fprintf(stderr, "Skew angle: %7.2f degrees; %6.2f conf\n", angle, conf);
pixDisplayWrite(pixb, 1);
/* Use full image morphology to find columns, at 2x reduction.
This only works for very simple layouts where each column
of text extends the full height of the input image. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pix1 = pixMorphCompSequence(pixb2, "c5.500", 0);
boxa = pixConnComp(pix1, &pixam, 8);
ncols = boxaGetCount(boxa);
fprintf(stderr, "Num columns: %d\n", ncols);
pixDisplayWrite(pix1, 1);
/* Use selective region-based morphology to get the textline mask. */
pixad = pixaMorphSequenceByRegion(pixb2, pixam, "c100.3", 0, 0);
pixGetDimensions(pixb2, &w2, &h2, NULL);
pix2 = pixaDisplay(pixad, w2, h2);
pixDisplayWrite(pix2, 1);
pixDestroy(&pix2);
/* Some of the lines may be touching, so use a HMT to split the
lines in each column, and use a pixaa to save the results. */
selsplit = selCreateFromString(seltext, 17, 7, "selsplit");
pixaa = pixaaCreate(ncols);
for (i = 0; i < ncols; i++) {
pix3 = pixaGetPix(pixad, i, L_CLONE);
box = pixaGetBox(pixad, i, L_COPY);
pix4 = pixHMT(NULL, pix3, selsplit);
pixXor(pix4, pix4, pix3);
boxa2 = pixConnComp(pix4, &pixac, 8);
pixaaAddPixa(pixaa, pixac, L_INSERT);
pixaaAddBox(pixaa, box, L_INSERT);
pix5 = pixaDisplayRandomCmap(pixac, 0, 0);
pixDisplayWrite(pix5, 1);
fprintf(stderr, "Num textlines in col %d: %d\n", i,
boxaGetCount(boxa2));
pixDestroy(&pix5);
pixDestroy(&pix3);
pixDestroy(&pix4);
boxaDestroy(&boxa2);
}
/* Visual output */
ignore = system("gthumb /tmp/display/file* &");
pixat = pixaReadFiles("/tmp/display", "file");
pix5 = selDisplayInPix(selsplit, 31, 2);
pixaAddPix(pixat, pix5, L_INSERT);
pix6 = pixaDisplayTiledAndScaled(pixat, 32, 400, 3, 0, 35, 3);
pixWrite("/tmp/result.png", pix6, IFF_PNG);
pixaDestroy(&pixat);
pixDestroy(&pix6);
/* Test pixaa I/O */
pixaaWrite("/tmp/pixaa", pixaa);
pixaa2 = pixaaRead("/tmp/pixaa");
pixaaWrite("/tmp/pixaa2", pixaa2);
/* Test pixaa display */
pixd = pixaaDisplay(pixaa, w2, h2);
pixWrite("/tmp/textlines.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Cleanup */
pixDestroy(&pixb2);
pixDestroy(&pix1);
pixaDestroy(&pixam);
pixaDestroy(&pixad);
pixaaDestroy(&pixaa);
pixaaDestroy(&pixaa2);
boxaDestroy(&boxa);
selDestroy(&selsplit);
pixDestroy(&pixs);
pixDestroy(&pixb);
return 0;
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pix2, *pix3, *pixdb;
PIXA *pixa1, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 1 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 2 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 3 */
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 4 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 5 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 6 */
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix1, 200, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
regTestCompareValues(rp, 1, same, 0.0); /* 8 */
regTestCompareValues(rp, 0.053, diffarea, 0.002); /* 9 */
regTestCompareValues(rp, 0.240, diffxor, 0.002); /* 10 */
regTestWritePixAndCheck(rp, pixdb, IFF_PNG); /* 11 */
pixDisplayWithTitle(pixdb, 400, 0, NULL, rp->display);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix1, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaSmoothSequenceMedian(boxa1, 10, L_SUB_ON_LOC_DIFF, 80, 20, 1);
boxa3 = boxaSmoothSequenceMedian(boxa1, 10, L_SUB_ON_SIZE_DIFF, 80, 20, 1);
boxaPlotSides(boxa1, "initial", NULL, NULL, NULL, NULL, &pix1);
boxaPlotSides(boxa2, "side_smoothing", NULL, NULL, NULL, NULL, &pix2);
boxaPlotSides(boxa3, "size_smoothing", NULL, NULL, NULL, NULL, &pix3);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 15 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 16 */
pixDisplayWithTitle(pix1, 1300, 0, NULL, rp->display);
pixDisplayWithTitle(pix2, 1300, 500, NULL, rp->display);
pixDisplayWithTitle(pix3, 1300, 1000, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 17 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
regTestCompareValues(rp, 1, same, 0.0); /* 18 */
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* ----------- Test pixaDisplayBoxaa() ------------ */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
/* Check that the transpose is reversible */
regTestCompareValues(rp, 1, success, 0.0); /* 19 */
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 20 */
pixDisplayWithTitle(pix1, 0, 600, NULL, rp->display);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
l_pdfSetDateAndVersion(FALSE);
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
regTestCheckFile(rp, "/tmp/lept/boxa/show.pdf"); /* 21 */
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char buf[8];
l_int32 i, n, h;
l_float32 scalefact;
BOXA *boxa;
PIX *pixs, *pixt1, *pixt2;
PIXA *pixa, *pixas, *pixad;
PIXAA *pixaa;
static char mainName[] = "digitprep1";
if (argc != 1) {
ERROR_INT(" Syntax: digitprep1", mainName, 1);
return 1;
}
setLeptDebugOK(1);
if ((pixs = pixRead("barcode-digits.png")) == NULL)
return ERROR_INT("pixs not read", mainName, 1);
/* Extract the digits and scale to HEIGHT */
boxa = pixConnComp(pixs, &pixa, 8);
pixas = pixaSort(pixa, L_SORT_BY_X, L_SORT_INCREASING, NULL, L_CLONE);
n = pixaGetCount(pixas);
/* Move the last ("0") to the first position */
pixt1 = pixaGetPix(pixas, n - 1, L_CLONE);
pixaInsertPix(pixas, 0, pixt1, NULL);
pixaRemovePix(pixas, n);
/* Make the output scaled pixa */
pixad = pixaCreate(n);
for (i = 0; i < n; i++) {
pixt1 = pixaGetPix(pixas, i, L_CLONE);
pixGetDimensions(pixt1, NULL, &h, NULL);
scalefact = HEIGHT / (l_float32)h;
pixt2 = pixScale(pixt1, scalefact, scalefact);
if (pixGetHeight(pixt2) != 32)
return ERROR_INT("height not 32!", mainName, 1);
snprintf(buf, sizeof(buf), "%d", i);
pixSetText(pixt2, buf);
pixaAddPix(pixad, pixt2, L_INSERT);
pixDestroy(&pixt1);
}
/* Save in a pixaa, with 1 pix in each pixa */
pixaa = pixaaCreateFromPixa(pixad, 1, L_CHOOSE_CONSECUTIVE, L_CLONE);
pixaaWrite("junkdigits.pixaa", pixaa);
/* Show result */
pixt1 = pixaaDisplayByPixa(pixaa, 20, 20, 1000);
pixDisplay(pixt1, 100, 100);
pixDestroy(&pixt1);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
pixaDestroy(&pixas);
pixaDestroy(&pixad);
pixaaDestroy(&pixaa);
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)
{
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;
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
static char mainName[] = "boxa1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: boxa1_reg", mainName, 1);
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
pixDisplay(pix1, 100, 100);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
pixDisplay(pix1, 100, 500);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
pixDisplay(pixdb, 700, 100);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 0, 100);
pixWrite("/tmp/lept/boxa/pix1.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 500, 100);
pixWrite("/tmp/lept/boxa/pix2.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 1000, 100);
pixWrite("/tmp/lept/boxa/pix3.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
if (same)
fprintf(stderr, "Good: boxes files are identical\n");
else
fprintf(stderr, "Bad: boxes files differ\n");
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* Test pixaDisplayBoxaa() */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
if (success)
fprintf(stderr, "Good: transpose is reversible\n");
else
fprintf(stderr, "Bad: transpose failed\n");
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
pixDisplay(pix1, 0, 600);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return 0;
}
/*!
* jbWordsInTextlines()
*
* Input: dirin (directory of input pages)
* reduction (1 for full res; 2 for half-res)
* maxwidth (of word mask components, to be kept)
* maxheight (of word mask components, to be kept)
* thresh (on correlation; 0.80 is reasonable)
* weight (for handling thick text; 0.6 is reasonable)
* natl (<return> numa with textline index for each component)
* firstpage (0-based)
* npages (use 0 for all pages in dirin)
* Return: classer (for the set of pages)
*
* Notes:
* (1) This is a high-level function. See prog/jbwords for example
* of usage.
* (2) Typically, words can be found reasonably well at a resolution
* of about 150 ppi. For highest accuracy, you should use 300 ppi.
* Assuming that the input images are 300 ppi, use reduction = 1
* for finding words at full res, and reduction = 2 for finding
* them at 150 ppi.
*/
JBCLASSER *
jbWordsInTextlines(const char *dirin,
l_int32 reduction,
l_int32 maxwidth,
l_int32 maxheight,
l_float32 thresh,
l_float32 weight,
NUMA **pnatl,
l_int32 firstpage,
l_int32 npages)
{
char *fname;
l_int32 nfiles, i, w, h;
BOXA *boxa;
JBCLASSER *classer;
NUMA *nai, *natl;
PIX *pix;
PIXA *pixa;
SARRAY *safiles;
PROCNAME("jbWordsInTextlines");
if (!pnatl)
return (JBCLASSER *)ERROR_PTR("&natl not defined", procName, NULL);
*pnatl = NULL;
if (!dirin)
return (JBCLASSER *)ERROR_PTR("dirin not defined", procName, NULL);
if (reduction != 1 && reduction != 2)
return (JBCLASSER *)ERROR_PTR("reduction not in {1,2}", procName, NULL);
safiles = getSortedPathnamesInDirectory(dirin, NULL, firstpage, npages);
nfiles = sarrayGetCount(safiles);
/* Classify components */
classer = jbCorrelationInit(JB_WORDS, maxwidth, maxheight, thresh, weight);
classer->safiles = sarrayCopy(safiles);
natl = numaCreate(0);
*pnatl = natl;
for (i = 0; i < nfiles; i++) {
fname = sarrayGetString(safiles, i, 0);
if ((pix = pixRead(fname)) == NULL) {
L_WARNING("image file %d not read\n", procName, i);
continue;
}
pixGetDimensions(pix, &w, &h, NULL);
if (reduction == 1) {
classer->w = w;
classer->h = h;
} else { /* reduction == 2 */
classer->w = w / 2;
classer->h = h / 2;
}
pixGetWordsInTextlines(pix, reduction, JB_WORDS_MIN_WIDTH,
JB_WORDS_MIN_HEIGHT, maxwidth, maxheight,
&boxa, &pixa, &nai);
jbAddPageComponents(classer, pix, boxa, pixa);
numaJoin(natl, nai, 0, -1);
pixDestroy(&pix);
numaDestroy(&nai);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
}
sarrayDestroy(&safiles);
return classer;
}
int main(int argc,
char **argv) {
l_int32 i, n, ws, hs, w, h, rval, gval, bval, order;
l_float32 *mat1, *mat2, *mat3;
l_float32 matd[9];
BOX *box, *boxt;
BOXA *boxa, *boxat, *boxa1, *boxa2, *boxa3, *boxa4, *boxa5;
PIX *pix, *pixs, *pixc, *pixt, *pix1, *pix2, *pix3;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ----------------------------------------------------------- *
* Test hash rendering in 3 modes *
* ----------------------------------------------------------- */
pixs = pixRead("feyn.tif");
box = boxCreate(461, 429, 1393, 342);
pix1 = pixClipRectangle(pixs, box, NULL);
boxa = pixConnComp(pix1, NULL, 8);
n = boxaGetCount(boxa);
pix2 = pixConvertTo8(pix1, 1);
pix3 = pixConvertTo32(pix1);
for (i = 0; i < n; i++) {
boxt = boxaGetBox(boxa, i, L_CLONE);
rval = (1413 * (i + 1)) % 256;
gval = (4917 * (i + 1)) % 256;
bval = (7341 * (i + 1)) % 256;
pixRenderHashBox(pix1, boxt, 8, 2, i % 4, 1, L_SET_PIXELS);
pixRenderHashBoxArb(pix2, boxt, 7, 2, i % 4, 1, rval, gval, bval);
pixRenderHashBoxBlend(pix3, boxt, 7, 2, i % 4, 1,
rval, gval, bval, 0.5);
boxDestroy(&boxt);
}
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 2 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDisplayWithTitle(pix2, 0, 300, NULL, rp->display);
pixDisplayWithTitle(pix3, 0, 570, NULL, rp->display);
boxaDestroy(&boxa);
boxDestroy(&box);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* ----------------------------------------------------------- *
* Test orthogonal box rotation and hash rendering *
* ----------------------------------------------------------- */
pixs = pixRead("feyn.tif");
box = boxCreate(461, 429, 1393, 342);
pix1 = pixClipRectangle(pixs, box, NULL);
pixc = pixConvertTo32(pix1);
pixGetDimensions(pix1, &w, &h, NULL);
boxa1 = pixConnComp(pix1, NULL, 8);
pixa = pixaCreate(4);
for (i = 0; i < 4; i++) {
pix2 = pixRotateOrth(pixc, i);
boxa2 = boxaRotateOrth(boxa1, w, h, i);
rval = (1413 * (i + 4)) % 256;
gval = (4917 * (i + 4)) % 256;
bval = (7341 * (i + 4)) % 256;
pixRenderHashBoxaArb(pix2, boxa2, 10, 3, i, 1, rval, gval, bval);
pixaAddPix(pixa, pix2, L_INSERT);
boxaDestroy(&boxa2);
}
pix3 = pixaDisplayTiledInRows(pixa, 32, 1200, 0.7, 0, 30, 3);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
pixDisplayWithTitle(pix3, 0, 800, NULL, rp->display);
boxDestroy(&box);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix3);
pixDestroy(&pixc);
boxaDestroy(&boxa1);
pixaDestroy(&pixa);
/* ----------------------------------------------------------- *
* Test box transforms with either translation or scaling *
* combined with rotation, using the simple 'ordered' *
* function. Show that the order of the operations does *
* not matter; different hashing schemes end up in the *
* identical boxes. *
* ----------------------------------------------------------- */
pix = pixRead("feyn.tif");
box = boxCreate(420, 360, 1500, 465);
pixt = pixClipRectangle(pix, box, NULL);
pixs = pixAddBorderGeneral(pixt, 0, 200, 0, 0, 0);
boxDestroy(&box);
pixDestroy(&pix);
pixDestroy(&pixt);
boxa = pixConnComp(pixs, NULL, 8);
n = boxaGetCount(boxa);
pixa = pixaCreate(0);
pixt = pixConvertTo32(pixs);
for (i = 0; i < 3; i++) {
if (i == 0)
order = L_TR_SC_RO;
else if (i == 1)
order = L_TR_RO_SC;
else
order = L_SC_TR_RO;
boxat = boxaTransformOrdered(boxa, SHIFTX_2, SHIFTY_2, 1.0, 1.0,
450, 250, ROTATION_2, order);
RenderTransformedBoxa(pixt, boxat, i);
boxaDestroy(&boxat);
}
pixSaveTiled(pixt, pixa, 1.0, 1, 30, 32);
pixDestroy(&pixt);
pixt = pixConvertTo32(pixs);
for (i = 0; i < 3; i++) {
if (i == 0)
order = L_RO_TR_SC;
else if (i == 1)
order = L_RO_SC_TR;
else
order = L_SC_RO_TR;
boxat = boxaTransformOrdered(boxa, SHIFTX_2, SHIFTY_2, 1.0, 1.0,
450, 250, ROTATION_2, order);
RenderTransformedBoxa(pixt, boxat, i + 4);
boxaDestroy(&boxat);
}
pixSaveTiled(pixt, pixa, 1.0, 1, 30, 0);
pixDestroy(&pixt);
pixt = pixConvertTo32(pixs);
for (i = 0; i < 3; i++) {
if (i == 0)
order = L_TR_SC_RO;
else if (i == 1)
order = L_SC_RO_TR;
else
order = L_SC_TR_RO;
boxat = boxaTransformOrdered(boxa, 0, 0, SCALEX_2, SCALEY_2,
450, 250, ROTATION_2, order);
RenderTransformedBoxa(pixt, boxat, i + 8);
boxaDestroy(&boxat);
}
pixSaveTiled(pixt, pixa, 1.0, 1, 30, 0);
pixDestroy(&pixt);
pixt = pixConvertTo32(pixs);
for (i = 0; i < 3; i++) {
if (i == 0)
order = L_RO_TR_SC;
else if (i == 1)
order = L_RO_SC_TR;
else
order = L_TR_RO_SC;
boxat = boxaTransformOrdered(boxa, 0, 0, SCALEX_2, SCALEY_2,
450, 250, ROTATION_2, order);
RenderTransformedBoxa(pixt, boxat, i + 12);
boxaDestroy(&boxat);
}
pixSaveTiled(pixt, pixa, 1.0, 1, 30, 0);
pixDestroy(&pixt);
pixt = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixt, 1000, 0, NULL, rp->display);
pixDestroy(&pixt);
pixDestroy(&pixs);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
/* ----------------------------------------------------------- *
* Do more testing of box and pta transforms. Show that *
* resulting boxes are identical by three methods. *
* ----------------------------------------------------------- */
/* Set up pix and boxa */
pixa = pixaCreate(0);
pix = pixRead("lucasta.1.300.tif");
pixTranslate(pix, pix, 70, 0, L_BRING_IN_WHITE);
pixt = pixCloseBrick(NULL, pix, 14, 5);
pixOpenBrick(pixt, pixt, 1, 2);
boxa = pixConnComp(pixt, NULL, 8);
pixs = pixConvertTo32(pix);
pixc = pixCopy(NULL, pixs);
RenderTransformedBoxa(pixc, boxa, 113);
pixSaveTiled(pixc, pixa, 0.5, 1, 30, 32);
pixDestroy(&pix);
pixDestroy(&pixc);
pixDestroy(&pixt);
/* (a) Do successive discrete operations: shift, scale, rotate */
pix1 = pixTranslate(NULL, pixs, SHIFTX_3, SHIFTY_3, L_BRING_IN_WHITE);
boxa1 = boxaTranslate(boxa, SHIFTX_3, SHIFTY_3);
pixc = pixCopy(NULL, pix1);
RenderTransformedBoxa(pixc, boxa1, 213);
pixSaveTiled(pixc, pixa, 0.5, 0, 30, 32);
pixDestroy(&pixc);
pix2 = pixScale(pix1, SCALEX_3, SCALEY_3);
boxa2 = boxaScale(boxa1, SCALEX_3, SCALEY_3);
pixc = pixCopy(NULL, pix2);
RenderTransformedBoxa(pixc, boxa2, 313);
pixSaveTiled(pixc, pixa, 0.5, 1, 30, 32);
pixDestroy(&pixc);
pixGetDimensions(pix2, &w, &h, NULL);
pix3 = pixRotateAM(pix2, ROTATION_3, L_BRING_IN_WHITE);
boxa3 = boxaRotate(boxa2, w / 2, h / 2, ROTATION_3);
pixc = pixCopy(NULL, pix3);
RenderTransformedBoxa(pixc, boxa3, 413);
pixSaveTiled(pixc, pixa, 0.5, 0, 30, 32);
pixDestroy(&pixc);
/* (b) Set up and use the composite transform */
mat1 = createMatrix2dTranslate(SHIFTX_3, SHIFTY_3);
mat2 = createMatrix2dScale(SCALEX_3, SCALEY_3);
mat3 = createMatrix2dRotate(w / 2, h / 2, ROTATION_3);
l_productMat3(mat3, mat2, mat1, matd, 3);
boxa4 = boxaAffineTransform(boxa, matd);
pixc = pixCopy(NULL, pix3);
RenderTransformedBoxa(pixc, boxa4, 513);
pixSaveTiled(pixc, pixa, 0.5, 1, 30, 32);
pixDestroy(&pixc);
/* (c) Use the special 'ordered' function */
pixGetDimensions(pixs, &ws, &hs, NULL);
boxa5 = boxaTransformOrdered(boxa, SHIFTX_3, SHIFTY_3,
SCALEX_3, SCALEY_3,
ws / 2, hs / 2, ROTATION_3, L_TR_SC_RO);
pixc = pixCopy(NULL, pix3);
RenderTransformedBoxa(pixc, boxa5, 613);
pixSaveTiled(pixc, pixa, 0.5, 0, 30, 32);
pixDestroy(&pixc);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
boxaDestroy(&boxa4);
boxaDestroy(&boxa5);
lept_free(mat1);
lept_free(mat2);
lept_free(mat3);
pixt = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixt, 1000, 300, NULL, rp->display);
pixDestroy(&pixt);
pixDestroy(&pixs);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
/**
* Auto page segmentation. Divide the page image into blocks of uniform
* text linespacing and images.
*
* Width, height and resolution are derived from the input image.
*
* If the pix is non-NULL, then it is assumed to be the input, and it is
* copied to the image, otherwise the image is used directly.
*
* The output goes in the blocks list with corresponding TO_BLOCKs in the
* to_blocks list.
*
* If single_column is true, then no attempt is made to divide the image
* into columns, but multiple blocks are still made if the text is of
* non-uniform linespacing.
*/
int Tesseract::AutoPageSeg(int width, int height, int resolution,
bool single_column, IMAGE* image,
BLOCK_LIST* blocks, TO_BLOCK_LIST* to_blocks) {
int vertical_x = 0;
int vertical_y = 1;
TabVector_LIST v_lines;
TabVector_LIST h_lines;
ICOORD bleft(0, 0);
Boxa* boxa = NULL;
Pixa* pixa = NULL;
// The blocks made by the ColumnFinder. Moved to blocks before return.
BLOCK_LIST found_blocks;
#ifdef HAVE_LIBLEPT
if (pix_binary_ != NULL) {
if (textord_debug_images) {
Pix* grey_pix = pixCreate(width, height, 8);
// Printable images are light grey on white, but for screen display
// they are black on dark grey so the other colors show up well.
if (textord_debug_printable) {
pixSetAll(grey_pix);
pixSetMasked(grey_pix, pix_binary_, 192);
} else {
pixSetAllArbitrary(grey_pix, 64);
pixSetMasked(grey_pix, pix_binary_, 0);
}
AlignedBlob::IncrementDebugPix();
pixWrite(AlignedBlob::textord_debug_pix().string(), grey_pix, IFF_PNG);
pixDestroy(&grey_pix);
}
if (tessedit_dump_pageseg_images)
pixWrite("tessinput.png", pix_binary_, IFF_PNG);
// Leptonica is used to find the lines and image regions in the input.
LineFinder::FindVerticalLines(resolution, pix_binary_,
&vertical_x, &vertical_y, &v_lines);
LineFinder::FindHorizontalLines(resolution, pix_binary_, &h_lines);
if (tessedit_dump_pageseg_images)
pixWrite("tessnolines.png", pix_binary_, IFF_PNG);
ImageFinder::FindImages(pix_binary_, &boxa, &pixa);
if (tessedit_dump_pageseg_images)
pixWrite("tessnoimages.png", pix_binary_, IFF_PNG);
// Copy the Pix to the IMAGE.
image->FromPix(pix_binary_);
if (single_column)
v_lines.clear();
}
#endif
TO_BLOCK_LIST land_blocks, port_blocks;
TBOX page_box;
// The rest of the algorithm uses the usual connected components.
find_components(blocks, &land_blocks, &port_blocks, &page_box);
TO_BLOCK_IT to_block_it(&port_blocks);
ASSERT_HOST(!to_block_it.empty());
for (to_block_it.mark_cycle_pt(); !to_block_it.cycled_list();
to_block_it.forward()) {
TO_BLOCK* to_block = to_block_it.data();
TBOX blkbox = to_block->block->bounding_box();
if (to_block->line_size >= 2) {
// Note: if there are multiple blocks, then v_lines, boxa, and pixa
// are empty on the next iteration, but in this case, we assume
// that there aren't any interesting line separators or images, since
// it means that we have a pre-defined unlv zone file.
ColumnFinder finder(static_cast<int>(to_block->line_size),
blkbox.botleft(), blkbox.topright(),
&v_lines, &h_lines, vertical_x, vertical_y);
if (finder.FindBlocks(height, resolution, single_column,
to_block, boxa, pixa, &found_blocks, to_blocks) < 0)
return -1;
finder.ComputeDeskewVectors(&deskew_, &reskew_);
boxa = NULL;
pixa = NULL;
}
}
#ifdef HAVE_LIBLEPT
boxaDestroy(&boxa);
pixaDestroy(&pixa);
#endif
blocks->clear();
BLOCK_IT block_it(blocks);
// Move the found blocks to the input/output blocks.
block_it.add_list_after(&found_blocks);
if (textord_debug_images) {
// The debug image is no longer needed so delete it.
unlink(AlignedBlob::textord_debug_pix().string());
}
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, j, w, h;
l_int32 minsum[5] = { 2, 40, 50, 50, 70};
l_int32 skipdist[5] = { 5, 5, 10, 10, 30};
l_int32 delta[5] = { 2, 10, 10, 25, 40};
l_int32 maxbg[5] = {10, 15, 10, 20, 40};
BOX *box1, *box2, *box3, *box4;
BOXA *boxa;
PIX *pixs, *pixc, *pixt, *pixd, *pix32;
PIXA *pixas, *pixad;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate and save 1 bpp masks */
pixas = pixaCreate(0);
pixs = pixCreate(300, 250, 1);
pixSetAll(pixs);
box1 = boxCreate(50, 0, 140, 25);
box2 = boxCreate(120, 100, 100, 25);
box3 = boxCreate(75, 170, 80, 20);
box4 = boxCreate(150, 80, 25, 70);
pixClearInRect(pixs, box1);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box2);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box3);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box4);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
boxDestroy(&box1);
boxDestroy(&box2);
boxDestroy(&box3);
boxDestroy(&box4);
pixDestroy(&pixs);
/* Do 5 splittings on each of the 8 masks */
pixad = pixaCreate(0);
for (j = 0; j < 8; j++) {
pixt = pixaGetPix(pixas, j, L_CLONE);
pixGetDimensions(pixt, &w, &h, NULL);
pix32 = pixCreate(w, h, 32);
pixSetAll(pix32);
pixPaintThroughMask(pix32, pixt, 0, 0, 0xc0c0c000);
pixSaveTiled(pix32, pixad, 1, 1, 30, 32);
for (i = 0; i < 5; i++) {
pixc = pixCopy(NULL, pix32);
boxa = pixSplitComponentIntoBoxa(pixt, NULL, minsum[i], skipdist[i],
delta[i], maxbg[i], 0, 1);
/* boxaWriteStream(stderr, boxa); */
pixd = pixBlendBoxaRandom(pixc, boxa, 0.4);
pixRenderBoxaArb(pixd, boxa, 2, 255, 0, 0);
pixSaveTiled(pixd, pixad, 1, 0, 30, 32);
pixDestroy(&pixd);
pixDestroy(&pixc);
boxaDestroy(&boxa);
}
pixDestroy(&pixt);
pixDestroy(&pix32);
}
/* Display results */
pixd = pixaDisplay(pixad, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixad);
/* Put the 8 masks all together, and split 5 ways */
pixad = pixaCreate(0);
pixs = pixaDisplayOnLattice(pixas, 325, 325);
pixGetDimensions(pixs, &w, &h, NULL);
pix32 = pixCreate(w, h, 32);
pixSetAll(pix32);
pixPaintThroughMask(pix32, pixs, 0, 0, 0xc0c0c000);
pixSaveTiled(pix32, pixad, 1, 1, 30, 32);
for (i = 0; i < 5; i++) {
pixc = pixCopy(NULL, pix32);
boxa = pixSplitIntoBoxa(pixs, minsum[i], skipdist[i],
delta[i], maxbg[i], 0, 1);
/* boxaWriteStream(stderr, boxa); */
pixd = pixBlendBoxaRandom(pixc, boxa, 0.4);
pixRenderBoxaArb(pixd, boxa, 2, 255, 0, 0);
pixSaveTiled(pixd, pixad, 1, 0, 30, 32);
pixDestroy(&pixd);
pixDestroy(&pixc);
boxaDestroy(&boxa);
}
pixDestroy(&pix32);
pixDestroy(&pixs);
/* Display results */
pixd = pixaDisplay(pixad, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixad);
pixaDestroy(&pixas);
regTestCleanup(rp);
return 0;
}
