main(int argc,
char **argv)
{
l_int32 w, h, d, n;
char *filein1, *filein2, *fileout;
PIX *pixs1, *pixs2, *pixd;
static char mainName[] = "bincompare";
if (argc != 4)
exit(ERROR_INT(" Syntax: bincompare filein1 filein2 fileout",
mainName, 1));
filein1 = argv[1];
filein2 = argv[2];
fileout = argv[3];
if ((pixs1 = pixRead(filein1)) == NULL)
exit(ERROR_INT("pixs1 not made", mainName, 1));
if ((pixs2 = pixRead(filein2)) == NULL)
exit(ERROR_INT("pixs2 not made", mainName, 1));
w = pixGetWidth(pixs1);
h = pixGetHeight(pixs1);
d = pixGetDepth(pixs1);
if (d != 1)
exit(ERROR_INT("pixs1 not binary", mainName, 1));
pixCountPixels(pixs1, &n, NULL);
fprintf(stderr, "Number of fg pixels in file1 = %d\n", n);
pixCountPixels(pixs2, &n, NULL);
fprintf(stderr, "Number of fg pixels in file2 = %d\n", n);
#if XOR
fprintf(stderr, "xor: 1 ^ 2\n");
pixRasterop(pixs1, 0, 0, w, h, PIX_SRC ^ PIX_DST, pixs2, 0, 0);
pixCountPixels(pixs1, &n, NULL);
fprintf(stderr, "Number of fg pixels in XOR = %d\n", n);
pixWrite(fileout, pixs1, IFF_PNG);
#elif SUBTRACT_1_FROM_2
fprintf(stderr, "subtract: 2 - 1\n");
pixRasterop(pixs1, 0, 0, w, h, PIX_SRC & PIX_NOT(PIX_DST), pixs2, 0, 0);
pixCountPixels(pixs1, &n, NULL);
fprintf(stderr, "Number of fg pixels in 2 - 1 = %d\n", n);
pixWrite(fileout, pixs1, IFF_PNG);
#elif SUBTRACT_2_FROM_1
fprintf(stderr, "subtract: 1 - 2\n");
pixRasterop(pixs1, 0, 0, w, h, PIX_DST & PIX_NOT(PIX_SRC), pixs2, 0, 0);
pixCountPixels(pixs1, &n, NULL);
fprintf(stderr, "Number of fg pixels in 1 - 2 = %d\n", n);
pixWrite(fileout, pixs1, IFF_PNG);
#else
fprintf(stderr, "no comparison selected\n");
#endif
return 0;
}
/*!
* \brief pixFindStrokeLength()
*
* \param[in] pixs 1 bpp
* \param[in] tab8 [optional] table for counting fg pixels; can be NULL
* \param[out] *plength estimated length of the strokes
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) Returns half the number of fg boundary pixels.
* </pre>
*/
l_int32
pixFindStrokeLength(PIX *pixs,
l_int32 *tab8,
l_int32 *plength)
{
l_int32 n;
l_int32 *tab;
PIX *pix1;
PROCNAME("pixFindStrokeLength");
if (!plength)
return ERROR_INT("&length not defined", procName, 1);
*plength = 0;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
pix1 = pixExtractBoundary(pixs, 1);
tab = (tab8) ? tab8 : makePixelSumTab8();
pixCountPixels(pix1, &n, tab);
*plength = n / 2;
if (!tab8) LEPT_FREE(tab);
pixDestroy(&pix1);
return 0;
}
l_float32 ComputeCCDensity(PIX *pix) {
l_int32 area = pix->w * pix->h;
l_int32 pixel_count;
pixCountPixels(pix, &pixel_count, NULL);
return pixel_count / (l_float32) area;
}
/*!
* boxaGetCoverage()
*
* Input: boxa
* wc, hc (dimensions of overall clipping rectangle with UL
* corner at (0, 0) that is covered by the boxes.
* exactflag (1 for guaranteeing an exact result; 0 for getting
* an exact result only if the boxes do not overlap)
* &fract (<return> sum of box area as fraction of w * h)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) The boxes in boxa are clipped to the input rectangle.
* (2) * When @exactflag == 1, we generate a 1 bpp pix of size
* wc x hc, paint all the boxes black, and count the fg pixels.
* This can take 1 msec on a large page with many boxes.
* * When @exactflag == 0, we clip each box to the wc x hc region
* and sum the resulting areas. This is faster.
* * The results are the same when none of the boxes overlap
* within the wc x hc region.
*/
l_int32
boxaGetCoverage(BOXA *boxa,
l_int32 wc,
l_int32 hc,
l_int32 exactflag,
l_float32 *pfract)
{
l_int32 i, n, x, y, w, h, sum;
BOX *box, *boxc;
PIX *pixt;
PROCNAME("boxaGetCoverage");
if (!pfract)
return ERROR_INT("&fract not defined", procName, 1);
*pfract = 0.0;
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
n = boxaGetCount(boxa);
if (n == 0)
return ERROR_INT("no boxes in boxa", procName, 1);
if (exactflag == 0) { /* quick and dirty */
sum = 0;
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa, i, L_CLONE);
if ((boxc = boxClipToRectangle(box, wc, hc)) != NULL) {
boxGetGeometry(boxc, NULL, NULL, &w, &h);
sum += w * h;
boxDestroy(&boxc);
}
boxDestroy(&box);
}
}
else { /* slower and exact */
pixt = pixCreate(wc, hc, 1);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa, i, L_CLONE);
boxGetGeometry(box, &x, &y, &w, &h);
pixRasterop(pixt, x, y, w, h, PIX_SET, NULL, 0, 0);
boxDestroy(&box);
}
pixCountPixels(pixt, &sum, NULL);
pixDestroy(&pixt);
}
*pfract = (l_float32)sum / (l_float32)(wc * hc);
return 0;
}
/*!
* \brief recogGetWindowedArea()
*
* \param[in] recog
* \param[in] index of template
* \param[in] x pixel position of left hand edge of template
* \param[out] pdely y shift of template relative to pix1
* \param[out] pwsum number of fg pixels in window of pixs
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) This is called after the best path has been found through
* the trellis, in order to produce a correlation that can be used
* to evaluate the confidence we have in the identification.
* The correlation is |1 \& 2|^2 / (|1| * |2|).
* |1 \& 2| is given by the count array, |2| is found from
* nasum_u[], and |1| is wsum returned from this function.
* </pre>
*/
static l_int32
recogGetWindowedArea(L_RECOG *recog,
l_int32 index,
l_int32 x,
l_int32 *pdely,
l_int32 *pwsum)
{
l_int32 w1, h1, w2, h2;
PIX *pix1, *pix2, *pixt;
L_RDID *did;
PROCNAME("recogGetWindowedArea");
if (pdely) *pdely = 0;
if (pwsum) *pwsum = 0;
if (!pdely || !pwsum)
return ERROR_INT("&dely and &wsum not both defined", procName, 1);
if (!recog)
return ERROR_INT("recog not defined", procName, 1);
if ((did = recogGetDid(recog)) == NULL)
return ERROR_INT("did not defined", procName, 1);
if (index < 0 || index >= did->narray)
return ERROR_INT("invalid index", procName, 1);
pix1 = did->pixs;
pixGetDimensions(pix1, &w1, &h1, NULL);
if (x >= w1)
return ERROR_INT("invalid x position", procName, 1);
pix2 = pixaGetPix(recog->pixa_u, index, L_CLONE);
pixGetDimensions(pix2, &w2, &h2, NULL);
if (w1 < w2) {
L_INFO("template %d too small\n", procName, index);
pixDestroy(&pix2);
return 0;
}
*pdely = did->delya[index][x];
pixt = pixCreate(w2, h1, 1);
pixRasterop(pixt, 0, *pdely, w2, h2, PIX_SRC, pix2, 0, 0);
pixRasterop(pixt, 0, 0, w2, h1, PIX_SRC & PIX_DST, pix1, x, 0);
pixCountPixels(pixt, pwsum, recog->sumtab);
pixDestroy(&pix2);
pixDestroy(&pixt);
return 0;
}
/*!
* pixConnCompAreaTransform()
*
* Input: pixs (1 bpp)
* connect (connectivity: 4 or 8)
* Return: pixd (16 bpp), or null on error
*
* Notes:
* (1) The pixel values in pixd label the area of the fg component
* to which the pixel belongs. Pixels in the bg are labelled 0.
* (2) The pixel values cannot exceed 2^16 - 1, even if the area
* of the c.c. is larger.
* (3) For purposes of visualization, the output can be converted
* to 8 bpp, using pixConvert16To8() or pixMaxDynamicRange().
*/
PIX *
pixConnCompAreaTransform(PIX *pixs,
l_int32 connect)
{
l_int32 i, n, npix, w, h, xb, yb, wb, hb;
l_int32 *tab8;
BOXA *boxa;
PIX *pix1, *pix2, *pixd;
PIXA *pixa;
PROCNAME("pixConnCompTransform");
if (!pixs || pixGetDepth(pixs) != 1)
return (PIX *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (connect != 4 && connect != 8)
return (PIX *)ERROR_PTR("connectivity must be 4 or 8", procName, NULL);
boxa = pixConnComp(pixs, &pixa, connect);
n = pixaGetCount(pixa);
boxaDestroy(&boxa);
pixGetDimensions(pixs, &w, &h, NULL);
pixd = pixCreate(w, h, 16);
if (n == 0) { /* no fg */
pixaDestroy(&pixa);
return pixd;
}
/* Label each component and blit it in */
tab8 = makePixelSumTab8();
for (i = 0; i < n; i++) {
pixaGetBoxGeometry(pixa, i, &xb, &yb, &wb, &hb);
pix1 = pixaGetPix(pixa, i, L_CLONE);
pixCountPixels(pix1, &npix, tab8);
npix = L_MIN(npix, 0xffff);
pix2 = pixConvert1To16(NULL, pix1, 0, npix);
pixRasterop(pixd, xb, yb, wb, hb, PIX_PAINT, pix2, 0, 0);
pixDestroy(&pix1);
pixDestroy(&pix2);
}
pixaDestroy(&pixa);
FREE(tab8);
return pixd;
}
// Returns the number of black pixels found in the box made by adding the line
// width to both sides of the line bounding box. (Increasing the smallest
// dimension of the bounding box.)
static int CountPixelsAdjacentToLine(int line_width, Box* line_box,
Pix* nonline_pix) {
l_int32 x, y, box_width, box_height;
boxGetGeometry(line_box, &x, &y, &box_width, &box_height);
if (box_width > box_height) {
// horizontal line.
int bottom = MIN(pixGetHeight(nonline_pix), y + box_height + line_width);
y = MAX(0, y - line_width);
box_height = bottom - y;
} else {
// Vertical line.
int right = MIN(pixGetWidth(nonline_pix), x + box_width + line_width);
x = MAX(0, x - line_width);
box_width = right - x;
}
Box* box = boxCreate(x, y, box_width, box_height);
Pix* rect_pix = pixClipRectangle(nonline_pix, box, NULL);
boxDestroy(&box);
l_int32 result;
pixCountPixels(rect_pix, &result, NULL);
pixDestroy(&rect_pix);
return result;
}
/*!
* \brief pixConnCompBB()
*
* \param[in] pixs 1 bpp
* \param[in] connectivity 4 or 8
* \return boxa, or NULL on error
*
* <pre>
* Notes:
* (1) Finds bounding boxes of 4- or 8-connected components
* in a binary image.
* (2) This works on a copy of the input pix. The c.c. are located
* in raster order and erased one at a time. In the process,
* the b.b. is computed and saved.
* </pre>
*/
BOXA *
pixConnCompBB(PIX *pixs,
l_int32 connectivity)
{
l_int32 h, iszero;
l_int32 x, y, xstart, ystart;
PIX *pixt;
BOX *box;
BOXA *boxa;
L_STACK *stack, *auxstack;
PROCNAME("pixConnCompBB");
if (!pixs || pixGetDepth(pixs) != 1)
return (BOXA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (connectivity != 4 && connectivity != 8)
return (BOXA *)ERROR_PTR("connectivity not 4 or 8", procName, NULL);
boxa = NULL;
pixt = NULL;
stack = NULL;
pixZero(pixs, &iszero);
if (iszero)
return boxaCreate(1); /* return empty boxa */
if ((pixt = pixCopy(NULL, pixs)) == NULL)
return (BOXA *)ERROR_PTR("pixt not made", procName, NULL);
h = pixGetHeight(pixs);
if ((stack = lstackCreate(h)) == NULL) {
L_ERROR("stack not made\n", procName);
goto cleanup;
}
auxstack = lstackCreate(0);
stack->auxstack = auxstack;
boxa = boxaCreate(0);
xstart = 0;
ystart = 0;
while (1) {
if (!nextOnPixelInRaster(pixt, xstart, ystart, &x, &y))
break;
if ((box = pixSeedfillBB(pixt, stack, x, y, connectivity)) == NULL) {
L_ERROR("box not made\n", procName);
boxaDestroy(&boxa);
goto cleanup;
}
boxaAddBox(boxa, box, L_INSERT);
xstart = x;
ystart = y;
}
#if DEBUG
pixCountPixels(pixt, &iszero, NULL);
fprintf(stderr, "Number of remaining pixels = %d\n", iszero);
pixWrite("junkremain", pixt1, IFF_PNG);
#endif /* DEBUG */
/* Cleanup, freeing the fillsegs on each stack */
cleanup:
lstackDestroy(&stack, TRUE);
pixDestroy(&pixt);
return boxa;
}
l_int32 main(int argc,
char **argv)
{
char buf[512];
l_int32 delx, dely, etransx, etransy, w, h, area1, area2;
l_int32 *stab, *ctab;
l_float32 cx1, cy1, cx2, cy2, score;
PIX *pix0, *pix1, *pix2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Test of pixBestCorrelation() --------------- */
pix0 = pixRead("harmoniam100-11.png");
pix1 = pixConvertTo1(pix0, 160);
pixGetDimensions(pix1, &w, &h, NULL);
/* Now make a smaller image, translated by (-32, -12)
* Except for the resizing, this is equivalent to
* pix2 = pixTranslate(NULL, pix1, -32, -12, L_BRING_IN_WHITE); */
pix2 = pixCreate(w - 10, h, 1);
pixRasterop(pix2, 0, 0, w, h, PIX_SRC, pix1, 32, 12);
/* Get the number of FG pixels and the centroid locations */
stab = makePixelSumTab8();
ctab = makePixelCentroidTab8();
pixCountPixels(pix1, &area1, stab);
pixCountPixels(pix2, &area2, stab);
pixCentroid(pix1, ctab, stab, &cx1, &cy1);
pixCentroid(pix2, ctab, stab, &cx2, &cy2);
etransx = lept_roundftoi(cx1 - cx2);
etransy = lept_roundftoi(cy1 - cy2);
fprintf(stderr, "delta cx = %d, delta cy = %d\n",
etransx, etransy);
/* Get the best correlation, searching around the translation
* where the centroids coincide */
pixBestCorrelation(pix1, pix2, area1, area2, etransx, etransy,
4, stab, &delx, &dely, &score, 5);
fprintf(stderr, "delx = %d, dely = %d, score = %7.4f\n",
delx, dely, score);
regTestCompareValues(rp, 32, delx, 0); /* 0 */
regTestCompareValues(rp, 12, dely, 0); /* 1 */
regTestCheckFile(rp, "/tmp/junkcorrel_5.png"); /* 2 */
lept_rm(NULL, "junkcorrel_5.png");
FREE(stab);
FREE(ctab);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------ Test of pixCompareWithTranslation() ------------ */
/* Now use the pyramid to get the result. Do a translation
* to remove pixels at the bottom from pix2, so that the
* centroids are initially far apart. */
pix1 = pixRead("harmoniam-11.tif");
pix2 = pixTranslate(NULL, pix1, -45, 25, L_BRING_IN_WHITE);
l_pdfSetDateAndVersion(0);
pixCompareWithTranslation(pix1, pix2, 160, &delx, &dely, &score, 1);
pixDestroy(&pix1);
pixDestroy(&pix2);
fprintf(stderr, "delx = %d, dely = %d\n", delx, dely);
regTestCompareValues(rp, 45, delx, 0); /* 3 */
regTestCompareValues(rp, -25, dely, 0); /* 4 */
regTestCheckFile(rp, "/tmp/junkcmp.pdf"); /* 5 */
regTestCheckFile(rp, "/tmp/junkcorrel.pdf"); /* 6 */
return regTestCleanup(rp);
}
/*!
* \brief pixConnCompPixa()
*
* \param[in] pixs 1 bpp
* \param[out] ppixa pixa of each c.c.
* \param[in] connectivity 4 or 8
* \return boxa, or NULL on error
*
* <pre>
* Notes:
* (1) This finds bounding boxes of 4- or 8-connected components
* in a binary image, and saves images of each c.c
* in a pixa array.
* (2) It sets up 2 temporary pix, and for each c.c. that is
* located in raster order, it erases the c.c. from one pix,
* then uses the b.b. to extract the c.c. from the two pix using
* an XOR, and finally erases the c.c. from the second pix.
* (3) A clone of the returned boxa (where all boxes in the array
* are clones) is inserted into the pixa.
* (4) If the input is valid, this always returns a boxa and a pixa.
* If pixs is empty, the boxa and pixa will be empty.
* </pre>
*/
BOXA *
pixConnCompPixa(PIX *pixs,
PIXA **ppixa,
l_int32 connectivity)
{
l_int32 h, iszero;
l_int32 x, y, xstart, ystart;
PIX *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
BOX *box;
BOXA *boxa;
L_STACK *stack, *auxstack;
PROCNAME("pixConnCompPixa");
if (!ppixa)
return (BOXA *)ERROR_PTR("&pixa not defined", procName, NULL);
*ppixa = NULL;
if (!pixs || pixGetDepth(pixs) != 1)
return (BOXA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (connectivity != 4 && connectivity != 8)
return (BOXA *)ERROR_PTR("connectivity not 4 or 8", procName, NULL);
boxa = NULL;
pix1 = pix2 = pix3 = pix4 = NULL;
stack = NULL;
pixZero(pixs, &iszero);
if (iszero)
return boxaCreate(1); /* return empty boxa */
pix1 = pixCopy(NULL, pixs);
pix2 = pixCopy(NULL, pixs);
if (!pix1 || !pix2) {
L_ERROR("pix1 or pix2 not made\n", procName);
goto cleanup;
}
h = pixGetHeight(pixs);
if ((stack = lstackCreate(h)) == NULL) {
L_ERROR("stack not made\n", procName);
goto cleanup;
}
auxstack = lstackCreate(0);
stack->auxstack = auxstack;
pixa = pixaCreate(0);
boxa = boxaCreate(0);
xstart = 0;
ystart = 0;
while (1) {
if (!nextOnPixelInRaster(pix1, xstart, ystart, &x, &y))
break;
if ((box = pixSeedfillBB(pix1, stack, x, y, connectivity)) == NULL) {
L_ERROR("box not made\n", procName);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
goto cleanup;
}
boxaAddBox(boxa, box, L_INSERT);
/* Save the c.c. and remove from pix2 as well */
pix3 = pixClipRectangle(pix1, box, NULL);
pix4 = pixClipRectangle(pix2, box, NULL);
pixXor(pix3, pix3, pix4);
pixRasterop(pix2, box->x, box->y, box->w, box->h, PIX_SRC ^ PIX_DST,
pix3, 0, 0);
pixaAddPix(pixa, pix3, L_INSERT);
pixDestroy(&pix4);
xstart = x;
ystart = y;
}
#if DEBUG
pixCountPixels(pix1, &iszero, NULL);
fprintf(stderr, "Number of remaining pixels = %d\n", iszero);
pixWrite("junkremain", pix1, IFF_PNG);
#endif /* DEBUG */
/* Remove old boxa of pixa and replace with a clone copy */
boxaDestroy(&pixa->boxa);
pixa->boxa = boxaCopy(boxa, L_CLONE);
*ppixa = pixa;
/* Cleanup, freeing the fillsegs on each stack */
cleanup:
lstackDestroy(&stack, TRUE);
pixDestroy(&pix1);
pixDestroy(&pix2);
return boxa;
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb; /* for color content extraction */
PIXA *pixa, *pixat;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate a pdf of results when called with display */
pixa = pixaCreate(0);
/* Generate colors by sampling hue with max sat and value.
* This image has been saved as 19-colors.png. */
pixat = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixat, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixat, 32, 1100, 1.0, 0, 0, 0);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 0 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixaDestroy(&pixat);
/* Colorspace conversion in rgb */
pixs = pixRead("wyom.jpg");
pixaAddPix(pixa, pixs, L_INSERT);
pixt = pixConvertRGBToHSV(NULL, pixs);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_COPY);
pixConvertHSVToRGB(pixt, pixt);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 2 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 3 */
pixaAddPix(pixa, pixt, L_COPY);
cmap = pixGetColormap(pixt);
if (rp->display) pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixcmapConvertHSVToRGB(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
regTestWritePixAndCheck(rp, pixr, IFF_JFIF_JPEG); /* 6 */
pixaAddPix(pixa, pixr, L_INSERT);
regTestWritePixAndCheck(rp, pixg, IFF_JFIF_JPEG); /* 7 */
pixaAddPix(pixa, pixg, L_INSERT);
regTestWritePixAndCheck(rp, pixb, IFF_JFIF_JPEG); /* 8 */
pixaAddPix(pixa, pixb, L_INSERT);
/* Color content measurement. This tests the global
* mapping of (r,g,b) --> (white), for 20 different
* values of (r,g,b). For each mappings, we compute
* the color magnitude and threshold it at six values.
* For each of those six thresholds, we plot the
* fraction of pixels that exceeds the threshold
* color magnitude, where the red value (mapped to
* white) goes between 100 and 195. */
pixat = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixat, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/regout/colorspace.10", GPLOT_PNG,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/regout/colorspace.11", GPLOT_PNG,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixat, 32, 250, 4, 0, 10, 2);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 9 */
pixaAddPix(pixa, pixt1, L_INSERT);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", rp->display);
pixaDestroy(&pixat);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
/* Give gnuplot time to write out the files */
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
/* Save as golden files, or check against them */
regTestCheckFile(rp, "/tmp/regout/colorspace.10.png"); /* 10 */
regTestCheckFile(rp, "/tmp/regout/colorspace.11.png"); /* 11 */
if (rp->display) {
pixt = pixRead("/tmp/regout/colorspace.10.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixt = pixRead("/tmp/regout/colorspace.11.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixaConvertToPdf(pixa, 0, 1.0, 0, 0, "colorspace tests",
"/tmp/regout/colorspace.pdf");
L_INFO("Output pdf: /tmp/regout/colorspace.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
int
main(int argc, char **argv) {
if (argc < 3)
return usage(argv[0]);
char highlight = 0;
char ignore_scrollbars = 1;
/* Default output filename; can be overridden by command line. */
const char *output_filename = "highlight.png";
int argi = 1;
for (; argi < argc; ++argi) {
if (strcmp("--highlight", argv[argi]) == 0) {
highlight = 1;
} else if (strcmp("--no-ignore-scrollbars", argv[argi]) == 0) {
ignore_scrollbars = 0;
} else if (strcmp("--output", argv[argi]) == 0) {
if (argi + 1 >= argc) {
fprintf(stderr, "missing argument to --output\n");
return 1;
}
output_filename = argv[++argi];
} else {
break;
}
}
if (argc - argi < 2)
return usage(argv[0]);
PIX *a = pixRead(argv[argi]);
PIX *b = pixRead(argv[argi + 1]);
if (!a) {
fprintf(stderr, "Failed to open %s\n", argv[argi]);
return 1;
}
if (!b) {
fprintf(stderr, "Failed to open %s\n", argv[argi + 1]);
return 1;
}
if (pixGetWidth(a) != pixGetWidth(b) ||
pixGetHeight(a) != pixGetHeight(b)) {
fprintf(stderr, "Inputs are difference sizes\n");
return 1;
}
PIX *delta = pixAbsDifference(a, b);
pixInvert(delta, delta);
if (!highlight)
pixDestroy(&a);
pixDestroy(&b);
PIX *deltagray = pixConvertRGBToGray(delta, 0, 0, 0);
pixDestroy(&delta);
PIX *deltabinary = pixThresholdToBinary(deltagray, 254);
PIX *deltabinaryclipped;
const int clipwidth = pixGetWidth(deltabinary) - 15;
const int clipheight = pixGetHeight(deltabinary) - 15;
if (ignore_scrollbars && clipwidth > 0 && clipheight > 0) {
BOX *clip = boxCreate(0, 0, clipwidth, clipheight);
deltabinaryclipped = pixClipRectangle(deltabinary, clip, NULL);
boxDestroy(&clip);
pixDestroy(&deltabinary);
} else {
deltabinaryclipped = deltabinary;
deltabinary = NULL;
}
PIX *hopened = pixOpenBrick(NULL, deltabinaryclipped, 3, 1);
PIX *vopened = pixOpenBrick(NULL, deltabinaryclipped, 1, 3);
pixDestroy(&deltabinaryclipped);
PIX *opened = pixOr(NULL, hopened, vopened);
pixDestroy(&hopened);
pixDestroy(&vopened);
l_int32 count;
pixCountPixels(opened, &count, NULL);
fprintf(stderr, "%d\n", count);
if (count && highlight) {
PIX *d1 = pixDilateBrick(NULL, opened, 7, 7);
PIX *d2 = pixDilateBrick(NULL, opened, 3, 3);
pixInvert(d2, d2);
pixAnd(d1, d1, d2);
pixPaintThroughMask(a, d1, 0, 0, 0xff << 24);
pixWrite(output_filename, a, IFF_PNG);
}
return count > 0;
}
/*!
* pixMirrorDetectDwa()
*
* Input: pixs (1 bpp, deskewed, English text)
* &conf (<return> confidence that text is not LR mirror reversed)
* mincount (min number of left + right; use 0 for default)
* debug (1 for debug output; 0 otherwise)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) We assume the text is horizontally oriented, with
* ascenders going up.
* (2) See notes in pixMirrorDetect().
*/
l_int32
pixMirrorDetectDwa(PIX *pixs,
l_float32 *pconf,
l_int32 mincount,
l_int32 debug)
{
char flipsel1[] = "flipsel1";
char flipsel2[] = "flipsel2";
l_int32 count1, count2, nmax;
l_float32 nleft, nright;
PIX *pixt0, *pixt1, *pixt2, *pixt3;
PROCNAME("pixMirrorDetectDwa");
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_MIRROR_FLIP_COUNT;
/* Fill x-height characters but not space between them, sort of. */
pixt3 = pixMorphSequenceDwa(pixs, "d1.30", 0);
pixXor(pixt3, pixt3, pixs);
pixt0 = pixMorphSequenceDwa(pixs, "c15.1", 0);
pixXor(pixt0, pixt0, pixs);
pixAnd(pixt0, pixt0, pixt3);
pixOr(pixt3, pixt0, pixs);
pixDestroy(&pixt0);
pixt0 = pixAddBorderGeneral(pixt3, ADDED_BORDER, ADDED_BORDER,
ADDED_BORDER, ADDED_BORDER, 0);
pixDestroy(&pixt3);
/* Filter the right-facing characters. */
pixt1 = pixFlipFHMTGen(NULL, pixt0, flipsel1);
pixt3 = pixReduceRankBinaryCascade(pixt1, 1, 1, 0, 0);
pixCountPixels(pixt3, &count1, NULL);
pixDestroy(&pixt1);
pixDestroy(&pixt3);
/* Filter the left-facing characters. */
pixt2 = pixFlipFHMTGen(NULL, pixt0, flipsel2);
pixt3 = pixReduceRankBinaryCascade(pixt2, 1, 1, 0, 0);
pixCountPixels(pixt3, &count2, NULL);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt0);
nright = (l_float32)count1;
nleft = (l_float32)count2;
nmax = L_MAX(count1, count2);
if (nmax > mincount)
*pconf = 2. * ((nright - nleft) / sqrt(nright + nleft));
if (debug) {
fprintf(stderr, "nright = %f, nleft = %f\n", nright, nleft);
if (*pconf > DEFAULT_MIN_MIRROR_FLIP_CONF)
fprintf(stderr, "Text is not mirror reversed\n");
if (*pconf < -DEFAULT_MIN_MIRROR_FLIP_CONF)
fprintf(stderr, "Text is mirror reversed\n");
}
return 0;
}
/*!
* \brief recogMakeDecodingArray()
*
* \param[in] recog
* \param[in] index of averaged template
* \param[in] debug 1 for debug output; 0 otherwise
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) Generates the bit-and sum array for a character template along pixs.
* (2) The values are saved in the scoring arrays at the left edge
* of the template as it is positioned on pixs.
* </pre>
*/
static l_int32
recogMakeDecodingArray(L_RECOG *recog,
l_int32 index,
l_int32 debug)
{
l_int32 i, j, w1, h1, w2, h2, nx, ycent2, count, maxcount, maxdely;
l_int32 sum, moment, dely, shifty;
l_int32 *counta, *delya, *ycent1, *arraysum, *arraymoment, *sumtab;
NUMA *nasum, *namoment;
PIX *pix1, *pix2, *pix3;
L_RDID *did;
PROCNAME("recogMakeDecodingArray");
if (!recog)
return ERROR_INT("recog not defined", procName, 1);
if ((did = recogGetDid(recog)) == NULL)
return ERROR_INT("did not defined", procName, 1);
if (index < 0 || index >= did->narray)
return ERROR_INT("invalid index", procName, 1);
/* Check that pix1 is large enough for this template. */
pix1 = did->pixs; /* owned by did; do not destroy */
pixGetDimensions(pix1, &w1, &h1, NULL);
pix2 = pixaGetPix(recog->pixa_u, index, L_CLONE);
pixGetDimensions(pix2, &w2, &h2, NULL);
if (w1 < w2) {
L_INFO("w1 = %d < w2 = %d for index %d\n", procName, w1, w2, index);
pixDestroy(&pix2);
return 0;
}
nasum = did->nasum;
namoment = did->namoment;
ptaGetIPt(recog->pta_u, index, NULL, &ycent2);
sumtab = recog->sumtab;
counta = did->counta[index];
delya = did->delya[index];
/* Set up the array for ycent1. This gives the y-centroid location
* for a window of width w2, starting at location i. */
nx = w1 - w2 + 1; /* number of positions w2 can be placed in w1 */
ycent1 = (l_int32 *)LEPT_CALLOC(nx, sizeof(l_int32));
arraysum = numaGetIArray(nasum);
arraymoment = numaGetIArray(namoment);
for (i = 0, sum = 0, moment = 0; i < w2; i++) {
sum += arraysum[i];
moment += arraymoment[i];
}
for (i = 0; i < nx - 1; i++) {
ycent1[i] = (sum == 0) ? ycent2 : (l_float32)moment / (l_float32)sum;
sum += arraysum[w2 + i] - arraysum[i];
moment += arraymoment[w2 + i] - arraymoment[i];
}
ycent1[nx - 1] = (sum == 0) ? ycent2 : (l_float32)moment / (l_float32)sum;
/* Compute the bit-and sum between the template pix2 and pix1, at
* locations where the left side of pix2 goes from 0 to nx - 1
* in pix1. Do this around the vertical alignment of the pix2
* centroid and the windowed pix1 centroid.
* (1) Start with pix3 cleared and approximately equal in size to pix1.
* (2) Blit the y-shifted pix2 onto pix3. Then all ON pixels
* are within the intersection of pix1 and the shifted pix2.
* (3) AND pix1 with pix3. */
pix3 = pixCreate(w2, h1, 1);
for (i = 0; i < nx; i++) {
shifty = (l_int32)(ycent1[i] - ycent2 + 0.5);
maxcount = 0;
for (j = -MaxYShift; j <= MaxYShift; j++) {
pixClearAll(pix3);
dely = shifty + j; /* amount pix2 is shifted relative to pix1 */
pixRasterop(pix3, 0, dely, w2, h2, PIX_SRC, pix2, 0, 0);
pixRasterop(pix3, 0, 0, w2, h1, PIX_SRC & PIX_DST, pix1, i, 0);
pixCountPixels(pix3, &count, sumtab);
if (count > maxcount) {
maxcount = count;
maxdely = dely;
}
}
counta[i] = maxcount;
delya[i] = maxdely;
}
did->fullarrays = TRUE;
pixDestroy(&pix2);
pixDestroy(&pix3);
LEPT_FREE(ycent1);
LEPT_FREE(arraysum);
LEPT_FREE(arraymoment);
return 0;
}
void
RotateOrthTest(PIX *pixs,
L_REGPARAMS *rp)
{
l_int32 zero, count;
PIX *pixt, *pixd;
PIXCMAP *cmap;
cmap = pixGetColormap(pixs);
/* Test 4 successive 90 degree rotations */
pixt = pixRotate90(pixs, 1);
pixd = pixRotate90(pixt, 1);
pixDestroy(&pixt);
pixt = pixRotate90(pixd, 1);
pixDestroy(&pixd);
pixd = pixRotate90(pixt, 1);
pixDestroy(&pixt);
regTestComparePix(rp, pixs, pixd);
if (!cmap) {
pixXor(pixd, pixd, pixs);
pixZero(pixd, &zero);
if (zero)
fprintf(stderr, "OK. Four 90-degree rotations gives I\n");
else {
pixCountPixels(pixd, &count, NULL);
fprintf(stderr, "Failure for four 90-degree rots; count = %d\n",
count);
}
}
pixDestroy(&pixd);
/* Test 2 successive 180 degree rotations */
pixt = pixRotate180(NULL, pixs);
pixRotate180(pixt, pixt);
regTestComparePix(rp, pixs, pixt);
if (!cmap) {
pixXor(pixt, pixt, pixs);
pixZero(pixt, &zero);
if (zero)
fprintf(stderr, "OK. Two 180-degree rotations gives I\n");
else {
pixCountPixels(pixt, &count, NULL);
fprintf(stderr, "Failure for two 180-degree rots; count = %d\n",
count);
}
}
pixDestroy(&pixt);
/* Test 2 successive LR flips */
pixt = pixFlipLR(NULL, pixs);
pixFlipLR(pixt, pixt);
regTestComparePix(rp, pixs, pixt);
if (!cmap) {
pixXor(pixt, pixt, pixs);
pixZero(pixt, &zero);
if (zero)
fprintf(stderr, "OK. Two LR flips gives I\n");
else {
pixCountPixels(pixt, &count, NULL);
fprintf(stderr, "Failure for two LR flips; count = %d\n", count);
}
}
pixDestroy(&pixt);
/* Test 2 successive TB flips */
pixt = pixFlipTB(NULL, pixs);
pixFlipTB(pixt, pixt);
regTestComparePix(rp, pixs, pixt);
if (!cmap) {
pixXor(pixt, pixt, pixs);
pixZero(pixt, &zero);
if (zero)
fprintf(stderr, "OK. Two TB flips gives I\n");
else {
pixCountPixels(pixt, &count, NULL);
fprintf(stderr, "Failure for two TB flips; count = %d\n", count);
}
}
pixDestroy(&pixt);
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);
}
/*!
* 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;
}
/*!
* \brief pixUpDownDetectGeneral()
*
* \param[in] pixs 1 bpp, deskewed, English text, 150 - 300 ppi
* \param[out] pconf confidence that text is rightside-up
* \param[in] mincount min number of up + down; use 0 for default
* \param[in] npixels number of pixels removed from each side of word box
* \param[in] debug 1 for debug output; 0 otherwise
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) See pixOrientDetect() for other details.
* (2) %conf is the normalized difference between the number of
* detected up and down ascenders, assuming that the text
* is either rightside-up or upside-down and not rotated
* at a 90 degree angle.
* (3) The typical mode of operation is %npixels == 0.
* If %npixels > 0, this removes HMT matches at the
* beginning and ending of "words." This is useful for
* pages that may have mostly digits, because if npixels == 0,
* leading "1" and "3" digits can register as having
* ascenders or descenders, and "7" digits can match descenders.
* Consequently, a page image of only digits may register
* as being upside-down.
* (4) We want to count the number of instances found using the HMT.
* An expensive way to do this would be to count the
* number of connected components. A cheap way is to do a rank
* reduction cascade that reduces each component to a single
* pixel, and results (after two or three 2x reductions)
* in one pixel for each of the original components.
* After the reduction, you have a much smaller pix over
* which to count pixels. We do only 2 reductions, because
* this function is designed to work for input pix between
* 150 and 300 ppi, and an 8x reduction on a 150 ppi image
* is going too far -- components will get merged.
* </pre>
*/
l_int32
pixUpDownDetectGeneral(PIX *pixs,
l_float32 *pconf,
l_int32 mincount,
l_int32 npixels,
l_int32 debug)
{
l_int32 countup, countdown, nmax;
l_float32 nup, ndown;
PIX *pix0, *pix1, *pix2, *pix3, *pixm;
SEL *sel1, *sel2, *sel3, *sel4;
PROCNAME("pixUpDownDetectGeneral");
if (!pconf)
return ERROR_INT("&conf not defined", procName, 1);
*pconf = 0.0;
if (!pixs || pixGetDepth(pixs) != 1)
return ERROR_INT("pixs not defined or not 1 bpp", procName, 1);
if (mincount == 0)
mincount = DEFAULT_MIN_UP_DOWN_COUNT;
if (npixels < 0)
npixels = 0;
lept_mkdir("lept/orient");
sel1 = selCreateFromString(textsel1, 5, 6, NULL);
sel2 = selCreateFromString(textsel2, 5, 6, NULL);
sel3 = selCreateFromString(textsel3, 5, 6, NULL);
sel4 = selCreateFromString(textsel4, 5, 6, NULL);
/* 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. */
pix0 = pixMorphCompSequence(pixs, "c1.8 + c30.1", 0);
/* 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;
pix1 = pixMorphSequence(pix0, "o10.1", 0);
boxa = pixConnComp(pix1, NULL, 8);
pixm = pixCreateTemplate(pix1);
pixDestroy(&pix1);
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 at the beginning of this function. */
pix1 = pixHMT(NULL, pix0, sel1);
pix2 = pixHMT(NULL, pix0, sel2);
pixOr(pix1, pix1, pix2);
if (pixm)
pixAnd(pix1, pix1, pixm);
pix3 = pixReduceRankBinaryCascade(pix1, 1, 1, 0, 0);
pixCountPixels(pix3, &countup, NULL);
pixDebugFlipDetect("/tmp/lept/orient/up.png", pixs, pix1, debug);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Find the ascenders and optionally filter with pixm. */
pix1 = pixHMT(NULL, pix0, sel3);
pix2 = pixHMT(NULL, pix0, sel4);
pixOr(pix1, pix1, pix2);
if (pixm)
pixAnd(pix1, pix1, pixm);
pix3 = pixReduceRankBinaryCascade(pix1, 1, 1, 0, 0);
pixCountPixels(pix3, &countdown, NULL);
pixDebugFlipDetect("/tmp/lept/orient/down.png", pixs, pix1, debug);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 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) pixWriteDebug("/tmp/lept/orient/pixm1.png", 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(&pix0);
pixDestroy(&pixm);
selDestroy(&sel1);
selDestroy(&sel2);
selDestroy(&sel3);
selDestroy(&sel4);
return 0;
}
main(int argc,
char **argv)
{
char *text;
l_int32 w, h, d, wpl, count, npages, color, format, bps, spp, iscmap;
FILE *fp;
PIX *pix;
PIXCMAP *cmap;
char *filein;
static char mainName[] = "fileinfo";
if (argc != 2)
exit(ERROR_INT(" Syntax: fileinfo filein", mainName, 1));
filein = argv[1];
l_pngSetStrip16To8(0); /* to preserve 16 bpp if format is png */
/* Read the full image */
if ((pix = pixRead(filein)) == NULL)
exit(ERROR_INT("image not returned from file", mainName, 1));
format = pixGetInputFormat(pix);
pixGetDimensions(pix, &w, &h, &d);
wpl = pixGetWpl(pix);
fprintf(stderr, "Reading the full image:\n");
fprintf(stderr, " Input image format type: %s\n",
ImageFileFormatExtensions[format]);
fprintf(stderr, " w = %d, h = %d, d = %d, wpl = %d\n", w, h, d, wpl);
fprintf(stderr, " xres = %d, yres = %d\n",
pixGetXRes(pix), pixGetYRes(pix));
text = pixGetText(pix);
if (text) /* not null */
fprintf(stderr, " Text: %s\n", text);
cmap = pixGetColormap(pix);
if (cmap) {
pixcmapHasColor(cmap, &color);
if (color)
fprintf(stderr, " Colormap exists and has color values:");
else
fprintf(stderr, " Colormap exists and has only gray values:");
pixcmapWriteStream(stderr, pixGetColormap(pix));
}
else
fprintf(stderr, " Colormap does not exist.\n");
if (format == IFF_TIFF || format == IFF_TIFF_G4 ||
format == IFF_TIFF_G3 || format == IFF_TIFF_PACKBITS) {
fprintf(stderr, " Tiff header information:\n");
fp = lept_fopen(filein, "rb");
tiffGetCount(fp, &npages);
lept_fclose(fp);
if (npages == 1)
fprintf(stderr, " One page in file\n");
else
fprintf(stderr, " %d pages in file\n", npages);
fprintTiffInfo(stderr, filein);
}
if (d == 1) {
pixCountPixels(pix, &count, NULL);
fprintf(stderr, " 1 bpp: pixel ratio ON/OFF = %6.3f\n",
(l_float32)count / (l_float32)(pixGetWidth(pix) * pixGetHeight(pix)));
}
pixDestroy(&pix);
/* Test pixReadHeader() */
if (pixReadHeader(filein, &format, &w, &h, &bps, &spp, &iscmap)) {
fprintf(stderr, "Failure to read header!\n");
return 1;
}
fprintf(stderr, "Reading just the header:\n");
fprintf(stderr, " Input image format type: %s\n",
ImageFileFormatExtensions[format]);
fprintf(stderr,
" w = %d, h = %d, d = %d, bps = %d, spp = %d, iscmap = %d\n",
w, h, d, bps, spp, iscmap);
return 0;
}
/*!
* Note: this method is generally inferior to pixHasColorRegions(); it
* is retained as a reference only
*
* \brief pixFindColorRegionsLight()
*
* \param[in] pixs 32 bpp rgb
* \param[in] pixm [optional] 1 bpp mask image
* \param[in] factor subsample factor; integer >= 1
* \param[in] darkthresh threshold to eliminate dark pixels (e.g., text)
* from consideration; typ. 70; -1 for default.
* \param[in] lightthresh threshold for minimum gray value at 95% rank
* near white; typ. 220; -1 for default
* \param[in] mindiff minimum difference from 95% rank value, used
* to count darker pixels; typ. 50; -1 for default
* \param[in] colordiff minimum difference in (max - min) component to
* qualify as a color pixel; typ. 40; -1 for default
* \param[out] pcolorfract fraction of 'color' pixels found
* \param[out] pcolormask1 [optional] mask over background color, if any
* \param[out] pcolormask2 [optional] filtered mask over background color
* \param[out] pixadb [optional] debug intermediate results
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) This function tries to determine if there is a significant
* color or darker region on a scanned page image where part
* of the image is very close to "white". It will also allow
* extraction of small regions of lightly colored pixels.
* If the background is darker (and reddish), use instead
* pixHasColorRegions2().
* (2) If %pixm exists, only pixels under fg are considered. Typically,
* the inverse of %pixm would have fg pixels over a photograph.
* (3) There are four thresholds.
* * %darkthresh: ignore pixels darker than this (typ. fg text).
* We make a 1 bpp mask of these pixels, and then dilate it to
* remove all vestiges of fg from their vicinity.
* * %lightthresh: let val95 be the pixel value for which 95%
* of the non-masked pixels have a lower value (darker) of
* their min component. Then if val95 is darker than
* %lightthresh, the image is not considered to have a
* light bg, and this returns 0.0 for %colorfract.
* * %mindiff: we are interested in the fraction of pixels that
* have two conditions. The first is that their min component
* is at least %mindiff darker than val95.
* * %colordiff: the second condition is that the max-min diff
* of the pixel components exceeds %colordiff.
* (4) This returns in %pcolorfract the fraction of pixels that have
* both a min component that is at least %mindiff below that at the
* 95% rank value (where 100% rank is the lightest value), and
* a max-min diff that is at least %colordiff. Without the
* %colordiff constraint, gray pixels of intermediate value
* could get flagged by this function.
* (5) No masks are returned unless light color pixels are found.
* If colorfract > 0.0 and %pcolormask1 is defined, this returns
* a 1 bpp mask with fg pixels over the color background.
* This mask may have some holes in it.
* (6) If colorfract > 0.0 and %pcolormask2 is defined, this returns
* a filtered version of colormask1. The two changes are
* (a) small holes have been filled
* (b) components near the border have been removed.
* The latter insures that dark pixels near the edge of the
* image are not included.
* (7) To generate a boxa of rectangular regions from the overlap
* of components in the filtered mask:
* boxa1 = pixConnCompBB(colormask2, 8);
* boxa2 = boxaCombineOverlaps(boxa1);
* This is done here in debug mode.
* </pre>
*/
static l_int32
pixFindColorRegionsLight(PIX *pixs,
PIX *pixm,
l_int32 factor,
l_int32 darkthresh,
l_int32 lightthresh,
l_int32 mindiff,
l_int32 colordiff,
l_float32 *pcolorfract,
PIX **pcolormask1,
PIX **pcolormask2,
PIXA *pixadb)
{
l_int32 lightbg, w, h, count;
l_float32 ratio, val95, rank;
BOXA *boxa1, *boxa2;
NUMA *nah;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pixm1, *pixm2, *pixm3;
PROCNAME("pixFindColorRegionsLight");
if (pcolormask1) *pcolormask1 = NULL;
if (pcolormask2) *pcolormask2 = NULL;
if (!pcolorfract)
return ERROR_INT("&colorfract not defined", procName, 1);
*pcolorfract = 0.0;
if (!pixs || pixGetDepth(pixs) != 32)
return ERROR_INT("pixs not defined or not 32 bpp", procName, 1);
if (factor < 1) factor = 1;
if (darkthresh < 0) darkthresh = 70; /* defaults */
if (lightthresh < 0) lightthresh = 220;
if (mindiff < 0) mindiff = 50;
if (colordiff < 0) colordiff = 40;
/* Check if pixm covers most of the image. If so, just return. */
pixGetDimensions(pixs, &w, &h, NULL);
if (pixm) {
pixCountPixels(pixm, &count, NULL);
ratio = (l_float32)count / ((l_float32)(w) * h);
if (ratio > 0.7) {
if (pixadb) L_INFO("pixm has big fg: %f5.2\n", procName, ratio);
return 0;
}
}
/* Make a mask pixm1 over the dark pixels in the image:
* convert to gray using the average of the components;
* threshold using %darkthresh; do a small dilation;
* combine with pixm. */
pix1 = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33);
if (pixadb) pixaAddPix(pixadb, pixs, L_COPY);
if (pixadb) pixaAddPix(pixadb, pix1, L_COPY);
pixm1 = pixThresholdToBinary(pix1, darkthresh);
pixDilateBrick(pixm1, pixm1, 7, 7);
if (pixadb) pixaAddPix(pixadb, pixm1, L_COPY);
if (pixm) {
pixOr(pixm1, pixm1, pixm);
if (pixadb) pixaAddPix(pixadb, pixm1, L_COPY);
}
pixDestroy(&pix1);
/* Convert to gray using the minimum component value and
* find the gray value at rank 0.95, that represents the light
* pixels in the image. If it is too dark, quit. */
pix1 = pixConvertRGBToGrayMinMax(pixs, L_SELECT_MIN);
pix2 = pixInvert(NULL, pixm1); /* pixels that are not dark */
pixGetRankValueMasked(pix1, pix2, 0, 0, factor, 0.95, &val95, &nah);
pixDestroy(&pix2);
if (pixadb) {
L_INFO("val at 0.95 rank = %5.1f\n", procName, val95);
gplotSimple1(nah, GPLOT_PNG, "/tmp/lept/histo1", "gray histo");
pix3 = pixRead("/tmp/lept/histo1.png");
pix4 = pixExpandReplicate(pix3, 2);
pixaAddPix(pixadb, pix4, L_INSERT);
pixDestroy(&pix3);
}
lightbg = (l_int32)val95 >= lightthresh;
numaDestroy(&nah);
if (!lightbg) {
pixDestroy(&pix1);
pixDestroy(&pixm1);
return 0;
}
/* Make mask pixm2 over pixels that are darker than val95 - mindiff. */
pixm2 = pixThresholdToBinary(pix1, val95 - mindiff);
if (pixadb) pixaAddPix(pixadb, pixm2, L_COPY);
pixDestroy(&pix1);
/* Make a mask pixm3 over pixels that have some color saturation,
* with a (max - min) component difference >= %colordiff,
* and combine using AND with pixm2. */
pix2 = pixConvertRGBToGrayMinMax(pixs, L_CHOOSE_MAXDIFF);
pixm3 = pixThresholdToBinary(pix2, colordiff);
pixDestroy(&pix2);
pixInvert(pixm3, pixm3); /* need pixels above threshold */
if (pixadb) pixaAddPix(pixadb, pixm3, L_COPY);
pixAnd(pixm2, pixm2, pixm3);
if (pixadb) pixaAddPix(pixadb, pixm2, L_COPY);
pixDestroy(&pixm3);
/* Subtract the dark pixels represented by pixm1.
* pixm2 now holds all the color pixels of interest */
pixSubtract(pixm2, pixm2, pixm1);
pixDestroy(&pixm1);
if (pixadb) pixaAddPix(pixadb, pixm2, L_COPY);
/* But we're not quite finished. Remove pixels from any component
* that is touching the image border. False color pixels can
* sometimes be found there if the image is much darker near
* the border, due to oxidation or reduced illumination. */
pixm3 = pixRemoveBorderConnComps(pixm2, 8);
pixDestroy(&pixm2);
if (pixadb) pixaAddPix(pixadb, pixm3, L_COPY);
/* Get the fraction of light color pixels */
pixCountPixels(pixm3, &count, NULL);
*pcolorfract = (l_float32)count / (w * h);
if (pixadb) {
if (count == 0)
L_INFO("no light color pixels found\n", procName);
else
L_INFO("fraction of light color pixels = %5.3f\n", procName,
*pcolorfract);
}
/* Debug: extract the color pixels from pixs */
if (pixadb && count > 0) {
/* Use pixm3 to extract the color pixels */
pix3 = pixCreateTemplate(pixs);
pixSetAll(pix3);
pixCombineMasked(pix3, pixs, pixm3);
pixaAddPix(pixadb, pix3, L_INSERT);
/* Use additional filtering to extract the color pixels */
pix3 = pixCloseSafeBrick(NULL, pixm3, 15, 15);
pixaAddPix(pixadb, pix3, L_INSERT);
pix5 = pixCreateTemplate(pixs);
pixSetAll(pix5);
pixCombineMasked(pix5, pixs, pix3);
pixaAddPix(pixadb, pix5, L_INSERT);
/* Get the combined bounding boxes of the mask components
* in pix3, and extract those pixels from pixs. */
boxa1 = pixConnCompBB(pix3, 8);
boxa2 = boxaCombineOverlaps(boxa1, NULL);
pix4 = pixCreateTemplate(pix3);
pixMaskBoxa(pix4, pix4, boxa2, L_SET_PIXELS);
pixaAddPix(pixadb, pix4, L_INSERT);
pix5 = pixCreateTemplate(pixs);
pixSetAll(pix5);
pixCombineMasked(pix5, pixs, pix4);
pixaAddPix(pixadb, pix5, L_INSERT);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixaAddPix(pixadb, pixs, L_COPY);
}
/* Optional colormask returns */
if (pcolormask2 && count > 0)
*pcolormask2 = pixCloseSafeBrick(NULL, pixm3, 15, 15);
if (pcolormask1 && count > 0)
*pcolormask1 = pixm3;
else
pixDestroy(&pixm3);
return 0;
}
/*!
* pixMirrorDetect()
*
* Input: pixs (1 bpp, deskewed, English text)
* &conf (<return> confidence that text is not LR mirror reversed)
* mincount (min number of left + right; use 0 for default)
* debug (1 for debug output; 0 otherwise)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) For this test, it is necessary that the text is horizontally
* oriented, with ascenders going up.
* (2) conf is the normalized difference between the number of
* right and left facing characters with ascenders.
* Left-facing are {d}; right-facing are {b, h, k}.
* At least that was the expectation. In practice, we can
* really just say that it is the normalized difference in
* hits using two specific hit-miss filters, textsel1 and textsel2,
* after the image has been suitably pre-filtered so that
* these filters are effective. See (4) for what's really happening.
* (3) A large positive conf value indicates normal text, whereas
* a large negative conf value means the page is mirror reversed.
* (4) The implementation is a bit tricky. The general idea is
* to fill the x-height part of characters, but not the space
* between them, before doing the HMT. This is done by
* finding pixels added using two different operations -- a
* horizontal close and a vertical dilation -- and adding
* the intersection of these sets to the original. It turns
* out that the original intuition about the signal was largely
* in error: much of the signal for right-facing characters
* comes from the lower part of common x-height characters, like
* the e and c, that remain open after these operations.
* So it's important that the operations to close the x-height
* parts of the characters are purposely weakened sufficiently
* to allow these characters to remain open. The wonders
* of morphology!
*/
l_int32
pixMirrorDetect(PIX *pixs,
l_float32 *pconf,
l_int32 mincount,
l_int32 debug)
{
l_int32 count1, count2, nmax;
l_float32 nleft, nright;
PIX *pixt0, *pixt1, *pixt2, *pixt3;
SEL *sel1, *sel2;
PROCNAME("pixMirrorDetect");
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_MIRROR_FLIP_COUNT;
sel1 = selCreateFromString(textsel1, 5, 6, NULL);
sel2 = selCreateFromString(textsel2, 5, 6, NULL);
/* Fill x-height characters but not space between them, sort of. */
pixt3 = pixMorphCompSequence(pixs, "d1.30", 0);
pixXor(pixt3, pixt3, pixs);
pixt0 = pixMorphCompSequence(pixs, "c15.1", 0);
pixXor(pixt0, pixt0, pixs);
pixAnd(pixt0, pixt0, pixt3);
pixOr(pixt0, pixt0, pixs);
pixDestroy(&pixt3);
/* pixDisplayWrite(pixt0, 1); */
/* Filter the right-facing characters. */
pixt1 = pixHMT(NULL, pixt0, sel1);
pixt3 = pixReduceRankBinaryCascade(pixt1, 1, 1, 0, 0);
pixCountPixels(pixt3, &count1, NULL);
pixDebugFlipDetect("junkpixright", pixs, pixt1, debug);
pixDestroy(&pixt1);
pixDestroy(&pixt3);
/* Filter the left-facing characters. */
pixt2 = pixHMT(NULL, pixt0, sel2);
pixt3 = pixReduceRankBinaryCascade(pixt2, 1, 1, 0, 0);
pixCountPixels(pixt3, &count2, NULL);
pixDebugFlipDetect("junkpixleft", pixs, pixt2, debug);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
nright = (l_float32)count1;
nleft = (l_float32)count2;
nmax = L_MAX(count1, count2);
pixDestroy(&pixt0);
selDestroy(&sel1);
selDestroy(&sel2);
if (nmax > mincount)
*pconf = 2. * ((nright - nleft) / sqrt(nright + nleft));
if (debug) {
fprintf(stderr, "nright = %f, nleft = %f\n", nright, nleft);
if (*pconf > DEFAULT_MIN_MIRROR_FLIP_CONF)
fprintf(stderr, "Text is not mirror reversed\n");
if (*pconf < -DEFAULT_MIN_MIRROR_FLIP_CONF)
fprintf(stderr, "Text is mirror reversed\n");
}
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, nsels, same, xorcount;
char *selname;
PIX *pixs, *pixs1, *pixt1, *pixt2, *pixt3;
SEL *sel;
SELA *sela;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
if ((pixs = pixRead("feyn-fract.tif")) == NULL) {
rp->success = FALSE;
regTestCleanup(rp);
return 1;
}
sela = selaAddDwaLinear(NULL);
nsels = selaGetCount(sela);
for (i = 0; i < nsels; i++)
{
sel = selaGetSel(sela, i);
selname = selGetName(sel);
/* --------- dilation ----------*/
pixt1 = pixDilate(NULL, pixs, sel);
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_DILATE, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "dilations are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "dilations differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* --------- erosion with asymmetric b.c ----------*/
resetMorphBoundaryCondition(ASYMMETRIC_MORPH_BC);
fprintf(stderr, "MORPH_BC = %d ... ", MORPH_BC);
pixt1 = pixErode(NULL, pixs, sel);
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_ERODE, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "erosions are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "erosions differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* --------- erosion with symmetric b.c ----------*/
resetMorphBoundaryCondition(SYMMETRIC_MORPH_BC);
fprintf(stderr, "MORPH_BC = %d ... ", MORPH_BC);
pixt1 = pixErode(NULL, pixs, sel);
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_ERODE, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "erosions are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "erosions differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* --------- opening with asymmetric b.c ----------*/
resetMorphBoundaryCondition(ASYMMETRIC_MORPH_BC);
fprintf(stderr, "MORPH_BC = %d ... ", MORPH_BC);
pixt1 = pixOpen(NULL, pixs, sel);
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_OPEN, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "openings are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "openings differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* --------- opening with symmetric b.c ----------*/
resetMorphBoundaryCondition(SYMMETRIC_MORPH_BC);
fprintf(stderr, "MORPH_BC = %d ... ", MORPH_BC);
pixt1 = pixOpen(NULL, pixs, sel);
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_OPEN, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "openings are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "openings differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* --------- safe closing with asymmetric b.c ----------*/
resetMorphBoundaryCondition(ASYMMETRIC_MORPH_BC);
fprintf(stderr, "MORPH_BC = %d ... ", MORPH_BC);
pixt1 = pixCloseSafe(NULL, pixs, sel); /* must use safe version */
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_CLOSE, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "closings are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "closings differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* --------- safe closing with symmetric b.c ----------*/
resetMorphBoundaryCondition(SYMMETRIC_MORPH_BC);
fprintf(stderr, "MORPH_BC = %d ... ", MORPH_BC);
pixt1 = pixClose(NULL, pixs, sel); /* safe version not required */
pixt2 = pixMorphDwa_3(NULL, pixs, L_MORPH_CLOSE, selname);
pixEqual(pixt1, pixt2, &same);
if (same == 1) {
fprintf(stderr, "closings are identical for sel %d (%s)\n",
i, selname);
}
else {
rp->success = FALSE;
fprintf(rp->fp, "closings differ for sel %d (%s)\n", i, selname);
pixt3 = pixXor(NULL, pixt1, pixt2);
pixCountPixels(pixt3, &xorcount, NULL);
fprintf(rp->fp, "Number of pixels in XOR: %d\n", xorcount);
pixDestroy(&pixt3);
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
selaDestroy(&sela);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb;
PIXA *pixa;
PIXCMAP *cmap;
static char mainName[] = "colorspacetest";
if (argc != 2)
return ERROR_INT(" Syntax: colorspacetest filein", mainName, 1);
if ((pixs = pixRead(argv[1])) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
/* Generate colors by sampling hue with max sat and value.
* This was used to make the color strip 19-colors.png. */
pixa = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixa, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixa, 32, 1100, 1.0, 0, 0, 0);
pixDisplayWrite(pixt2, 1);
pixDestroy(&pixt2);
pixaDestroy(&pixa);
/* Colorspace conversion in rgb */
pixDisplayWrite(pixs, 1);
pixt = pixConvertRGBToHSV(NULL, pixs);
pixDisplayWrite(pixt, 1);
pixConvertHSVToRGB(pixt, pixt);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
pixDisplayWrite(pixt, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixcmapConvertHSVToRGB(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
pixDisplayWrite(pixr, 1);
pixDisplayWrite(pixg, 1);
pixDisplayWrite(pixb, 1);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Color content measurement */
pixa = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/junkplot1", GPLOT_X11,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/junkplot2", GPLOT_X11,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, 250, 4, 0, 10, 2);
pixWrite("/tmp/junkcolormag", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", 1);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
pixDisplayMultiple("/tmp/display/file*");
pixDestroy(&pixs);
return 0;
}
/*!
* \brief pixFindStrokeWidth()
*
* \param[in] pixs 1 bpp
* \param[in] thresh fractional count threshold relative to distance 1
* \param[in] tab8 [optional] table for counting fg pixels; can be NULL
* \param[out] *pwidth estimated width of the strokes
* \param[out] *pnahisto [optional] histo of pixel distances from bg
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) This uses two methods to estimate the stroke width:
* (a) half the fg boundary length
* (b) a value derived from the histogram of the fg distance transform
* (2) Distance is measured in 8-connected
* (3) %thresh is the minimum fraction N(dist=d)/N(dist=1) of pixels
* required to determine if the pixels at distance d are above
* the noise. It is typically about 0.15.
* </pre>
*/
l_int32
pixFindStrokeWidth(PIX *pixs,
l_float32 thresh,
l_int32 *tab8,
l_float32 *pwidth,
NUMA **pnahisto)
{
l_int32 i, n, count, length, first, last;
l_int32 *tab;
l_float32 width1, width2, ratio, extra;
l_float32 *fa;
NUMA *na1, *na2;
PIX *pix1;
PROCNAME("pixFindStrokeWidth");
if (!pwidth)
return ERROR_INT("&width not defined", procName, 1);
*pwidth = 0;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
tab = (tab8) ? tab8 : makePixelSumTab8();
/* ------- Method 1: via boundary length ------- */
/* The computed stroke length is a bit larger than that actual
* length, because of the addition of the 'caps' at the
* stroke ends. Therefore the computed width is a bit
* smaller than the average width. */
pixFindStrokeLength(pixs, tab8, &length);
pixCountPixels(pixs, &count, tab8);
width1 = (l_float32)count / (l_float32)length;
/* ------- Method 2: via distance transform ------- */
/* First get the histogram of distances */
pix1 = pixDistanceFunction(pixs, 8, 8, L_BOUNDARY_BG);
na1 = pixGetGrayHistogram(pix1, 1);
pixDestroy(&pix1);
numaGetNonzeroRange(na1, 0.1, &first, &last);
na2 = numaClipToInterval(na1, 0, last);
numaWriteStream(stderr, na2);
/* Find the bucket with the largest distance whose contents
* exceed the threshold. */
fa = numaGetFArray(na2, L_NOCOPY);
n = numaGetCount(na2);
for (i = n - 1; i > 0; i--) {
ratio = fa[i] / fa[1];
if (ratio > thresh) break;
}
/* Let the last skipped bucket contribute to the stop bucket.
* This is the 'extra' term below. The result may be a slight
* over-correction, so the computed width may be a bit larger
* than the average width. */
extra = (i < n - 1) ? fa[i + 1] / fa[1] : 0;
width2 = 2.0 * (i - 1.0 + ratio + extra);
fprintf(stderr, "width1 = %5.2f, width2 = %5.2f\n", width1, width2);
/* Average the two results */
*pwidth = (width1 + width2) / 2.0;
if (!tab8) LEPT_FREE(tab);
numaDestroy(&na1);
if (pnahisto)
*pnahisto = na2;
else
numaDestroy(&na2);
return 0;
}
l_int32 main(int argc,
char **argv)
{
l_int32 delx, dely, etransx, etransy, w, h, area1, area2;
l_int32 *stab, *ctab;
l_float32 cx1, cy1, cx2, cy2, score, fract;
PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Test of pixBestCorrelation() --------------- */
pix0 = pixRead("harmoniam100-11.png");
pix1 = pixConvertTo1(pix0, 160);
pixGetDimensions(pix1, &w, &h, NULL);
/* Now make a smaller image, translated by (-32, -12)
* Except for the resizing, this is equivalent to
* pix2 = pixTranslate(NULL, pix1, -32, -12, L_BRING_IN_WHITE); */
pix2 = pixCreate(w - 10, h, 1);
pixRasterop(pix2, 0, 0, w, h, PIX_SRC, pix1, 32, 12);
/* Get the number of FG pixels and the centroid locations */
stab = makePixelSumTab8();
ctab = makePixelCentroidTab8();
pixCountPixels(pix1, &area1, stab);
pixCountPixels(pix2, &area2, stab);
pixCentroid(pix1, ctab, stab, &cx1, &cy1);
pixCentroid(pix2, ctab, stab, &cx2, &cy2);
etransx = lept_roundftoi(cx1 - cx2);
etransy = lept_roundftoi(cy1 - cy2);
fprintf(stderr, "delta cx = %d, delta cy = %d\n",
etransx, etransy);
/* Get the best correlation, searching around the translation
* where the centroids coincide */
pixBestCorrelation(pix1, pix2, area1, area2, etransx, etransy,
4, stab, &delx, &dely, &score, 5);
fprintf(stderr, "delx = %d, dely = %d, score = %7.4f\n",
delx, dely, score);
regTestCompareValues(rp, 32, delx, 0); /* 0 */
regTestCompareValues(rp, 12, dely, 0); /* 1 */
lept_mv("/tmp/lept/correl_5.png", "regout", NULL, NULL);
regTestCheckFile(rp, "/tmp/regout/correl_5.png"); /* 2 */
lept_free(stab);
lept_free(ctab);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------ Test of pixCompareWithTranslation() ------------ */
/* Now use the pyramid to get the result. Do a translation
* to remove pixels at the bottom from pix2, so that the
* centroids are initially far apart. */
pix1 = pixRead("harmoniam-11.tif");
pix2 = pixTranslate(NULL, pix1, -45, 25, L_BRING_IN_WHITE);
l_pdfSetDateAndVersion(0);
pixCompareWithTranslation(pix1, pix2, 160, &delx, &dely, &score, 1);
pixDestroy(&pix1);
pixDestroy(&pix2);
fprintf(stderr, "delx = %d, dely = %d\n", delx, dely);
regTestCompareValues(rp, 45, delx, 0); /* 3 */
regTestCompareValues(rp, -25, dely, 0); /* 4 */
lept_mv("/tmp/lept/correl.pdf", "regout", NULL, NULL);
lept_mv("/tmp/lept/compare.pdf", "regout", NULL, NULL);
regTestCheckFile(rp, "/tmp/regout/compare.pdf"); /* 5 */
regTestCheckFile(rp, "/tmp/regout/correl.pdf"); /* 6 */
/* ------------ Test of pixGetPerceptualDiff() --------------- */
pix0 = pixRead("greencover.jpg");
pix1 = pixRead("redcover.jpg"); /* pre-scaled to the same size */
/* Apply directly to the color images */
pixGetPerceptualDiff(pix0, pix1, 1, 3, 20, &fract, &pix2, &pix3);
fprintf(stderr, "Fraction of color pixels = %f\n", fract);
regTestCompareValues(rp, 0.061252, fract, 0.01); /* 7 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 8 */
regTestWritePixAndCheck(rp, pix3, IFF_TIFF_G4); /* 9 */
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Apply to grayscale images */
pix2 = pixConvertTo8(pix0, 0);
pix3 = pixConvertTo8(pix1, 0);
pixGetPerceptualDiff(pix2, pix3, 1, 3, 20, &fract, &pix4, &pix5);
fprintf(stderr, "Fraction of grayscale pixels = %f\n", fract);
regTestCompareValues(rp, 0.046928, fract, 0.0002); /* 10 */
regTestWritePixAndCheck(rp, pix4, IFF_JFIF_JPEG); /* 11 */
regTestWritePixAndCheck(rp, pix5, IFF_TIFF_G4); /* 12 */
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char *filein;
l_int32 count;
CCBORDA *ccba, *ccba2;
PIX *pixs, *pixd, *pixd2, *pixd3;
PIX *pixt, *pixc, *pixc2;
static char mainName[] = "ccbordtest";
if (argc != 2)
exit(ERROR_INT(" Syntax: ccbordtest filein", mainName, 1));
filein = argv[1];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
fprintf(stderr, "Get border representation...");
startTimer();
ccba = pixGetAllCCBorders(pixs);
fprintf(stderr, "%6.3f sec\n", stopTimer());
#if 0
/* get global locs directly and display borders */
fprintf(stderr, "Convert from local to global locs...");
startTimer();
ccbaGenerateGlobalLocs(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
fprintf(stderr, "Display border representation...");
startTimer();
pixd = ccbaDisplayBorder(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
pixWrite("/tmp/junkborder1.png", pixd, IFF_PNG);
#else
/* get step chain code, then global coords, and display borders */
fprintf(stderr, "Get step chain code...");
startTimer();
ccbaGenerateStepChains(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
fprintf(stderr, "Convert from step chain to global locs...");
startTimer();
ccbaStepChainsToPixCoords(ccba, CCB_GLOBAL_COORDS);
fprintf(stderr, "%6.3f sec\n", stopTimer());
fprintf(stderr, "Display border representation...");
startTimer();
pixd = ccbaDisplayBorder(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
pixWrite("/tmp/junkborder1.png", pixd, IFF_PNG);
#endif
/* check if border pixels are in original set */
fprintf(stderr, "Check if border pixels are in original set ...\n");
pixt = pixSubtract(NULL, pixd, pixs);
pixCountPixels(pixt, &count, NULL);
if (count == 0)
fprintf(stderr, " all border pixels are in original set\n");
else
fprintf(stderr, " %d border pixels are not in original set\n", count);
pixDestroy(&pixt);
/* display image */
fprintf(stderr, "Reconstruct image ...");
startTimer();
/* pixc = ccbaDisplayImage1(ccba); */
pixc = ccbaDisplayImage2(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
pixWrite("/tmp/junkrecon1.png", pixc, IFF_PNG);
/* check with original to see if correct */
fprintf(stderr, "Check with original to see if correct ...\n");
pixXor(pixc, pixc, pixs);
pixCountPixels(pixc, &count, NULL);
if (count == 0)
fprintf(stderr, " perfect direct recon\n");
else {
l_int32 w, h, i, j;
l_uint32 val;
fprintf(stderr, " %d pixels in error in recon\n", count);
#if 1
w = pixGetWidth(pixc);
h = pixGetHeight(pixc);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
pixGetPixel(pixc, j, i, &val);
if (val == 1)
fprintf(stderr, "bad pixel at (%d, %d)\n", j, i);
}
}
pixWrite("/tmp/junkbadpixels.png", pixc, IFF_PNG);
#endif
}
/*----------------------------------------------------------*
* write to file (compressed) and read back *
*----------------------------------------------------------*/
fprintf(stderr, "Write serialized step data...");
startTimer();
ccbaWrite("/tmp/junkstepout", ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
fprintf(stderr, "Read serialized step data...");
startTimer();
ccba2 = ccbaRead("/tmp/junkstepout");
fprintf(stderr, "%6.3f sec\n", stopTimer());
/* display the border pixels again */
fprintf(stderr, "Convert from step chain to global locs...");
startTimer();
ccbaStepChainsToPixCoords(ccba2, CCB_GLOBAL_COORDS);
fprintf(stderr, "%6.3f sec\n", stopTimer());
fprintf(stderr, "Display border representation...");
startTimer();
pixd2 = ccbaDisplayBorder(ccba2);
fprintf(stderr, "%6.3f sec\n", stopTimer());
pixWrite("/tmp/junkborder2.png", pixd2, IFF_PNG);
/* check if border pixels are same as first time */
pixXor(pixd2, pixd2, pixd);
pixCountPixels(pixd2, &count, NULL);
if (count == 0)
fprintf(stderr, " perfect w/r border recon\n");
else {
l_int32 w, h, i, j, val;
fprintf(stderr, " %d pixels in error in w/r recon\n", count);
}
pixDestroy(&pixd2);
/* display image again */
fprintf(stderr, "Convert from step chain to local coords...");
startTimer();
ccbaStepChainsToPixCoords(ccba2, CCB_LOCAL_COORDS);
fprintf(stderr, "%6.3f sec\n", stopTimer());
fprintf(stderr, "Reconstruct image from file ...");
startTimer();
/* pixc2 = ccbaDisplayImage1(ccba2); */
pixc2 = ccbaDisplayImage2(ccba2);
fprintf(stderr, "%6.3f sec\n", stopTimer());
pixWrite("/tmp/junkrecon2.png", pixc2, IFF_PNG);
/* check with original to see if correct */
fprintf(stderr, "Check with original to see if correct ...\n");
pixXor(pixc2, pixc2, pixs);
pixCountPixels(pixc2, &count, NULL);
if (count == 0)
fprintf(stderr, " perfect image recon\n");
else {
l_int32 w, h, i, j;
l_uint32 val;
fprintf(stderr, " %d pixels in error in image recon\n", count);
#if 1
w = pixGetWidth(pixc2);
h = pixGetHeight(pixc2);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
pixGetPixel(pixc2, j, i, &val);
if (val == 1)
fprintf(stderr, "bad pixel at (%d, %d)\n", j, i);
}
}
pixWrite("/tmp/junkbadpixels2.png", pixc2, IFF_PNG);
#endif
}
/*----------------------------------------------------------*
* make, display and check single path border for svg *
*----------------------------------------------------------*/
/* make local single path border for svg */
fprintf(stderr, "Make local single path borders for svg ...");
startTimer();
ccbaGenerateSinglePath(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
/* generate global single path border */
fprintf(stderr, "Generate global single path borders ...");
startTimer();
ccbaGenerateSPGlobalLocs(ccba, CCB_SAVE_TURNING_PTS);
fprintf(stderr, "%6.3f sec\n", stopTimer());
/* display border pixels from single path */
fprintf(stderr, "Display border from single path...");
startTimer();
pixd3 = ccbaDisplaySPBorder(ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
pixWrite("/tmp/junkborder3.png", pixd3, IFF_PNG);
/* check if border pixels are in original set */
fprintf(stderr, "Check if border pixels are in original set ...\n");
pixt = pixSubtract(NULL, pixd3, pixs);
pixCountPixels(pixt, &count, NULL);
if (count == 0)
fprintf(stderr, " all border pixels are in original set\n");
else
fprintf(stderr, " %d border pixels are not in original set\n", count);
pixDestroy(&pixt);
pixDestroy(&pixd3);
/* output in svg file format */
fprintf(stderr, "Write output in svg file format ...\n");
startTimer();
ccbaWriteSVG("/tmp/junksvg", ccba);
fprintf(stderr, "%6.3f sec\n", stopTimer());
ccbaDestroy(&ccba2);
ccbaDestroy(&ccba);
pixDestroy(&pixs);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixDestroy(&pixc2);
return 0;
}
main(int argc,
char **argv)
{
l_int32 w, h, d, wpl, count, i, format, xres, yres;
FILE *fp;
PIX *pix, *pixt1, *pixt2;
PIXCMAP *cmap;
char *filein;
char *fileout = NULL;
static char mainName[] = "iotest";
if (argc != 2 && argc != 3)
exit(ERROR_INT(" Syntax: iotest filein [fileout]", mainName, 1));
filein = argv[1];
if (argc == 3)
fileout = argv[2];
#if 1
if ((pix = pixRead(filein)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
#else
if ((pix = pixReadJpeg(filein, 0, 4, NULL)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
#endif
pixGetDimensions(pix, &w, &h, &d);
wpl = pixGetWpl(pix);
fprintf(stderr, "w = %d, h = %d, d = %d, wpl = %d\n", w, h, d, wpl);
xres = pixGetXRes(pix);
yres = pixGetXRes(pix);
if (xres != 0 && yres != 0)
fprintf(stderr, "xres = %d, yres = %d\n", xres, yres);
if (pixGetColormap(pix)) {
/* Write and read back the colormap */
pixcmapWriteStream(stderr, pixGetColormap(pix));
fp = lept_fopen("/tmp/junkcmap1", "wb");
pixcmapWriteStream(fp, pixGetColormap(pix));
lept_fclose(fp);
fp = lept_fopen("/tmp/junkcmap1", "rb");
cmap = pixcmapReadStream(fp);
lept_fclose(fp);
fp = lept_fopen("/tmp/junkcmap2", "wb");
pixcmapWriteStream(fp, cmap);
lept_fclose(fp);
pixcmapDestroy(&cmap);
/* Remove and regenerate colormap */
pixt1 = pixRemoveColormap(pix, REMOVE_CMAP_BASED_ON_SRC);
if (pixGetDepth(pixt1) == 8) {
fprintf(stderr, "Colormap: represents grayscale image\n");
pixt2 = pixConvertGrayToColormap(pixt1);
}
else { /* 32 bpp */
fprintf(stderr, "Colormap: represents RGB image\n");
pixt2 = pixConvertRGBToColormap(pixt1, 1);
}
pixWrite("/tmp/junkpixt2.png", pixt2, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
else {
fprintf(stderr, "no colormap\n");
}
format = pixGetInputFormat(pix);
fprintf(stderr, "Input format extension: %s\n",
ImageFileFormatExtensions[format]);
if (format == IFF_JFIF_JPEG)
fprintf(stderr, "Jpeg comment: %s\n", pixGetText(pix));
if (d == 1) {
pixCountPixels(pix, &count, NULL);
fprintf(stderr, "pixel ratio ON/OFF = %6.3f\n",
(l_float32)count / (l_float32)(pixGetWidth(pix) * pixGetHeight(pix)));
}
if (argc == 3) {
#if 1
d = pixGetDepth(pix);
if (d == 16 || d < 8 || pixGetColormap(pix))
pixWrite(fileout, pix, IFF_PNG);
else
pixWriteJpeg(fileout, pix, 75, 0);
#elif 0
pixWrite(fileout, pix, IFF_BMP);
#elif 0
pixWrite(fileout, pix, IFF_PNG);
#elif 0
pixWrite(fileout, pix, IFF_TIFF);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_TIFF_PACKBITS);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_TIFF_G3);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_TIFF_G4);
fprintTiffInfo(stderr, fileout);
#elif 0
pixWrite(fileout, pix, IFF_JFIF_JPEG);
#elif 0
pixWriteJpeg(fileout, pix, 75, 0);
#elif 0
pixWrite(fileout, pix, IFF_PNM);
#elif 0
pixWrite(fileout, pix, IFF_PS);
#endif
}
pixDestroy(&pix);
#if 0 /* test tiff header reader */
{ l_int32 w, h, bps, spp, res, cmap;
if (readHeaderTiff(filein, 0, &w, &h, &bps, &spp, &res, &cmap) == 0)
fprintf(stderr,
"w = %d, h = %d, bps = %d, spp = %d, res = %d, cmap = %d\n",
w, h, bps, spp, res, cmap);
}
#endif
return 0;
}
