int main(int argc,
char **argv)
{
char filename[BUF_SIZE];
char *dirin, *rootname, *fname;
l_int32 i, j, w, h, firstpage, npages, nfiles, ncomp;
l_int32 index, ival, rval, gval, bval;
BOX *box;
BOXA *boxa;
BOXAA *baa;
JBDATA *data;
JBCLASSER *classer;
NUMA *nai;
NUMAA *naa;
SARRAY *safiles;
PIX *pixs, *pixt1, *pixt2, *pixd;
PIXCMAP *cmap;
static char mainName[] = "wordsinorder";
if (argc != 3 && argc != 5)
return ERROR_INT(
" Syntax: wordsinorder dirin rootname [firstpage, npages]",
mainName, 1);
dirin = argv[1];
rootname = argv[2];
if (argc == 3) {
firstpage = 0;
npages = 0;
}
else {
firstpage = atoi(argv[3]);
npages = atoi(argv[4]);
}
/* Compute the word bounding boxes at 2x reduction, along with
* the textlines that they are in. */
safiles = getSortedPathnamesInDirectory(dirin, NULL, firstpage, npages);
nfiles = sarrayGetCount(safiles);
baa = boxaaCreate(nfiles);
naa = numaaCreate(nfiles);
for (i = 0; i < nfiles; i++) {
fname = sarrayGetString(safiles, i, 0);
if ((pixs = pixRead(fname)) == NULL) {
L_WARNING("image file %d not read\n", mainName, i);
continue;
}
pixGetWordBoxesInTextlines(pixs, 2, MIN_WORD_WIDTH, MIN_WORD_HEIGHT,
MAX_WORD_WIDTH, MAX_WORD_HEIGHT,
&boxa, &nai);
boxaaAddBoxa(baa, boxa, L_INSERT);
numaaAddNuma(naa, nai, L_INSERT);
#if RENDER_PAGES
/* Show the results on a 2x reduced image, where each
* word is outlined and the color of the box depends on the
* computed textline. */
pixt1 = pixReduceRankBinary2(pixs, 2, NULL);
pixGetDimensions(pixt1, &w, &h, NULL);
pixd = pixCreate(w, h, 8);
cmap = pixcmapCreateRandom(8, 1, 1); /* first color is black */
pixSetColormap(pixd, cmap);
pixt2 = pixUnpackBinary(pixt1, 8, 1);
pixRasterop(pixd, 0, 0, w, h, PIX_SRC | PIX_DST, pixt2, 0, 0);
ncomp = boxaGetCount(boxa);
for (j = 0; j < ncomp; j++) {
box = boxaGetBox(boxa, j, L_CLONE);
numaGetIValue(nai, j, &ival);
index = 1 + (ival % 254); /* omit black and white */
pixcmapGetColor(cmap, index, &rval, &gval, &bval);
pixRenderBoxArb(pixd, box, 2, rval, gval, bval);
boxDestroy(&box);
}
snprintf(filename, BUF_SIZE, "%s.%05d", rootname, i);
fprintf(stderr, "filename: %s\n", filename);
pixWrite(filename, pixd, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDestroy(&pixd);
#endif /* RENDER_PAGES */
}
boxaaDestroy(&baa);
numaaDestroy(&naa);
sarrayDestroy(&safiles);
return 0;
}
/*!
* pixSearchBinaryMaze()
*
* Input: pixs (1 bpp, maze)
* xi, yi (beginning point; use same initial point
* that was used to generate the maze)
* xf, yf (end point, or close to it)
* &ppixd (<optional return> maze with path illustrated, or
* if no path possible, the part of the maze
* that was searched)
* Return: pta (shortest path), or null if either no path
* exists or on error
*
* Notes:
* (1) Because of the overhead in calling pixGetPixel() and
* pixSetPixel(), we have used raster line pointers and the
* GET_DATA* and SET_DATA* macros for many of the pix accesses.
* (2) Commentary:
* The goal is to find the shortest path between beginning and
* end points, without going through walls, and there are many
* ways to solve this problem.
* We use a queue to implement a breadth-first search. Two auxiliary
* "image" data structures can be used: one to mark the visited
* pixels and one to give the direction to the parent for each
* visited pixels. The first structure is used to avoid putting
* pixels on the queue more than once, and the second is used
* for retracing back to the origin, like the breadcrumbs in
* Hansel and Gretel. Each pixel taken off the queue is destroyed
* after it is used to locate the allowed neighbors. In fact,
* only one distance image is required, if you initialize it
* to some value that signifies "not yet visited." (We use
* a binary image for marking visited pixels because it is clearer.)
* This method for a simple search of a binary maze is implemented in
* searchBinaryMaze().
* An alternative method would store the (manhattan) distance
* from the start point with each pixel on the queue. The children
* of each pixel get a distance one larger than the parent. These
* values can be stored in an auxiliary distance map image
* that is constructed simultaneously with the search. Once the
* end point is reached, the distance map is used to backtrack
* along a minimum path. There may be several equal length
* minimum paths, any one of which can be chosen this way.
*/
PTA *
pixSearchBinaryMaze(PIX *pixs,
l_int32 xi,
l_int32 yi,
l_int32 xf,
l_int32 yf,
PIX **ppixd)
{
l_int32 i, j, x, y, w, h, d, found;
l_uint32 val, rpixel, gpixel, bpixel;
void **lines1, **linem1, **linep8, **lined32;
MAZEEL *el, *elp;
PIX *pixd; /* the shortest path written on the maze image */
PIX *pixm; /* for bookkeeping, to indicate pixels already visited */
PIX *pixp; /* for bookkeeping, to indicate direction to parent */
L_QUEUE *lq;
PTA *pta;
PROCNAME("pixSearchBinaryMaze");
if (ppixd) *ppixd = NULL;
if (!pixs)
return (PTA *)ERROR_PTR("pixs not defined", procName, NULL);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 1)
return (PTA *)ERROR_PTR("pixs not 1 bpp", procName, NULL);
if (xi <= 0 || xi >= w)
return (PTA *)ERROR_PTR("xi not valid", procName, NULL);
if (yi <= 0 || yi >= h)
return (PTA *)ERROR_PTR("yi not valid", procName, NULL);
pixGetPixel(pixs, xi, yi, &val);
if (val != 0)
return (PTA *)ERROR_PTR("(xi,yi) not bg pixel", procName, NULL);
pixd = NULL;
pta = NULL;
/* Find a bg pixel near input point (xf, yf) */
localSearchForBackground(pixs, &xf, &yf, 5);
#if DEBUG_MAZE
fprintf(stderr, "(xi, yi) = (%d, %d), (xf, yf) = (%d, %d)\n",
xi, yi, xf, yf);
#endif /* DEBUG_MAZE */
pixm = pixCreate(w, h, 1); /* initialized to OFF */
pixp = pixCreate(w, h, 8); /* direction to parent stored as enum val */
lines1 = pixGetLinePtrs(pixs, NULL);
linem1 = pixGetLinePtrs(pixm, NULL);
linep8 = pixGetLinePtrs(pixp, NULL);
lq = lqueueCreate(0);
/* Prime the queue with the first pixel; it is OFF */
el = mazeelCreate(xi, yi, 0); /* don't need direction here */
pixSetPixel(pixm, xi, yi, 1); /* mark visited */
lqueueAdd(lq, el);
/* Fill up the pix storing directions to parents,
* stopping when we hit the point (xf, yf) */
found = FALSE;
while (lqueueGetCount(lq) > 0) {
elp = (MAZEEL *)lqueueRemove(lq);
x = elp->x;
y = elp->y;
if (x == xf && y == yf) {
found = TRUE;
FREE(elp);
break;
}
if (x > 0) { /* check to west */
val = GET_DATA_BIT(linem1[y], x - 1);
if (val == 0) { /* not yet visited */
SET_DATA_BIT(linem1[y], x - 1); /* mark visited */
val = GET_DATA_BIT(lines1[y], x - 1);
if (val == 0) { /* bg, not a wall */
SET_DATA_BYTE(linep8[y], x - 1, DIR_EAST); /* parent E */
el = mazeelCreate(x - 1, y, 0);
lqueueAdd(lq, el);
}
}
}
if (y > 0) { /* check north */
val = GET_DATA_BIT(linem1[y - 1], x);
if (val == 0) { /* not yet visited */
SET_DATA_BIT(linem1[y - 1], x); /* mark visited */
val = GET_DATA_BIT(lines1[y - 1], x);
if (val == 0) { /* bg, not a wall */
SET_DATA_BYTE(linep8[y - 1], x, DIR_SOUTH); /* parent S */
el = mazeelCreate(x, y - 1, 0);
lqueueAdd(lq, el);
}
}
}
if (x < w - 1) { /* check east */
val = GET_DATA_BIT(linem1[y], x + 1);
if (val == 0) { /* not yet visited */
SET_DATA_BIT(linem1[y], x + 1); /* mark visited */
val = GET_DATA_BIT(lines1[y], x + 1);
if (val == 0) { /* bg, not a wall */
SET_DATA_BYTE(linep8[y], x + 1, DIR_WEST); /* parent W */
el = mazeelCreate(x + 1, y, 0);
lqueueAdd(lq, el);
}
}
}
if (y < h - 1) { /* check south */
val = GET_DATA_BIT(linem1[y + 1], x);
if (val == 0) { /* not yet visited */
SET_DATA_BIT(linem1[y + 1], x); /* mark visited */
val = GET_DATA_BIT(lines1[y + 1], x);
if (val == 0) { /* bg, not a wall */
SET_DATA_BYTE(linep8[y + 1], x, DIR_NORTH); /* parent N */
el = mazeelCreate(x, y + 1, 0);
lqueueAdd(lq, el);
}
}
}
FREE(elp);
}
lqueueDestroy(&lq, TRUE);
pixDestroy(&pixm);
FREE(linem1);
if (ppixd) {
pixd = pixUnpackBinary(pixs, 32, 1);
*ppixd = pixd;
}
composeRGBPixel(255, 0, 0, &rpixel); /* start point */
composeRGBPixel(0, 255, 0, &gpixel);
composeRGBPixel(0, 0, 255, &bpixel); /* end point */
if (!found) {
L_INFO(" No path found", procName);
if (pixd) { /* paint all visited locations */
lined32 = pixGetLinePtrs(pixd, NULL);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
val = GET_DATA_BYTE(linep8[i], j);
if (val != 0 && pixd)
SET_DATA_FOUR_BYTES(lined32[i], j, gpixel);
}
}
FREE(lined32);
}
}
else { /* write path onto pixd */
L_INFO(" Path found", procName);
pta = ptaCreate(0);
x = xf;
y = yf;
while (1) {
ptaAddPt(pta, x, y);
if (x == xi && y == yi)
break;
if (pixd)
pixSetPixel(pixd, x, y, gpixel);
pixGetPixel(pixp, x, y, &val);
if (val == DIR_NORTH)
y--;
else if (val == DIR_SOUTH)
y++;
else if (val == DIR_EAST)
x++;
else if (val == DIR_WEST)
x--;
}
}
if (pixd) {
pixSetPixel(pixd, xi, yi, rpixel);
pixSetPixel(pixd, xf, yf, bpixel);
}
pixDestroy(&pixp);
FREE(lines1);
FREE(linep8);
return pta;
}