int main(int argc,
char **argv)
{
l_int32 index;
l_uint32 val32;
BOX *box, *box1, *box2, *box3, *box4, *box5;
BOXA *boxa;
L_KERNEL *kel;
PIX *pixs, *pixg, *pixb, *pixd, *pixt, *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Color non-white pixels on RGB */
pixs = pixRead("lucasta-frag.jpg");
pixt = pixConvert8To32(pixs);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_DARK, 220, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 0 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_DARK, 220, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-white pixels on colormap */
pixt = pixThresholdTo4bpp(pixs, 6, 1);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_DARK, 220, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_DARK, 220, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 3 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-black pixels on RGB */
pixt = pixConvert8To32(pixs);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_LIGHT, 20, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_LIGHT, 80, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-black pixels on colormap */
pixt = pixThresholdTo4bpp(pixs, 6, 1);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_LIGHT, 20, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 6 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_LIGHT, 20, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 7 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Add highlight color to RGB */
pixt = pixConvert8To32(pixs);
box = boxCreate(507, 5, 385, 45);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
pixDisplayWrite(pixb, 1);
composeRGBPixel(50, 0, 250, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
box = boxCreate(236, 107, 262, 40);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
composeRGBPixel(250, 0, 50, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
box = boxCreate(222, 208, 247, 43);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
composeRGBPixel(60, 250, 60, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 8 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Add highlight color to colormap */
pixt = pixThresholdTo4bpp(pixs, 5, 1);
cmap = pixGetColormap(pixt);
pixcmapGetIndex(cmap, 255, 255, 255, &index);
box = boxCreate(507, 5, 385, 45);
pixSetSelectCmap(pixt, box, index, 50, 0, 250);
boxDestroy(&box);
box = boxCreate(236, 107, 262, 40);
pixSetSelectCmap(pixt, box, index, 250, 0, 50);
boxDestroy(&box);
box = boxCreate(222, 208, 247, 43);
pixSetSelectCmap(pixt, box, index, 60, 250, 60);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 9 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Paint lines on RGB */
pixt = pixConvert8To32(pixs);
pixRenderLineArb(pixt, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt, 30, 40, 440, 40, 5, 100, 200, 25);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxArb(pixt, box, 3, 200, 200, 25);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 10 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Paint lines on colormap */
pixt = pixThresholdTo4bpp(pixs, 5, 1);
pixRenderLineArb(pixt, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt, 30, 40, 440, 40, 5, 100, 200, 25);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxArb(pixt, box, 3, 200, 200, 25);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 11 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Blend lines on RGB */
pixt = pixConvert8To32(pixs);
pixRenderLineBlend(pixt, 450, 20, 850, 320, 5, 200, 50, 125, 0.35);
pixRenderLineBlend(pixt, 30, 40, 440, 40, 5, 100, 200, 25, 0.35);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxBlend(pixt, box, 3, 200, 200, 25, 0.6);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 12 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Colorize gray on cmapped image. */
pix1 = pixRead("lucasta.150.jpg");
pix2 = pixThresholdTo4bpp(pix1, 7, 1);
box1 = boxCreate(73, 206, 140, 27);
pixColorGrayCmap(pix2, box1, L_PAINT_LIGHT, 130, 207, 43);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 13 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "One box added");
box2 = boxCreate(255, 404, 197, 25);
pixColorGrayCmap(pix2, box2, L_PAINT_LIGHT, 230, 67, 119);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 14 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Two boxes added");
box3 = boxCreate(122, 756, 224, 22);
pixColorGrayCmap(pix2, box3, L_PAINT_DARK, 230, 67, 119);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 15 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Three boxes added");
box4 = boxCreate(11, 780, 147, 22);
pixColorGrayCmap(pix2, box4, L_PAINT_LIGHT, 70, 137, 229);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 16 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Four boxes added");
box5 = boxCreate(163, 605, 78, 22);
pixColorGrayCmap(pix2, box5, L_PAINT_LIGHT, 70, 137, 229);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 17 */
pixaAddPix(pixa, pix2, L_INSERT);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Five boxes added");
pixDestroy(&pix1);
boxDestroy(&box1);
boxDestroy(&box2);
boxDestroy(&box3);
boxDestroy(&box4);
boxDestroy(&box5);
pixDestroy(&pixs);
/* Make a gray image and identify the fg pixels (val > 230) */
pixs = pixRead("feyn-fract.tif");
pix1 = pixConvertTo8(pixs, 0);
kel = makeGaussianKernel(2, 2, 1.5, 1.0);
pix2 = pixConvolve(pix1, kel, 8, 1);
pix3 = pixThresholdToBinary(pix2, 230);
boxa = pixConnComp(pix3, NULL, 8);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix3);
kernelDestroy(&kel);
/* Color the individual components in the gray image */
pix4 = pixColorGrayRegions(pix2, boxa, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 18 */
pixaAddPix(pixa, pix4, L_INSERT);
pixDisplayWithTitle(pix4, 0, 0, NULL, rp->display);
/* Threshold to 10 levels of gray */
pix3 = pixThresholdOn8bpp(pix2, 10, 1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 19 */
pixaAddPix(pixa, pix3, L_COPY);
/* Color the individual components in the cmapped image */
pix4 = pixColorGrayRegions(pix3, boxa, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 20 */
pixaAddPix(pixa, pix4, L_INSERT);
pixDisplayWithTitle(pix4, 0, 100, NULL, rp->display);
boxaDestroy(&boxa);
/* Color the entire gray image (not component-wise) */
pixColorGray(pix2, NULL, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 21 */
pixaAddPix(pixa, pix2, L_INSERT);
/* Color the entire cmapped image (not component-wise) */
pixColorGray(pix3, NULL, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 22 */
pixaAddPix(pixa, pix3, L_INSERT);
/* Reconstruct cmapped images */
pixd = ReconstructByValue(rp, "weasel2.4c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 23 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = ReconstructByValue(rp, "weasel4.11c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 24 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = ReconstructByValue(rp, "weasel8.240c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 25 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Fake reconstruct cmapped images, with one color into a band */
pixd = FakeReconstructByBand(rp, "weasel2.4c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 26 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = FakeReconstructByBand(rp, "weasel4.11c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 27 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = FakeReconstructByBand(rp, "weasel8.240c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 28 */
pixaAddPix(pixa, pixd, L_INSERT);
/* If in testing mode, make a pdf */
if (rp->display) {
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0,
"Colorize and paint", "/tmp/lept/regout/paint.pdf");
L_INFO("Output pdf: /tmp/lept/regout/paint.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
/*!
* pixSearchGrayMaze()
*
* 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
*
* Commentary:
* Consider first a slight generalization of the binary maze
* search problem. Suppose that you can go through walls,
* but the cost is higher (say, an increment of 3 to go into
* a wall pixel rather than 1)? You're still trying to find
* the shortest path. One way to do this is with an ordered
* queue, and a simple way to visualize an ordered queue is as
* a set of stacks, each stack being marked with the distance
* of each pixel in the stack from the start. We place the
* start pixel in stack 0, pop it, and process its 4 children.
* Each pixel is given a distance that is incremented from that
* of its parent (0 in this case), depending on if it is a wall
* pixel or not. That value may be recorded on a distance map,
* according to the algorithm below. For children of the first
* pixel, those not on a wall go in stack 1, and wall
* children go in stack 3. Stack 0 being emptied, the process
* then continues with pixels being popped from stack 1.
* Here is the algorithm for each child pixel. The pixel's
* distance value, were it to be placed on a stack, is compared
* with the value for it that is on the distance map. There
* are three possible cases:
* (1) If the pixel has not yet been registered, it is pushed
* on its stack and the distance is written to the map.
* (2) If it has previously been registered with a higher distance,
* the distance on the map is relaxed to that of the
* current pixel, which is then placed on its stack.
* (3) If it has previously been registered with an equal
* or lower value, the pixel is discarded.
* The pixels are popped and processed successively from
* stack 1, and when stack 1 is empty, popping starts on stack 2.
* This continues until the destination pixel is popped off
* a stack. The minimum path is then derived from the distance map,
* going back from the end point as before. This is just Dijkstra's
* algorithm for a directed graph; here, the underlying graph
* (consisting of the pixels and four edges connecting each pixel
* to its 4-neighbor) is a special case of a directed graph, where
* each edge is bi-directional. The implementation of this generalized
* maze search is left as an exercise to the reader.
*
* Let's generalize a bit further. Suppose the "maze" is just
* a grayscale image -- think of it as an elevation map. The cost
* of moving on this surface depends on the height, or the gradient,
* or whatever you want. All that is required is that the cost
* is specified and non-negative on each link between adjacent
* pixels. Now the problem becomes: find the least cost path
* moving on this surface between two specified end points.
* For example, if the cost across an edge between two pixels
* depends on the "gradient", you can use:
* cost = 1 + L_ABS(deltaV)
* where deltaV is the difference in value between two adjacent
* pixels. If the costs are all integers, we can still use an array
* of stacks to avoid ordering the queue (e.g., by using a heap sort.)
* This is a neat problem, because you don't even have to build a
* maze -- you can can use it on any grayscale image!
*
* Rather than using an array of stacks, a more practical
* approach is to implement with a priority queue, which is
* a queue that is sorted so that the elements with the largest
* (or smallest) key values always come off first. The
* priority queue is efficiently implemented as a heap, and
* this is how we do it. Suppose you run the algorithm
* using a priority queue, doing the bookkeeping with an
* auxiliary image data structure that saves the distance of
* each pixel put on the queue as before, according to the method
* described above. We implement it as a 2-way choice by
* initializing the distance array to a large value and putting
* a pixel on the queue if its distance is less than the value
* found on the array. When you finally pop the end pixel from
* the queue, you're done, and you can trace the path backward,
* either always going downhill or using an auxiliary image to
* give you the direction to go at each step. This is implemented
* here in searchGrayMaze().
*
* Do we really have to use a sorted queue? Can we solve this
* generalized maze with an unsorted queue of pixels? (Or even
* an unsorted stack, doing a depth-first search (DFS)?)
* Consider a different algorithm for this generalized maze, where
* we travel again breadth first, but this time use a single,
* unsorted queue. An auxiliary image is used as before to
* store the distances and to determine if pixels get pushed
* on the stack or dropped. As before, we must allow pixels
* to be revisited, with relaxation of the distance if a shorter
* path arrives later. As a result, we will in general have
* multiple instances of the same pixel on the stack with different
* distances. However, because the queue is not ordered, some of
* these pixels will be popped when another instance with a lower
* distance is still on the stack. Here, we're just popping them
* in the order they go on, rather than setting up a priority
* based on minimum distance. Thus, unlike the priority queue,
* when a pixel is popped we have to check the distance map to
* see if a pixel with a lower distance has been put on the queue,
* and, if so, we discard the pixel we just popped. So the
* "while" loop looks like this:
* - pop a pixel from the queue
* - check its distance against the distance stored in the
* distance map; if larger, discard
* - otherwise, for each of its neighbors:
* - compute its distance from the start pixel
* - compare this distance with that on the distance map:
* - if the distance map value higher, relax the distance
* and push the pixel on the queue
* - if the distance map value is lower, discard the pixel
*
* How does this loop terminate? Before, with an ordered queue,
* it terminates when you pop the end pixel. But with an unordered
* queue (or stack), the first time you hit the end pixel, the
* distance is not guaranteed to be correct, because the pixels
* along the shortest path may not have yet been visited and relaxed.
* Because the shortest path can theoretically go anywhere,
* we must keep going. How do we know when to stop? Dijkstra
* uses an ordered queue to systematically remove nodes from
* further consideration. (Each time a pixel is popped, we're
* done with it; it's "finalized" in the Dijkstra sense because
* we know the shortest path to it.) However, with an unordered
* queue, the brute force answer is: stop when the queue
* (or stack) is empty, because then every pixel in the image
* has been assigned its minimum "distance" from the start pixel.
*
* This is similar to the situation when you use a stack for the
* simpler uniform-step problem: with breadth-first search (BFS)
* the pixels on the queue are automatically ordered, so you are
* done when you locate the end pixel as a neighbor of a popped pixel;
* whereas depth-first search (DFS), using a stack, requires,
* in general, a search of every accessible pixel. Further, if
* a pixel is revisited with a smaller distance, that distance is
* recorded and the pixel is put on the stack again.
*
* But surely, you ask, can't we stop sooner? What if the
* start and end pixels are very close to each other?
* OK, suppose they are, and you have very high walls and a
* long snaking level path that is actually the minimum cost.
* That long path can wind back and forth across the entire
* maze many times before ending up at the end point, which
* could be just over a wall from the start. With the unordered
* queue, you very quickly get a high distance for the end
* pixel, which will be relaxed to the minimum distance only
* after all the pixels of the path have been visited and placed
* on the queue, multiple times for many of them. So that's the
* price for not ordering the queue!
*/
PTA *
pixSearchGrayMaze(PIX *pixs,
l_int32 xi,
l_int32 yi,
l_int32 xf,
l_int32 yf,
PIX **ppixd)
{
l_int32 x, y, w, h, d;
l_uint32 val, valr, vals, rpixel, gpixel, bpixel;
void **lines8, **liner32, **linep8;
l_int32 cost, dist, distparent, sival, sivals;
MAZEEL *el, *elp;
PIX *pixd; /* optionally plot the path on this RGB version of pixs */
PIX *pixr; /* for bookkeeping, to indicate the minimum distance */
/* to pixels already visited */
PIX *pixp; /* for bookkeeping, to indicate direction to parent */
L_HEAP *lh;
PTA *pta;
PROCNAME("pixSearchGrayMaze");
if (ppixd) *ppixd = NULL;
if (!pixs)
return (PTA *)ERROR_PTR("pixs not defined", procName, NULL);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 8)
return (PTA *)ERROR_PTR("pixs not 8 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);
pixd = NULL;
pta = NULL;
pixr = pixCreate(w, h, 32);
pixSetAll(pixr); /* initialize to max value */
pixp = pixCreate(w, h, 8); /* direction to parent stored as enum val */
lines8 = pixGetLinePtrs(pixs, NULL);
linep8 = pixGetLinePtrs(pixp, NULL);
liner32 = pixGetLinePtrs(pixr, NULL);
lh = lheapCreate(0, L_SORT_INCREASING); /* always remove closest pixels */
/* Prime the heap with the first pixel */
pixGetPixel(pixs, xi, yi, &val);
el = mazeelCreate(xi, yi, 0); /* don't need direction here */
el->distance = 0;
pixGetPixel(pixs, xi, yi, &val);
el->val = val;
pixSetPixel(pixr, xi, yi, 0); /* distance is 0 */
lheapAdd(lh, el);
/* Breadth-first search with priority queue (implemented by
a heap), labeling direction to parents in pixp and minimum
distance to visited pixels in pixr. Stop when we pull
the destination point (xf, yf) off the queue. */
while (lheapGetCount(lh) > 0) {
elp = (MAZEEL *)lheapRemove(lh);
if (!elp)
return (PTA *)ERROR_PTR("heap broken!!", procName, NULL);
x = elp->x;
y = elp->y;
if (x == xf && y == yf) { /* exit condition */
FREE(elp);
break;
}
distparent = (l_int32)elp->distance;
val = elp->val;
sival = val;
if (x > 0) { /* check to west */
vals = GET_DATA_BYTE(lines8[y], x - 1);
valr = GET_DATA_FOUR_BYTES(liner32[y], x - 1);
sivals = (l_int32)vals;
cost = 1 + L_ABS(sivals - sival); /* cost to move to this pixel */
dist = distparent + cost;
if (dist < valr) { /* shortest path so far to this pixel */
SET_DATA_FOUR_BYTES(liner32[y], x - 1, dist); /* new dist */
SET_DATA_BYTE(linep8[y], x - 1, DIR_EAST); /* parent to E */
el = mazeelCreate(x - 1, y, 0);
el->val = vals;
el->distance = dist;
lheapAdd(lh, el);
}
}
if (y > 0) { /* check north */
vals = GET_DATA_BYTE(lines8[y - 1], x);
valr = GET_DATA_FOUR_BYTES(liner32[y - 1], x);
sivals = (l_int32)vals;
cost = 1 + L_ABS(sivals - sival); /* cost to move to this pixel */
dist = distparent + cost;
if (dist < valr) { /* shortest path so far to this pixel */
SET_DATA_FOUR_BYTES(liner32[y - 1], x, dist); /* new dist */
SET_DATA_BYTE(linep8[y - 1], x, DIR_SOUTH); /* parent to S */
el = mazeelCreate(x, y - 1, 0);
el->val = vals;
el->distance = dist;
lheapAdd(lh, el);
}
}
if (x < w - 1) { /* check east */
vals = GET_DATA_BYTE(lines8[y], x + 1);
valr = GET_DATA_FOUR_BYTES(liner32[y], x + 1);
sivals = (l_int32)vals;
cost = 1 + L_ABS(sivals - sival); /* cost to move to this pixel */
dist = distparent + cost;
if (dist < valr) { /* shortest path so far to this pixel */
SET_DATA_FOUR_BYTES(liner32[y], x + 1, dist); /* new dist */
SET_DATA_BYTE(linep8[y], x + 1, DIR_WEST); /* parent to W */
el = mazeelCreate(x + 1, y, 0);
el->val = vals;
el->distance = dist;
lheapAdd(lh, el);
}
}
if (y < h - 1) { /* check south */
vals = GET_DATA_BYTE(lines8[y + 1], x);
valr = GET_DATA_FOUR_BYTES(liner32[y + 1], x);
sivals = (l_int32)vals;
cost = 1 + L_ABS(sivals - sival); /* cost to move to this pixel */
dist = distparent + cost;
if (dist < valr) { /* shortest path so far to this pixel */
SET_DATA_FOUR_BYTES(liner32[y + 1], x, dist); /* new dist */
SET_DATA_BYTE(linep8[y + 1], x, DIR_NORTH); /* parent to N */
el = mazeelCreate(x, y + 1, 0);
el->val = vals;
el->distance = dist;
lheapAdd(lh, el);
}
}
FREE(elp);
}
lheapDestroy(&lh, TRUE);
if (ppixd) {
pixd = pixConvert8To32(pixs);
*ppixd = pixd;
}
composeRGBPixel(255, 0, 0, &rpixel); /* start point */
composeRGBPixel(0, 255, 0, &gpixel);
composeRGBPixel(0, 0, 255, &bpixel); /* end point */
x = xf;
y = yf;
pta = ptaCreate(0);
while (1) { /* write path onto pixd */
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--;
pixGetPixel(pixr, x, y, &val);
#if DEBUG_PATH
fprintf(stderr, "(x,y) = (%d, %d); dist = %d\n", x, y, val);
#endif /* DEBUG_PATH */
}
if (pixd) {
pixSetPixel(pixd, xi, yi, rpixel);
pixSetPixel(pixd, xf, yf, bpixel);
}
pixDestroy(&pixp);
pixDestroy(&pixr);
FREE(lines8);
FREE(linep8);
FREE(liner32);
return pta;
}
