/*!
* pixSaveTiled()
*
* Input: pixs (1, 2, 4, 8, 32 bpp)
* pixa (the pix are accumulated here)
* scalefactor (0.0 to disable; otherwise this is a scale factor)
* newrow (0 if placed on the same row as previous; 1 otherwise)
* space (horizontal and vertical spacing, in pixels)
* dp (depth of pixa; 8 or 32 bpp; only used on first call)
* Return: 0 if OK, 1 on error.
*/
l_int32
pixSaveTiled(PIX *pixs,
PIXA *pixa,
l_float32 scalefactor,
l_int32 newrow,
l_int32 space,
l_int32 dp)
{
/* Save without an outline */
return pixSaveTiledOutline(pixs, pixa, scalefactor, newrow, space, 0, dp);
}
/*!
* pixSaveTiled()
*
* Input: pixs (1, 2, 4, 8, 32 bpp)
* pixa (the pix are accumulated here)
* reduction (0 to disable; otherwise this is a reduction factor)
* newrow (0 if placed on the same row as previous; 1 otherwise)
* space (horizontal and vertical spacing, in pixels)
* dp (depth of pixa; 8 or 32 bpp; only used on first call)
* Return: 0 if OK, 1 on error.
*/
l_int32
pixSaveTiled(PIX *pixs,
PIXA *pixa,
l_int32 reduction,
l_int32 newrow,
l_int32 space,
l_int32 dp)
{
/* Save without an outline */
return pixSaveTiledOutline(pixs, pixa, reduction, newrow, space, 0, dp);
}
void
AddTextAndSave(PIXA *pixa,
PIX *pixs,
l_int32 newrow,
L_BMF *bmf,
const char *textstr,
l_int32 location,
l_uint32 val)
{
l_int32 n, ovf;
PIX *pixt;
pixt = pixAddSingleTextblock(pixs, bmf, textstr, val, location, &ovf);
n = pixaGetCount(pixa);
pixSaveTiledOutline(pixt, pixa, 1, newrow, 30, 2, 32);
if (ovf) fprintf(stderr, "Overflow writing text in image %d\n", n + 1);
pixDestroy(&pixt);
return;
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, n;
size_t size1, size2;
BOX *box;
PIX *pix, *pix1, *pix2, *pix3;
PIXA *pixa, *pixa1;
PIXC *pixc, *pixc1, *pixc2;
PIXAC *pixac, *pixac1, *pixac2;
L_REGPARAMS *rp;
SARRAY *sa;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/comp");
pixac = pixacompCreate(1);
pixa = pixaCreate(0);
/* --- Read in the images --- */
pix1 = pixRead("marge.jpg");
pixc1 = pixcompCreateFromPix(pix1, IFF_JFIF_JPEG);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_JFIF_JPEG);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 0 */
pixSaveTiledOutline(pix3, pixa, 1.0, 1, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
pix = pixRead("feyn.tif");
pix1 = pixScaleToGray6(pix);
pixc1 = pixcompCreateFromPix(pix1, IFF_JFIF_JPEG);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_JFIF_JPEG);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 1 */
pixSaveTiledOutline(pix3, pixa, 1.0, 1, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
box = boxCreate(1144, 611, 690, 180);
pix1 = pixClipRectangle(pix, box, NULL);
pixc1 = pixcompCreateFromPix(pix1, IFF_TIFF_G4);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_TIFF_G4);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_TIFF_G4); /* 2 */
pixSaveTiledOutline(pix3, pixa, 1.0, 0, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
boxDestroy(&box);
pixDestroy(&pix);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
pix1 = pixRead("weasel4.11c.png");
pixc1 = pixcompCreateFromPix(pix1, IFF_PNG);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_PNG);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
pixSaveTiledOutline(pix3, pixa, 1.0, 0, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
/* --- Extract formatting info from compressed strings --- */
for (i = 0; i < 4; i++) {
pixc = pixacompGetPixcomp(pixac, i, L_NOCOPY);
get_format_data(i, pixc->data, pixc->size);
}
/* Save a tiled composite from the pixa */
pix1 = pixaDisplayTiledAndScaled(pixa, 32, 400, 4, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 4 */
pixDestroy(&pix1);
/* Convert the pixac --> pixa and save a tiled composite */
pixa1 = pixaCreateFromPixacomp(pixac, L_COPY);
pix1 = pixaDisplayTiledAndScaled(pixa1, 32, 400, 4, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 5 */
pixaDestroy(&pixa1);
pixDestroy(&pix1);
/* Make a pixacomp from files, and join */
sa = sarrayCreate(0);
for (i = 0; i < 6; i++)
sarrayAddString(sa, (char *)fnames[i], L_COPY);
pixac1 = pixacompCreateFromSA(sa, IFF_DEFAULT);
pixacompJoin(pixac1, pixac, 0, -1);
pixa1 = pixaCreateFromPixacomp(pixac1, L_COPY);
pix1 = pixaDisplayTiledAndScaled(pixa1, 32, 250, 10, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 6 */
pixacompDestroy(&pixac1);
pixaDestroy(&pixa1);
pixDestroy(&pix1);
sarrayDestroy(&sa);
/* Test serialized I/O */
pixacompWrite("/tmp/lept/comp/file1.pac", pixac);
regTestCheckFile(rp, "/tmp/lept/comp/file1.pac"); /* 7 */
pixac1 = pixacompRead("/tmp/lept/comp/file1.pac");
pixacompWrite("/tmp/lept/comp/file2.pac", pixac1);
regTestCheckFile(rp, "/tmp/lept/comp/file2.pac"); /* 8 */
regTestCompareFiles(rp, 7, 8); /* 9 */
pixac2 = pixacompRead("/tmp/lept/comp/file2.pac");
pixa1 = pixaCreateFromPixacomp(pixac2, L_COPY);
pix1 = pixaDisplayTiledAndScaled(pixa1, 32, 250, 4, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 10 */
pixacompDestroy(&pixac1);
pixacompDestroy(&pixac2);
pixaDestroy(&pixa1);
pixDestroy(&pix1);
/* Test serialized pixacomp I/O to and from memory */
pixacompWriteMem(&data1, &size1, pixac);
pixac1 = pixacompReadMem(data1, size1);
pixacompWriteMem(&data2, &size2, pixac1);
pixac2 = pixacompReadMem(data2, size2);
pixacompWrite("/tmp/lept/comp/file3.pac", pixac1);
regTestCheckFile(rp, "/tmp/lept/comp/file3.pac"); /* 11 */
pixacompWrite("/tmp/lept/comp/file4.pac", pixac2);
regTestCheckFile(rp, "/tmp/lept/comp/file4.pac"); /* 12 */
regTestCompareFiles(rp, 11, 12); /* 13 */
pixacompDestroy(&pixac1);
pixacompDestroy(&pixac2);
lept_free(data1);
lept_free(data2);
pixaDestroy(&pixa);
pixacompDestroy(&pixac);
return regTestCleanup(rp);
}
/*
* Test both vertical and horizontal projections on this image.
* We rotate the image by 90 degrees for the horizontal projection,
* so that the two results should be identical.
*/
void
TestProjection(L_REGPARAMS *rp,
PIX *pixs)
{
l_int32 outline;
NUMA *na1, *na2, *na3, *na4, *na5, *na6;
NUMA *na7, *na8, *na9, *na10, *na11, *na12;
PIX *pixd, *pixt;
PIXA *pixa;
outline = 2;
pixColumnStats(pixs, &na1, &na3, &na5, &na7, &na9, &na11);
pixd = pixRotateOrth(pixs, 1);
pixRowStats(pixd, &na2, &na4, &na6, &na8, &na10, &na12);
/* The png plot files are written to "/tmp/proj.0.png", etc.
* These temp files are overwritten each time this
* function is called. */
gplotSimple1(na1, GPLOT_PNG, "/tmp/proj.0", "Mean value");
gplotSimple1(na2, GPLOT_PNG, "/tmp/proj.1", "Mean value");
gplotSimple1(na3, GPLOT_PNG, "/tmp/proj.2", "Median value");
gplotSimple1(na4, GPLOT_PNG, "/tmp/proj.3", "Median value");
gplotSimple1(na5, GPLOT_PNG, "/tmp/proj.4", "Mode value");
gplotSimple1(na6, GPLOT_PNG, "/tmp/proj.5", "Mode value");
gplotSimple1(na7, GPLOT_PNG, "/tmp/proj.6", "Mode count");
gplotSimple1(na8, GPLOT_PNG, "/tmp/proj.7", "Mode count");
gplotSimple1(na9, GPLOT_PNG, "/tmp/proj.8", "Variance");
gplotSimple1(na10, GPLOT_PNG, "/tmp/proj.9", "Variance");
gplotSimple1(na11, GPLOT_PNG, "/tmp/proj.10", "Square Root Variance");
gplotSimple1(na12, GPLOT_PNG, "/tmp/proj.11", "Square Root Variance");
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
/* Each of the 12 plot files is read into a pix and then:
* (1) saved into a pixa for display
* (2) saved as a golden file (generate stage) or compared
* to the existing golden file (testing stage) */
pixa = pixaCreate(13);
pixSaveTiledOutline(pixs, pixa, 1, 1, 30, outline, 32);
pixt = pixRead("/tmp/proj.0.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 0 */
pixSaveTiledOutline(pixt, pixa, 1, 1, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.1.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 1 */
pixSaveTiledOutline(pixt, pixa, 1, 0, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.2.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixSaveTiledOutline(pixt, pixa, 1, 1, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.3.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 3 */
pixSaveTiledOutline(pixt, pixa, 1, 0, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.4.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 4 */
pixSaveTiledOutline(pixt, pixa, 1, 1, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.5.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 5 */
pixSaveTiledOutline(pixt, pixa, 1, 0, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.6.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 6 */
pixSaveTiledOutline(pixt, pixa, 1, 1, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.7.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 7 */
pixSaveTiledOutline(pixt, pixa, 1, 0, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.8.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 8 */
pixSaveTiledOutline(pixt, pixa, 1, 1, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.9.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 9 */
pixSaveTiledOutline(pixt, pixa, 1, 0, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.10.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 10 */
pixSaveTiledOutline(pixt, pixa, 1, 1, 30, outline, 32);
pixDestroy(&pixt);
pixt = pixRead("/tmp/proj.11.png");
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 11 */
pixSaveTiledOutline(pixt, pixa, 1, 0, 30, outline, 32);
pixDestroy(&pixt);
/* The pixa is composited into a pix and 'goldened'/tested */
pixt = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 12 */
pixDisplayWithTitle(pixt, 100, 0, NULL, rp->display);
pixDestroy(&pixt);
pixaDestroy(&pixa);
/* The 12 plot files are tested in pairs for identity */
regTestCompareFiles(rp, 0, 1);
regTestCompareFiles(rp, 2, 3);
regTestCompareFiles(rp, 4, 5);
regTestCompareFiles(rp, 6, 7);
regTestCompareFiles(rp, 8, 9);
regTestCompareFiles(rp, 10, 11);
pixDestroy(&pixd);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
numaDestroy(&na5);
numaDestroy(&na6);
numaDestroy(&na7);
numaDestroy(&na8);
numaDestroy(&na9);
numaDestroy(&na10);
numaDestroy(&na11);
numaDestroy(&na12);
return;
}
int main(int argc,
char **argv)
{
l_int32 i, w, h, nbox, npta, fgcount, bgcount, count;
BOXA *boxa;
PIX *pixs, *pixfg, *pixbg, *pixc, *pixb, *pixd;
PIX *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
PTA *pta;
PTAA *ptaafg, *ptaabg;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn-fract.tif");
boxa = pixConnComp(pixs, NULL, 8);
nbox = boxaGetCount(boxa);
regTestCompareValues(rp, nbox, 464, 0); /* 0 */
/* Get fg and bg boundary pixels */
pixfg = pixMorphSequence(pixs, "e3.3", 0);
pixXor(pixfg, pixfg, pixs);
pixCountPixels(pixfg, &fgcount, NULL);
regTestCompareValues(rp, fgcount, 58764, 0); /* 1 */
pixbg = pixMorphSequence(pixs, "d3.3", 0);
pixXor(pixbg, pixbg, pixs);
pixCountPixels(pixbg, &bgcount, NULL);
regTestCompareValues(rp, bgcount, 60335, 0); /* 2 */
/* Get ptaa of fg pixels */
ptaafg = ptaaGetBoundaryPixels(pixs, L_BOUNDARY_FG, 8, NULL, NULL);
npta = ptaaGetCount(ptaafg);
regTestCompareValues(rp, npta, nbox, 0); /* 3 */
count = 0;
for (i = 0; i < npta; i++) {
pta = ptaaGetPta(ptaafg, i, L_CLONE);
count += ptaGetCount(pta);
ptaDestroy(&pta);
}
regTestCompareValues(rp, fgcount, count, 0); /* 4 */
/* Get ptaa of bg pixels. Note that the number of bg pts
* is, in general, larger than the number of bg boundary pixels,
* because bg boundary pixels are shared by two c.c. that
* are 1 pixel apart. */
ptaabg = ptaaGetBoundaryPixels(pixs, L_BOUNDARY_BG, 8, NULL, NULL);
npta = ptaaGetCount(ptaabg);
regTestCompareValues(rp, npta, nbox, 0); /* 5 */
count = 0;
for (i = 0; i < npta; i++) {
pta = ptaaGetPta(ptaabg, i, L_CLONE);
count += ptaGetCount(pta);
ptaDestroy(&pta);
}
regTestCompareValues(rp, count, 60602, 0); /* 6 */
/* Render the fg boundary pixels on top of pixs. */
pixa = pixaCreate(4);
pixc = pixRenderRandomCmapPtaa(pixs, ptaafg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 7 */
pixSaveTiledOutline(pixc, pixa, 1.0, 1, 30, 2, 32);
pixDestroy(&pixc);
/* Render the bg boundary pixels on top of pixs. */
pixc = pixRenderRandomCmapPtaa(pixs, ptaabg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 8 */
pixSaveTiledOutline(pixc, pixa, 1.0, 0, 30, 2, 32);
pixDestroy(&pixc);
pixClearAll(pixs);
/* Render the fg boundary pixels alone. */
pixc = pixRenderRandomCmapPtaa(pixs, ptaafg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 9 */
pixSaveTiledOutline(pixc, pixa, 1.0, 1, 30, 2, 32);
/* Verify that the fg pixels are the same set as we
* originally started with. */
pixb = pixConvertTo1(pixc, 255);
regTestComparePix(rp, pixb, pixfg); /* 10 */
pixDestroy(&pixc);
pixDestroy(&pixb);
/* Render the bg boundary pixels alone. */
pixc = pixRenderRandomCmapPtaa(pixs, ptaabg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 11 */
pixSaveTiledOutline(pixc, pixa, 1.0, 0, 30, 2, 32);
/* Verify that the bg pixels are the same set as we
* originally started with. */
pixb = pixConvertTo1(pixc, 255);
regTestComparePix(rp, pixb, pixbg); /* 12 */
pixDestroy(&pixc);
pixDestroy(&pixb);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 0, 0, NULL, rp->display);
ptaaDestroy(&ptaafg);
ptaaDestroy(&ptaabg);
pixDestroy(&pixs);
pixDestroy(&pixfg);
pixDestroy(&pixbg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
/* Test rotation */
pix1 = pixRead("feyn-word.tif");
pix2 = pixAddBorderGeneral(pix1, 200, 200, 200, 200, 0);
pixa = pixaCreate(0);
pix3 = PtaDisplayRotate(pix2, 0, 0);
pixaAddPix(pixa, pix3, L_INSERT);
pix3 = PtaDisplayRotate(pix2, 500, 100);
pixaAddPix(pixa, pix3, L_INSERT);
pix3 = PtaDisplayRotate(pix2, 100, 410);
pixaAddPix(pixa, pix3, L_INSERT);
pix3 = PtaDisplayRotate(pix2, 500, 410);
pixaAddPix(pixa, pix3, L_INSERT);
pix4 = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 30, 2);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix4, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix4);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
/*!
* \brief pixItalicWords()
*
* \param[in] pixs 1 bpp
* \param[in] boxaw [optional] word bounding boxes; can be NULL
* \param[in] pixw [optional] word box mask; can be NULL
* \param[out] pboxa boxa of italic words
* \param[in] debugflag 1 for debug output; 0 otherwise
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) You can input the bounding boxes for the words in one of
* two forms: as bounding boxes (%boxaw) or as a word mask with
* the word bounding boxes filled (%pixw). For example,
* to compute %pixw, you can use pixWordMaskByDilation().
* (2) Alternatively, you can set both of these inputs to NULL,
* in which case the word mask is generated here. This is
* done by dilating and closing the input image to connect
* letters within a word, while leaving the words separated.
* The parameters are chosen under the assumption that the
* input is 10 to 12 pt text, scanned at about 300 ppi.
* (3) sel_ital1 and sel_ital2 detect the right edges that are
* nearly vertical, at approximately the angle of italic
* strokes. We use the right edge to avoid getting seeds
* from lower-case 'y'. The typical italic slant has a smaller
* angle with the vertical than the 'W', so in most cases we
* will not trigger on the slanted lines in the 'W'.
* (4) Note that sel_ital2 is shorter than sel_ital1. It is
* more appropriate for a typical font scanned at 200 ppi.
* </pre>
*/
l_int32
pixItalicWords(PIX *pixs,
BOXA *boxaw,
PIX *pixw,
BOXA **pboxa,
l_int32 debugflag)
{
char opstring[32];
l_int32 size;
BOXA *boxa;
PIX *pixsd, *pixm, *pixd;
SEL *sel_ital1, *sel_ital2, *sel_ital3;
PROCNAME("pixItalicWords");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!pboxa)
return ERROR_INT("&boxa not defined", procName, 1);
if (boxaw && pixw)
return ERROR_INT("both boxaw and pixw are defined", procName, 1);
sel_ital1 = selCreateFromString(str_ital1, 13, 6, NULL);
sel_ital2 = selCreateFromString(str_ital2, 10, 6, NULL);
sel_ital3 = selCreateFromString(str_ital3, 4, 2, NULL);
/* Make the italic seed: extract with HMT; remove noise.
* The noise removal close/open is important to exclude
* situations where a small slanted line accidentally
* matches sel_ital1. */
pixsd = pixHMT(NULL, pixs, sel_ital1);
pixClose(pixsd, pixsd, sel_ital3);
pixOpen(pixsd, pixsd, sel_ital3);
/* Make the word mask. Use input boxes or mask if given. */
size = 0; /* init */
if (boxaw) {
pixm = pixCreateTemplate(pixs);
pixMaskBoxa(pixm, pixm, boxaw, L_SET_PIXELS);
} else if (pixw) {
pixm = pixClone(pixw);
} else {
pixWordMaskByDilation(pixs, NULL, &size, NULL);
L_INFO("dilation size = %d\n", procName, size);
snprintf(opstring, sizeof(opstring), "d1.5 + c%d.1", size);
pixm = pixMorphSequence(pixs, opstring, 0);
}
/* Binary reconstruction to fill in those word mask
* components for which there is at least one seed pixel. */
pixd = pixSeedfillBinary(NULL, pixsd, pixm, 8);
boxa = pixConnComp(pixd, NULL, 8);
*pboxa = boxa;
if (debugflag) {
/* Save results at at 2x reduction */
lept_mkdir("lept/ital");
l_int32 res, upper;
BOXA *boxat;
GPLOT *gplot;
NUMA *na;
PIXA *pad;
PIX *pix1, *pix2, *pix3;
pad = pixaCreate(0);
boxat = pixConnComp(pixm, NULL, 8);
boxaWrite("/tmp/lept/ital/ital.ba", boxat);
pixSaveTiledOutline(pixs, pad, 0.5, 1, 20, 2, 32); /* orig */
pixSaveTiledOutline(pixsd, pad, 0.5, 1, 20, 2, 0); /* seed */
pix1 = pixConvertTo32(pixm);
pixRenderBoxaArb(pix1, boxat, 3, 255, 0, 0);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* mask + outline */
pixDestroy(&pix1);
pixSaveTiledOutline(pixd, pad, 0.5, 1, 20, 2, 0); /* ital mask */
pix1 = pixConvertTo32(pixs);
pixRenderBoxaArb(pix1, boxa, 3, 255, 0, 0);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* orig + outline */
pixDestroy(&pix1);
pix1 = pixCreateTemplate(pixs);
pix2 = pixSetBlackOrWhiteBoxa(pix1, boxa, L_SET_BLACK);
pixCopy(pix1, pixs);
pix3 = pixDilateBrick(NULL, pixs, 3, 3);
pixCombineMasked(pix1, pix3, pix2);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* ital bolded */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pix2 = pixaDisplay(pad, 0, 0);
pixWrite("/tmp/lept/ital/ital.png", pix2, IFF_PNG);
pixDestroy(&pix2);
/* Assuming the image represents 6 inches of actual page width,
* the pixs resolution is approximately
* (width of pixs in pixels) / 6
* and the images have been saved at half this resolution. */
res = pixGetWidth(pixs) / 12;
L_INFO("resolution = %d\n", procName, res);
l_pdfSetDateAndVersion(0);
pixaConvertToPdf(pad, res, 1.0, L_FLATE_ENCODE, 75, "Italic Finder",
"/tmp/lept/ital/ital.pdf");
l_pdfSetDateAndVersion(1);
pixaDestroy(&pad);
boxaDestroy(&boxat);
/* Plot histogram of horizontal white run sizes. A small
* initial vertical dilation removes most runs that are neither
* inter-character nor inter-word. The larger first peak is
* from inter-character runs, and the smaller second peak is
* from inter-word runs. */
pix1 = pixDilateBrick(NULL, pixs, 1, 15);
upper = L_MAX(30, 3 * size);
na = pixRunHistogramMorph(pix1, L_RUN_OFF, L_HORIZ, upper);
pixDestroy(&pix1);
gplot = gplotCreate("/tmp/lept/ital/runhisto", GPLOT_PNG,
"Histogram of horizontal runs of white pixels, vs length",
"run length", "number of runs");
gplotAddPlot(gplot, NULL, na, GPLOT_LINES, "plot1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&na);
}
selDestroy(&sel_ital1);
selDestroy(&sel_ital2);
selDestroy(&sel_ital3);
pixDestroy(&pixsd);
pixDestroy(&pixm);
pixDestroy(&pixd);
return 0;
}
int main(int argc,
char **argv) {
char textstr[256];
l_int32 i, thresh, fgval, bgval;
l_float32 scorefract;
L_BMF *bmf;
PIX *pixs, *pixb, *pixb2, *pixb3, *pixg, *pixp, *pixt1, *pixt2;
PIXA *pixa;
pixs = pixRead("1555-7.jpg");
pixg = pixConvertTo8(pixs, 0);
bmf = bmfCreate("fonts", 8);
for (i = 0; i < 3; i++) {
pixa = pixaCreate(3);
scorefract = 0.1 * i;
pixOtsuAdaptiveThreshold(pixg, 2000, 2000, 0, 0, scorefract,
NULL, &pixb);
pixSaveTiledOutline(pixb, pixa, 0.5, 1, 20, 2, 32);
pixSplitDistributionFgBg(pixg, scorefract, 1, &thresh, &fgval, &bgval, 1);
fprintf(stderr, "thresh = %d, fgval = %d, bgval = %d\n", thresh, fgval,
bgval);
/* Give gnuplot time to write out the plot */
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixp = pixRead("/tmp/histplot.png");
pixSaveTiled(pixp, pixa, 1.0, 0, 20, 1);
pixt1 = pixaDisplay(pixa, 0, 0);
snprintf(textstr, sizeof(textstr),
"Scorefract = %3.1f ........... Thresh = %d", scorefract, thresh);
pixt2 = pixAddSingleTextblock(pixt1, bmf, textstr, 0x00ff0000,
L_ADD_BELOW, NULL);
pixDisplay(pixt2, 100, 100);
snprintf(textstr, sizeof(textstr), "/tmp/otsu.%d.png", i);
pixWrite(textstr, pixt2, IFF_PNG);
pixDestroy(&pixb);
pixDestroy(&pixp);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixaDestroy(&pixa);
}
pixa = pixaCreate(2);
for (i = 0; i < 2; i++) {
scorefract = 0.1 * i;
pixOtsuAdaptiveThreshold(pixg, 300, 300, 0, 0, scorefract,
NULL, &pixb);
pixb2 = pixAddBlackOrWhiteBorder(pixb, 2, 2, 2, 2, L_GET_BLACK_VAL);
snprintf(textstr, sizeof(textstr),
"Scorefract = %3.1f", scorefract);
pixb3 = pixAddSingleTextblock(pixb2, bmf, textstr, 1,
L_ADD_BELOW, NULL);
pixSaveTiled(pixb3, pixa, 2, (i + 1) % 1, 20, 32);
pixDestroy(&pixb);
pixDestroy(&pixb2);
}
pixb = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/otsu-tiled.jpg", pixb, IFF_PNG);
pixDestroy(&pixb);
pixaDestroy(&pixa);
bmfDestroy(&bmf);
pixDestroy(&pixs);
pixDestroy(&pixg);
return 0;
}
int main(int argc,
char **argv)
{
char textstr[256];
l_int32 w, h, d, i;
l_uint32 srcval, dstval;
l_float32 scalefact, sat, fract;
L_BMF *bmf8;
L_KERNEL *kel;
NUMA *na;
PIX *pix, *pixs, *pixs1, *pixs2, *pixd;
PIX *pixt0, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa, *pixaf;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pix = pixRead(filein);
pixGetDimensions(pix, &w, &h, &d);
if (d != 32)
return ERROR_INT("file not 32 bpp", argv[0], 1);
scalefact = (l_float32)WIDTH / (l_float32)w;
pixs = pixScale(pix, scalefact, scalefact);
w = pixGetWidth(pixs);
pixaf = pixaCreate(5);
/* TRC: vary gamma */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixGammaTRC(NULL, pixs, 0.3 + 0.15 * i, 0, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 32);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixt1, 0, 100, "TRC Gamma", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* TRC: vary black point */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixGammaTRC(NULL, pixs, 1.0, 5 * i, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixt1, 300, 100, "TRC", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary hue */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixModifyHue(NULL, pixs, 0.01 + 0.05 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixt1, 600, 100, "Hue", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary saturation */
pixa = pixaCreate(20);
na = numaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixModifySaturation(NULL, pixs, -0.9 + 0.1 * i);
pixMeasureSaturation(pixt0, 1, &sat);
pixaAddPix(pixa, pixt0, L_INSERT);
numaAddNumber(na, sat);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
gplotSimple1(na, GPLOT_PNG, "/tmp/regout/enhance.7", "Average Saturation");
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixt1, 900, 100, "Saturation", rp->display);
numaDestroy(&na);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary contrast */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixContrastTRC(NULL, pixs, 0.1 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixt1, 0, 400, "Contrast", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary sharpening */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixUnsharpMasking(pixs, 3, 0.01 + 0.15 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixt1, 300, 400, "Sharp", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Hue constant mapping to lighter background */
pixa = pixaCreate(11);
bmf8 = bmfCreate("fonts", 8);
pixt0 = pixRead("candelabrum-11.jpg");
composeRGBPixel(230, 185, 144, &srcval); /* select typical bg pixel */
for (i = 0; i <= 10; i++) {
fract = 0.10 * i;
pixelFractionalShift(230, 185, 144, fract, &dstval);
pixt1 = pixLinearMapToTargetColor(NULL, pixt0, srcval, dstval);
snprintf(textstr, 50, "Fract = %5.1f", fract);
pixt2 = pixAddSingleTextblock(pixt1, bmf8, textstr, 0xff000000,
L_ADD_BELOW, NULL);
pixSaveTiledOutline(pixt2, pixa, 1.0, (i % 4 == 0) ? 1 : 0, 30, 2, 32);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
pixDestroy(&pixt0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixd, 600, 400, "Constant hue", rp->display);
bmfDestroy(&bmf8);
pixaDestroy(&pixa);
pixDestroy(&pixd);
/* Delayed testing of saturation plot */
regTestCheckFile(rp, "/tmp/regout/enhance.7.png"); /* 7 */
/* Display results */
pixd = pixaDisplay(pixaf, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd, 100, 100, "All", rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixaf);
pixDestroy(&pix);
pixDestroy(&pixs);
/* -----------------------------------------------*
* Test global color transforms *
* -----------------------------------------------*/
/* Make identical cmap and rgb images */
pix = pixRead("wet-day.jpg");
pixs1 = pixOctreeColorQuant(pix, 200, 0);
pixs2 = pixRemoveColormap(pixs1, REMOVE_CMAP_TO_FULL_COLOR);
regTestComparePix(rp, pixs1, pixs2); /* 9 */
/* Make a diagonal color transform matrix */
kel = kernelCreate(3, 3);
kernelSetElement(kel, 0, 0, 0.7);
kernelSetElement(kel, 1, 1, 0.4);
kernelSetElement(kel, 2, 2, 1.3);
/* Apply to both cmap and rgb images. */
pixt1 = pixMultMatrixColor(pixs1, kel);
pixt2 = pixMultMatrixColor(pixs2, kel);
regTestComparePix(rp, pixt1, pixt2); /* 10 */
kernelDestroy(&kel);
/* Apply the same transform in the simpler interface */
pixt3 = pixMultConstantColor(pixs1, 0.7, 0.4, 1.3);
pixt4 = pixMultConstantColor(pixs2, 0.7, 0.4, 1.3);
regTestComparePix(rp, pixt3, pixt4); /* 11 */
regTestComparePix(rp, pixt1, pixt3); /* 12 */
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 13 */
pixDestroy(&pix);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
PIX *pixs, *pixc, *pixd;
PIXA *pixa;
static char mainName[] = "snapcolortest";
if (argc != 1)
return ERROR_INT(" Syntax: snapcolortest", mainName, 1);
if ((pixs = pixRead("Leptonica.jpg")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixa = pixaCreate(0);
/* First, snap the color directly on the input rgb image. */
pixSaveTiledOutline(pixs, pixa, 1.0, 1, 25, 2, 32);
pixd = pixSnapColor(NULL, pixs, 0xffffff00, LEPTONICA_YELLOW, 30);
pixSaveTiledOutline(pixd, pixa, 1.0, 0, 25, 2, 32);
pixWrite("/tmp/logo1.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
/* Then make a colormapped version and snap the color */
pixd = pixOctreeQuantNumColors(pixs, 250, 0);
pixSaveTiledOutline(pixd, pixa, 1.0, 1, 25, 2, 32);
pixSnapColor(pixd, pixd, 0xffffff00, LEPTONICA_YELLOW, 30);
pixSaveTiledOutline(pixd, pixa, 1.0, 0, 25, 2, 32);
pixWrite("/tmp/logo2.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixs);
/* Set the background of the google searchbox to yellow.
* The input image is colormapped with all 256 colors used. */
if ((pixs = pixRead("google-searchbox.png")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixSaveTiledOutline(pixs, pixa, 1.0, 1, 25, 2, 32);
pixd = pixSnapColor(NULL, pixs, 0xffffff00, LEPTONICA_YELLOW, 30);
pixSaveTiledOutline(pixd, pixa, 1.0, 0, 25, 2, 32);
pixWrite("/tmp/logo3.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixs);
/* A couple of more, setting pixels near white to strange colors */
pixs = pixRead("weasel4.11c.png");
pixSaveTiledOutline(pixs, pixa, 1.0, 1, 25, 2, 32);
pixd = pixSnapColor(NULL, pixs, 0xfefefe00, 0x80800000, 50);
pixSaveTiledOutline(pixd, pixa, 1.0, 0, 25, 2, 32);
pixDestroy(&pixs);
pixDestroy(&pixd);
pixs = pixRead("wyom.jpg");
pixc = pixFixedOctcubeQuant256(pixs, 0);
pixSaveTiledOutline(pixc, pixa, 1.0, 1, 25, 2, 32);
pixd = pixSnapColor(NULL, pixc, 0xf0f0f000, 0x80008000, 100);
pixSaveTiledOutline(pixd, pixa, 1.0, 0, 25, 2, 32);
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pixd);
/* --- Display results --- */
pixd = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/snap.jpg", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, w, h, bx, by, bw, bh, index, rval, gval, bval;
BOX *box;
BOXA *boxa;
PIX *pixm, *pixs, *pixg, *pixt, *pixd;
PIXA *pixa;
PIXCMAP *cmap;
PTA *pta;
PTAA *ptaa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* ---------------- Shortest path in binary maze ---------------- */
/* Generate the maze */
pixm = generateBinaryMaze(200, 200, 20, 20, 0.65, 0.25);
pixd = pixExpandBinaryReplicate(pixm, 3);
pixSaveTiledOutline(pixd, pixa, 1, 1, 20, 2, 32);
pixDestroy(&pixd);
/* Find the shortest path between two points */
pta = pixSearchBinaryMaze(pixm, 20, 20, 170, 170, NULL);
pixt = pixDisplayPta(NULL, pixm, pta);
pixd = pixScaleBySampling(pixt, 3., 3.);
pixSaveTiledOutline(pixd, pixa, 1, 0, 20, 2, 32);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 */
ptaDestroy(&pta);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixDestroy(&pixm);
/* ---------------- Shortest path in gray maze ---------------- */
pixg = pixRead("test8.jpg");
pixGetDimensions(pixg, &w, &h, NULL);
ptaa = ptaaCreate(NPATHS);
for (i = 0; i < NPATHS; i++) {
if (x0[i] >= w || x1[i] >= w || y0[i] >= h || y1[i] >= h) {
fprintf(stderr, "path %d extends beyond image; skipping\n", i);
continue;
}
pta = pixSearchGrayMaze(pixg, x0[i], y0[i], x1[i], y1[i], NULL);
ptaaAddPta(ptaa, pta, L_INSERT);
}
pixt = pixDisplayPtaa(pixg, ptaa);
pixd = pixScaleBySampling(pixt, 2., 2.);
pixSaveTiledOutline(pixd, pixa, 1, 1, 20, 2, 32);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 1 */
ptaaDestroy(&ptaa);
pixDestroy(&pixg);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* ---------------- Largest rectangles in image ---------------- */
pixs = pixRead("test1.png");
pixd = pixConvertTo8(pixs, FALSE);
cmap = pixcmapCreateRandom(8, 1, 1);
pixSetColormap(pixd, cmap);
boxa = boxaCreate(0);
for (i = 0; i < NBOXES; i++) {
pixFindLargestRectangle(pixs, POLARITY, &box, NULL);
boxGetGeometry(box, &bx, &by, &bw, &bh);
pixSetInRect(pixs, box);
fprintf(stderr, "bx = %5d, by = %5d, bw = %5d, bh = %5d, area = %d\n",
bx, by, bw, bh, bw * bh);
boxaAddBox(boxa, box, L_INSERT);
}
for (i = 0; i < NBOXES; i++) {
index = 32 + (i & 254);
pixcmapGetColor(cmap, index, &rval, &gval, &bval);
box = boxaGetBox(boxa, i, L_CLONE);
pixRenderHashBoxArb(pixd, box, 6, 2, L_NEG_SLOPE_LINE, 1,
rval, gval, bval);
boxDestroy(&box);
}
pixSaveTiledOutline(pixd, pixa, 1, 1, 20, 2, 32);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 2 */
pixDestroy(&pixs);
pixDestroy(&pixd);
boxaDestroy(&boxa);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
