int main(int argc,
char **argv)
{
l_int32 i, j, x, y, rval, gval, bval;
l_uint32 pixel;
l_float32 frval, fgval, fbval;
NUMA *nahue, *nasat, *napk;
PIX *pixs, *pixhsv, *pixh, *pixg, *pixf, *pixd;
PIX *pixr, *pixt1, *pixt2, *pixt3;
PIXA *pixa, *pixapk;
PTA *ptapk;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Make a graded frame color */
pixs = pixCreate(650, 900, 32);
for (i = 0; i < 900; i++) {
rval = 40 + i / 30;
for (j = 0; j < 650; j++) {
gval = 255 - j / 30;
bval = 70 + j / 30;
composeRGBPixel(rval, gval, bval, &pixel);
pixSetPixel(pixs, j, i, pixel);
}
}
/* Place an image inside the frame and convert to HSV */
pixt1 = pixRead("1555.003.jpg");
pixt2 = pixScale(pixt1, 0.5, 0.5);
pixRasterop(pixs, 100, 100, 2000, 2000, PIX_SRC, pixt2, 0, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDisplayWithTitle(pixs, 400, 0, "Input image", rp->display);
pixa = pixaCreate(0);
pixhsv = pixConvertRGBToHSV(NULL, pixs);
/* Work in the HS projection of HSV */
pixh = pixMakeHistoHS(pixhsv, 5, &nahue, &nasat);
pixg = pixMaxDynamicRange(pixh, L_LOG_SCALE);
pixf = pixConvertGrayToFalseColor(pixg, 1.0);
regTestWritePixAndCheck(rp, pixf, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixf, 100, 0, "False color HS histo", rp->display);
pixaAddPix(pixa, pixs, L_COPY);
pixaAddPix(pixa, pixhsv, L_INSERT);
pixaAddPix(pixa, pixg, L_INSERT);
pixaAddPix(pixa, pixf, L_INSERT);
gplotSimple1(nahue, GPLOT_PNG, "/tmp/lept/regout/junkhue",
"Histogram of hue values");
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixt3 = pixRead("/tmp/lept/regout/junkhue.png");
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixt3, 100, 300, "Histo of hue", rp->display);
pixaAddPix(pixa, pixt3, L_INSERT);
gplotSimple1(nasat, GPLOT_PNG, "/tmp/lept/regout/junksat",
"Histogram of saturation values");
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixt3 = pixRead("/tmp/lept/regout/junksat.png");
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixt3, 100, 800, "Histo of saturation", rp->display);
pixaAddPix(pixa, pixt3, L_INSERT);
pixd = pixaDisplayTiledAndScaled(pixa, 32, 270, 7, 0, 30, 3);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixd, 0, 400, "Hue and Saturation Mosaic", rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
numaDestroy(&nahue);
numaDestroy(&nasat);
/* Find all the peaks */
pixFindHistoPeaksHSV(pixh, L_HS_HISTO, 20, 20, 6, 2.0,
&ptapk, &napk, &pixapk);
numaWriteStream(stderr, napk);
ptaWriteStream(stderr, ptapk, 1);
pixd = pixaDisplayTiledInRows(pixapk, 32, 1400, 1.0, 0, 30, 2);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixd, 0, 550, "Peaks in HS", rp->display);
pixDestroy(&pixh);
pixDestroy(&pixd);
pixaDestroy(&pixapk);
/* Make masks for each of the peaks */
pixa = pixaCreate(0);
pixr = pixScaleBySampling(pixs, 0.4, 0.4);
for (i = 0; i < 6; i++) {
ptaGetIPt(ptapk, i, &x, &y);
pixt1 = pixMakeRangeMaskHS(pixr, y, 20, x, 20, L_INCLUDE_REGION);
pixaAddPix(pixa, pixt1, L_INSERT);
pixGetAverageMaskedRGB(pixr, pixt1, 0, 0, 1, L_MEAN_ABSVAL,
&frval, &fgval, &fbval);
composeRGBPixel((l_int32)frval, (l_int32)fgval, (l_int32)fbval,
&pixel);
pixt2 = pixCreateTemplate(pixr);
pixSetAll(pixt2);
pixPaintThroughMask(pixt2, pixt1, 0, 0, pixel);
pixaAddPix(pixa, pixt2, L_INSERT);
pixt3 = pixCreateTemplate(pixr);
pixSetAllArbitrary(pixt3, pixel);
pixaAddPix(pixa, pixt3, L_INSERT);
}
pixd = pixaDisplayTiledAndScaled(pixa, 32, 225, 3, 0, 30, 3);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixd, 600, 0, "Masks over peaks", rp->display);
pixDestroy(&pixs);
pixDestroy(&pixr);
pixDestroy(&pixd);
pixaDestroy(&pixa);
ptaDestroy(&ptapk);
numaDestroy(&napk);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, j, w, h, empty;
l_uint32 redval, greenval;
l_float32 f;
L_WSHED *wshed;
PIX *pixs, *pixc, *pixd;
PIX *pixt0, *pixt1, *pixt2, *pixt3, *pixt4, *pixt5;
PIX *pixt6, *pixt7, *pixt8;
PIXA *pixac;
PTA *pta;
static char mainName[] = "watershedtest";
if (argc != 1)
return ERROR_INT(" Syntax: watershedtest", mainName, 1);
pixac = pixaCreate(0);
pixs = pixCreate(500, 500, 8);
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 500; i++) {
for (j = 0; j < 500; j++) {
#if 1
f = 128.0 + 26.3 * sin(0.0438 * (l_float32)i);
f += 33.4 * cos(0.0712 * (l_float32)i);
f += 18.6 * sin(0.0561 * (l_float32)j);
f += 23.6 * cos(0.0327 * (l_float32)j);
#else
f = 128.0 + 26.3 * sin(0.0238 * (l_float32)i);
f += 33.4 * cos(0.0312 * (l_float32)i);
f += 18.6 * sin(0.0261 * (l_float32)j);
f += 23.6 * cos(0.0207 * (l_float32)j);
#endif
pixSetPixel(pixs, j, i, (l_int32)f);
}
}
pixSaveTiled(pixs, pixac, 1.0, 1, 10, 32);
pixWrite("/tmp/pattern.png", pixs, IFF_PNG);
startTimer();
pixLocalExtrema(pixs, 0, 0, &pixt1, &pixt2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
pixSetOrClearBorder(pixt1, 2, 2, 2, 2, PIX_CLR);
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixc = pixConvertTo32(pixs);
pixPaintThroughMask(pixc, pixt2, 0, 0, greenval);
pixPaintThroughMask(pixc, pixt1, 0, 0, redval);
pixSaveTiled(pixc, pixac, 1.0, 0, 10, 32);
pixWrite("/tmp/pixc.png", pixc, IFF_PNG);
pixSaveTiled(pixt1, pixac, 1.0, 0, 10, 32);
pixSelectMinInConnComp(pixs, pixt1, &pta, NULL);
/* ptaWriteStream(stderr, pta, 1); */
pixt3 = pixGenerateFromPta(pta, w, h);
pixSaveTiled(pixt3, pixac, 1.0, 1, 10, 32);
pixt4 = pixConvertTo32(pixs);
pixPaintThroughMask(pixt4, pixt3, 0, 0, greenval);
pixSaveTiled(pixt4, pixac, 1.0, 0, 10, 32);
pixt5 = pixRemoveSeededComponents(NULL, pixt3, pixt1, 8, 2);
pixSaveTiled(pixt5, pixac, 1.0, 0, 10, 32);
pixZero(pixt5, &empty);
fprintf(stderr, "Is empty? %d\n", empty);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
wshed = wshedCreate(pixs, pixt3, 10, 0);
startTimer();
wshedApply(wshed);
fprintf(stderr, "Time for wshed: %7.3f\n", stopTimer());
pixt6 = pixaDisplayRandomCmap(wshed->pixad, w, h);
pixSaveTiled(pixt6, pixac, 1.0, 1, 10, 32);
numaWriteStream(stderr, wshed->nalevels);
pixt7 = wshedRenderFill(wshed);
pixSaveTiled(pixt7, pixac, 1.0, 0, 10, 32);
pixt8 = wshedRenderColors(wshed);
pixSaveTiled(pixt8, pixac, 1.0, 0, 10, 32);
wshedDestroy(&wshed);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/wshed.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
pixDestroy(&pixt8);
pixDestroy(&pixs);
pixDestroy(&pixc);
ptaDestroy(&pta);
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, j, w, h;
l_int32 minsum[5] = { 2, 40, 50, 50, 70};
l_int32 skipdist[5] = { 5, 5, 10, 10, 30};
l_int32 delta[5] = { 2, 10, 10, 25, 40};
l_int32 maxbg[5] = {10, 15, 10, 20, 40};
BOX *box1, *box2, *box3, *box4;
BOXA *boxa;
PIX *pixs, *pixc, *pixt, *pixd, *pix32;
PIXA *pixas, *pixad;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate and save 1 bpp masks */
pixas = pixaCreate(0);
pixs = pixCreate(300, 250, 1);
pixSetAll(pixs);
box1 = boxCreate(50, 0, 140, 25);
box2 = boxCreate(120, 100, 100, 25);
box3 = boxCreate(75, 170, 80, 20);
box4 = boxCreate(150, 80, 25, 70);
pixClearInRect(pixs, box1);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box2);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box3);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box4);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
boxDestroy(&box1);
boxDestroy(&box2);
boxDestroy(&box3);
boxDestroy(&box4);
pixDestroy(&pixs);
/* Do 5 splittings on each of the 8 masks */
pixad = pixaCreate(0);
for (j = 0; j < 8; j++) {
pixt = pixaGetPix(pixas, j, L_CLONE);
pixGetDimensions(pixt, &w, &h, NULL);
pix32 = pixCreate(w, h, 32);
pixSetAll(pix32);
pixPaintThroughMask(pix32, pixt, 0, 0, 0xc0c0c000);
pixSaveTiled(pix32, pixad, 1, 1, 30, 32);
for (i = 0; i < 5; i++) {
pixc = pixCopy(NULL, pix32);
boxa = pixSplitComponentIntoBoxa(pixt, NULL, minsum[i], skipdist[i],
delta[i], maxbg[i], 0, 1);
/* boxaWriteStream(stderr, boxa); */
pixd = pixBlendBoxaRandom(pixc, boxa, 0.4);
pixRenderBoxaArb(pixd, boxa, 2, 255, 0, 0);
pixSaveTiled(pixd, pixad, 1, 0, 30, 32);
pixDestroy(&pixd);
pixDestroy(&pixc);
boxaDestroy(&boxa);
}
pixDestroy(&pixt);
pixDestroy(&pix32);
}
/* Display results */
pixd = pixaDisplay(pixad, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixad);
/* Put the 8 masks all together, and split 5 ways */
pixad = pixaCreate(0);
pixs = pixaDisplayOnLattice(pixas, 325, 325);
pixGetDimensions(pixs, &w, &h, NULL);
pix32 = pixCreate(w, h, 32);
pixSetAll(pix32);
pixPaintThroughMask(pix32, pixs, 0, 0, 0xc0c0c000);
pixSaveTiled(pix32, pixad, 1, 1, 30, 32);
for (i = 0; i < 5; i++) {
pixc = pixCopy(NULL, pix32);
boxa = pixSplitIntoBoxa(pixs, minsum[i], skipdist[i],
delta[i], maxbg[i], 0, 1);
/* boxaWriteStream(stderr, boxa); */
pixd = pixBlendBoxaRandom(pixc, boxa, 0.4);
pixRenderBoxaArb(pixd, boxa, 2, 255, 0, 0);
pixSaveTiled(pixd, pixad, 1, 0, 30, 32);
pixDestroy(&pixd);
pixDestroy(&pixc);
boxaDestroy(&boxa);
}
pixDestroy(&pix32);
pixDestroy(&pixs);
/* Display results */
pixd = pixaDisplay(pixad, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixad);
pixaDestroy(&pixas);
regTestCleanup(rp);
return 0;
}
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;
}
main(int argc,
char **argv)
{
l_int32 i, j;
l_float32 f;
l_uint32 redval, greenval;
PIX *pixs, *pixd, *pixt0, *pixt1, *pixt2, *pixt3;
static char mainName[] = "locminmax_reg";
if (argc != 1)
exit(ERROR_INT("syntax: locminmax_reg", mainName, 1));
pixs = pixCreate(500, 500, 8);
for (i = 0; i < 500; i++) {
for (j = 0; j < 500; j++) {
f = 128.0 + 26.3 * sin(0.0438 * (l_float32)i);
f += 33.4 * cos(0.0712 * (l_float32)i);
f += 18.6 * sin(0.0561 * (l_float32)j);
f += 23.6 * cos(0.0327 * (l_float32)j);
pixSetPixel(pixs, j, i, (l_int32)f);
}
}
pixDisplay(pixs, 0, 0);
pixWrite("/tmp/junkpattern.png", pixs, IFF_PNG);
startTimer();
/* pixSelectedLocalExtrema(pixs, 1, &pixt1, &pixt2); */
pixLocalExtrema(pixs, 0, 0, &pixt1, &pixt2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixd = pixConvertTo32(pixs);
pixPaintThroughMask(pixd, pixt2, 0, 0, greenval);
pixPaintThroughMask(pixd, pixt1, 0, 0, redval);
pixDisplay(pixd, 510, 0);
pixWrite("/tmp/junkpixd.png", pixd, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDestroy(&pixd);
pixt0 = pixRead("karen8.jpg");
pixs = pixBlockconv(pixt0, 10, 10);
pixDisplay(pixs, 0, 400);
pixWrite("/tmp/junkconv.png", pixs, IFF_PNG);
startTimer();
/* pixSelectedLocalExtrema(pixs, 1, &pixt1, &pixt2); */
pixLocalExtrema(pixs, 50, 100, &pixt1, &pixt2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixd = pixConvertTo32(pixs);
pixPaintThroughMask(pixd, pixt2, 0, 0, greenval);
pixPaintThroughMask(pixd, pixt1, 0, 0, redval);
pixDisplay(pixd, 350, 400);
pixWrite("/tmp/junkpixd2.png", pixd, IFF_PNG);
pixDestroy(&pixt0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDestroy(&pixd);
return 0;
}
/*!
* \brief selaAddTJunctions()
*
* \param[in] sela [optional]
* \param[in] hlsize length of each line of hits from origin
* \param[in] mdist distance of misses from the origin
* \param[in] norient number of orientations; max of 8
* \param[in] debugflag 1 for debug output
* \return sela with additional sels, or NULL on error
*
* <pre>
* Notes:
* (1) Adds hitmiss Sels for the T-junction of two lines.
* If the lines are very thin, they must be nearly orthogonal
* to register.
* (2) The number of Sels generated is 4 * %norient.
* (3) It is suggested that %hlsize be chosen at least 1 greater
* than %mdist. Try values of (%hlsize, %mdist) such as
* (6,5), (7,6), (8,7), (9,7), etc.
* </pre>
*/
SELA *
selaAddTJunctions(SELA *sela,
l_float32 hlsize,
l_float32 mdist,
l_int32 norient,
l_int32 debugflag)
{
char name[L_BUF_SIZE];
l_int32 i, j, k, w, xc, yc;
l_float64 pi, halfpi, radincr, jang, radang;
l_float64 angle[3], dist[3];
PIX *pixc, *pixm, *pixt;
PIXA *pixa;
PTA *pta1, *pta2, *pta3;
SEL *sel;
PROCNAME("selaAddTJunctions");
if (hlsize <= 2)
return (SELA *)ERROR_PTR("hlsizel not > 1", procName, NULL);
if (norient < 1 || norient > 8)
return (SELA *)ERROR_PTR("norient not in [1, ... 8]", procName, NULL);
if (!sela) {
if ((sela = selaCreate(0)) == NULL)
return (SELA *)ERROR_PTR("sela not made", procName, NULL);
}
pi = 3.1415926535;
halfpi = 3.1415926535 / 2.0;
radincr = halfpi / (l_float32)norient;
w = (l_int32)(2.4 * (L_MAX(hlsize, mdist) + 0.5));
if (w % 2 == 0)
w++;
xc = w / 2;
yc = w / 2;
pixa = pixaCreate(4 * norient);
for (i = 0; i < norient; i++) {
for (j = 0; j < 4; j++) { /* 4 orthogonal orientations */
jang = (l_float32)j * halfpi;
/* Set the don't cares */
pixc = pixCreate(w, w, 32);
pixSetAll(pixc);
/* Add the green lines of hits */
pixm = pixCreate(w, w, 1);
radang = (l_float32)i * radincr;
pta1 = generatePtaLineFromPt(xc, yc, hlsize + 1, jang + radang);
pta2 = generatePtaLineFromPt(xc, yc, hlsize + 1,
jang + radang + halfpi);
pta3 = generatePtaLineFromPt(xc, yc, hlsize + 1,
jang + radang + pi);
ptaJoin(pta1, pta2, 0, -1);
ptaJoin(pta1, pta3, 0, -1);
pixRenderPta(pixm, pta1, L_SET_PIXELS);
pixPaintThroughMask(pixc, pixm, 0, 0, 0x00ff0000);
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
/* Add red misses between the lines */
angle[0] = radang + jang - halfpi;
angle[1] = radang + jang + 0.5 * halfpi;
angle[2] = radang + jang + 1.5 * halfpi;
dist[0] = 0.8 * mdist;
dist[1] = dist[2] = mdist;
for (k = 0; k < 3; k++) {
pixSetPixel(pixc, xc + (l_int32)(dist[k] * cos(angle[k])),
yc + (l_int32)(dist[k] * sin(angle[k])),
0xff000000);
}
/* Add dark green for origin */
pixSetPixel(pixc, xc, yc, 0x00550000);
/* Generate the sel */
sel = selCreateFromColorPix(pixc, NULL);
sprintf(name, "sel_cross_%d", 4 * i + j);
selaAddSel(sela, sel, name, 0);
if (debugflag) {
pixt = pixScaleBySampling(pixc, 10.0, 10.0);
pixaAddPix(pixa, pixt, L_INSERT);
}
pixDestroy(&pixm);
pixDestroy(&pixc);
}
}
if (debugflag) {
l_int32 w;
lept_mkdir("lept/sel");
pixaGetPixDimensions(pixa, 0, &w, NULL, NULL);
pixt = pixaDisplayTiledAndScaled(pixa, 32, w, 4, 0, 10, 2);
pixWrite("/tmp/lept/sel/tsel1.png", pixt, IFF_PNG);
pixDisplay(pixt, 0, 100);
pixDestroy(&pixt);
pixt = selaDisplayInPix(sela, 15, 2, 20, 4);
pixWrite("/tmp/lept/sel/tsel2.png", pixt, IFF_PNG);
pixDisplay(pixt, 500, 100);
pixDestroy(&pixt);
selaWriteStream(stderr, sela);
}
pixaDestroy(&pixa);
return sela;
}
