main(int argc,
char **argv)
{
char *filein;
l_int32 i, n, ns;
BOX *box;
BOXA *boxa, *boxas;
PIX *pixs, *pixt;
PIXA *pixa, *pixas, *pixas2;
static char mainName[] = "sorttest";
if (argc != 2)
exit(ERROR_INT(" Syntax: sorttest filein", mainName, 1));
filein = argv[1];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
#if 0
boxa = pixConnComp(pixs, NULL, 8);
n = boxaGetCount(boxa);
boxas = boxaSort(boxa, L_SORT_BY_PERIMETER, L_SORT_DECREASING, NULL);
ns = boxaGetCount(boxas);
fprintf(stderr, "Number of cc: n = %d, ns = %d\n", n, ns);
boxaWrite("/tmp/junkboxa.ba", boxas);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxas, i, L_CLONE);
pixRenderBox(pixs, box, 2, L_FLIP_PIXELS);
boxDestroy(&box);
}
pixWrite("/tmp/junkout.png", pixs, IFF_PNG);
boxaDestroy(&boxa);
boxaDestroy(&boxas);
#endif
#if 1
boxa = pixConnComp(pixs, &pixa, 8);
n = pixaGetCount(pixa);
pixas = pixaSort(pixa, L_SORT_BY_Y, L_SORT_INCREASING, NULL, L_CLONE);
ns = pixaGetCount(pixas);
fprintf(stderr, "Number of cc: n = %d, ns = %d\n", n, ns);
pixaWrite("/tmp/junkpixa.pa", pixas);
pixas2 = pixaRead("/tmp/junkpixa.pa");
pixaWrite("/tmp/junkpixa2.pa", pixas2);
pixt = pixaDisplayOnLattice(pixas, 100, 100);
pixWrite("/tmp/junkpix.png", pixt, IFF_PNG);
boxaWrite("/tmp/junkboxa.ba", pixas->boxa);
pixDestroy(&pixt);
pixaDestroy(&pixa);
pixaDestroy(&pixas);
pixaDestroy(&pixas2);
boxaDestroy(&boxa);
#endif
pixDestroy(&pixs);
return 0;
}
int main(int argc,
char **argv)
{
char *filein;
l_int32 i, n, count;
BOX *box;
BOXA *boxa;
PIX *pixs, *pixd;
PIXA *pixa;
PIXCMAP *cmap;
static char mainName[] = "cctest1";
if (argc != 2)
return ERROR_INT(" Syntax: cctest1 filein", mainName, 1);
filein = argv[1];
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
if (pixGetDepth(pixs) != 1)
exit(ERROR_INT("pixs not 1 bpp", mainName, 1));
/* Test speed of pixCountConnComp() */
startTimer();
for (i = 0; i < NTIMES; i++)
pixCountConnComp(pixs, 4, &count);
fprintf(stderr, "Time to compute 4-cc: %6.3f sec\n", stopTimer()/NTIMES);
fprintf(stderr, "Number of 4-cc: %d\n", count);
startTimer();
for (i = 0; i < NTIMES; i++)
pixCountConnComp(pixs, 8, &count);
fprintf(stderr, "Time to compute 8-cc: %6.3f sec\n", stopTimer()/NTIMES);
fprintf(stderr, "Number of 8-cc: %d\n", count);
/* Test speed of pixConnComp(), with only boxa output */
startTimer();
for (i = 0; i < NTIMES; i++) {
boxa = pixConnComp(pixs, NULL, 4);
boxaDestroy(&boxa);
}
fprintf(stderr, "Time to compute 4-cc: %6.3f sec\n", stopTimer()/NTIMES);
startTimer();
for (i = 0; i < NTIMES; i++) {
boxa = pixConnComp(pixs, NULL, 8);
boxaDestroy(&boxa);
}
fprintf(stderr, "Time to compute 8-cc: %6.3f sec\n", stopTimer()/NTIMES);
/* Draw outline of each c.c. box */
boxa = pixConnComp(pixs, NULL, 4);
n = boxaGetCount(boxa);
fprintf(stderr, "Num 4-cc boxes: %d\n", n);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa, i, L_CLONE);
pixRenderBox(pixs, box, 3, L_FLIP_PIXELS);
boxDestroy(&box); /* remember, clones need to be destroyed */
}
pixDisplayWrite(pixs, 1);
boxaDestroy(&boxa);
/* Display each component as a random color in cmapped 8 bpp.
* Background is color 0; it is set to white. */
boxa = pixConnComp(pixs, &pixa, 4);
pixd = pixaDisplayRandomCmap(pixa, pixGetWidth(pixs), pixGetHeight(pixs));
cmap = pixGetColormap(pixd);
pixcmapResetColor(cmap, 0, 255, 255, 255); /* reset background to white */
pixDisplay(pixd, 100, 100);
pixDisplayWrite(pixd, 1);
boxaDestroy(&boxa);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
return 0;
}
int main_find_pattern(int argc,
char **argv)
{
char *filein, *fileout, *patternfile;
l_int32 w, h, i, n;
BOX *box, *boxe;
BOXA *boxa1, *boxa2;
PIX *pixs, *pixp, *pixpe;
PIX *pixd, *pixt1, *pixt2, *pixhmt;
SEL *sel_2h, *sel;
static char mainName[] = "findpattern1";
filein = "feyn.tif";
patternfile = "char.tif";
fileout = "result.findpattern1";
if ((pixs = pixRead(filein)) == NULL)
printf("pixs not made\n");
if ((pixp = pixRead(patternfile)) == NULL)
printf("pixp not made\n");
w = pixGetWidth(pixp);
h = pixGetHeight(pixp);
/* generate the hit-miss Sel with runs */
sel = pixGenerateSelWithRuns(pixp, NumHorLines, NumVertLines, 0,
MinRunlength, 7, 7, 0, 0, &pixpe);
/* display the Sel two ways */
selWriteStream(stderr, sel);
pixt1 = pixDisplayHitMissSel(pixpe, sel, 9, HitColor, MissColor);
pixDisplay(pixt1, 200, 200);
pixWrite("junkpixt", pixt1, IFF_PNG);
/* use the Sel to find all instances in the page */
startTimer();
pixhmt = pixHMT(NULL, pixs, sel);
fprintf(stderr, "Time to find patterns = %7.3f\n", stopTimer());
/* small erosion to remove noise; typically not necessary if
* there are enough elements in the Sel */
sel_2h = selCreateBrick(1, 2, 0, 0, SEL_HIT);
pixt2 = pixErode(NULL, pixhmt, sel_2h);
/* display the result visually by placing the Sel at each
* location found */
pixd = pixDilate(NULL, pixt2, sel);
pixWrite(fileout, pixd, IFF_TIFF_G4);
/* display outut with an outline around each located pattern */
boxa1 = pixConnCompBB(pixt2, 8);
n = boxaGetCount(boxa1);
boxa2 = boxaCreate(n);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa1, i, L_COPY);
boxe = boxCreate(box->x - w / 2, box->y - h / 2, w + 4, h + 4);
boxaAddBox(boxa2, boxe, L_INSERT);
pixRenderBox(pixs, boxe, 4, L_FLIP_PIXELS);
boxDestroy(&box);
}
pixWrite("junkoutline", pixs, IFF_TIFF_G4);
//boxaWriteStream(stderr, boxa2); //TODO ???
pixDestroy(&pixs);
pixDestroy(&pixp);
pixDestroy(&pixpe);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixhmt);
pixDestroy(&pixd);
selDestroy(&sel);
selDestroy(&sel_2h);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
printf("\n---\nEND\n");
getchar();
return 0;
}
l_int32 main(int argc,
char **argv)
{
l_int32 bx, by, bw, bh;
l_uint32 pixval;
BOX *box1, *box2;
BOXA *boxa;
PIX *pixs, *pixm, *pixd;
PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Find a mask for repainting pixels */
pixs = pixRead("amoris.2.150.jpg");
pix1 = MakeReplacementMask(pixs);
boxa = pixConnCompBB(pix1, 8);
box1 = boxaGetBox(boxa, 0, L_COPY);
boxaDestroy(&boxa);
/*--------------------------------------------------------*
* Show the individual steps *
*--------------------------------------------------------*/
/* Locate a good tile to use */
pixFindRepCloseTile(pixs, box1, L_VERT, 20, 30, 7, &box2, 1);
pix0 = pixCopy(NULL, pix1);
pixRenderBox(pix0, box2, 2, L_SET_PIXELS);
/* Make a patch using this tile */
boxGetGeometry(box1, &bx, &by, &bw, &bh);
pix2 = pixClipRectangle(pixs, box2, NULL);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 0 */
pixDisplayWithTitle(pix2, 400, 100, NULL, rp->display);
pix3 = pixMirroredTiling(pix2, bw, bh);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 1 */
pixDisplayWithTitle(pix3, 1000, 0, NULL, rp->display);
/* Paint the patch through the mask */
pixd = pixCopy(NULL, pixs);
pixm = pixClipRectangle(pix1, box1, NULL);
pixCombineMaskedGeneral(pixd, pix3, pixm, bx, by);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixd, 0, 0, NULL, rp->display);
boxDestroy(&box2);
pixDestroy(&pixm);
pixDestroy(&pixd);
pixDestroy(&pix2);
/* Blend two patches and then overlay. Use the previous
* tile found vertically and a new one found horizontally. */
pixFindRepCloseTile(pixs, box1, L_HORIZ, 20, 30, 7, &box2, 1);
pixRenderBox(pix0, box2, 2, L_SET_PIXELS);
regTestWritePixAndCheck(rp, pix0, IFF_TIFF_G4); /* 3 */
pixDisplayWithTitle(pix0, 100, 100, NULL, rp->display);
pix2 = pixClipRectangle(pixs, box2, NULL);
pix4 = pixMirroredTiling(pix2, bw, bh);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 1100, 0, NULL, rp->display);
pix5 = pixBlend(pix3, pix4, 0, 0, 0.5);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 5 */
pixDisplayWithTitle(pix5, 1200, 0, NULL, rp->display);
pix6 = pixClipRectangle(pix1, box1, NULL);
pixd = pixCopy(NULL, pixs);
pixCombineMaskedGeneral(pixd, pix5, pix6, bx, by);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 6 */
pixDisplayWithTitle(pixd, 700, 200, NULL, rp->display);
boxDestroy(&box2);
pixDestroy(&pixd);
pixDestroy(&pix0);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
/*--------------------------------------------------------*
* Show painting from a color near region *
*--------------------------------------------------------*/
pix2 = pixCopy(NULL, pixs);
pixGetColorNearMaskBoundary(pix2, pix1, box1, 20, &pixval, 0);
pix3 = pixClipRectangle(pix1, box1, NULL);
boxGetGeometry(box1, &bx, &by, NULL, NULL);
pixSetMaskedGeneral(pix2, pix3, pixval, bx, by);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix2, 0, 0, NULL, rp->display);
boxDestroy(&box1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/*--------------------------------------------------------*
* Use the higher-level function *
*--------------------------------------------------------*/
/* Use various tile selections and tile blending with one component */
pix2 = pixCopy(NULL, pixs);
pix3 = pixCopy(NULL, pixs);
pix4 = pixCopy(NULL, pixs);
pixPaintSelfThroughMask(pix2, pix1, 0, 0, L_HORIZ, 30, 50, 5, 10);
pixPaintSelfThroughMask(pix3, pix1, 0, 0, L_VERT, 30, 50, 5, 0);
pixPaintSelfThroughMask(pixs, pix1, 0, 0, L_BOTH_DIRECTIONS, 30, 50, 5, 20);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 8 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 9 */
regTestWritePixAndCheck(rp, pixs, IFF_PNG); /* 10 */
pixDisplayWithTitle(pix2, 300, 0, NULL, rp->display);
pixDisplayWithTitle(pix3, 500, 0, NULL, rp->display);
pixDisplayWithTitle(pixs, 700, 0, NULL, rp->display);
/* Test with two components; */
pix5 = pixFlipLR(NULL, pix1);
pixOr(pix5, pix5, pix1);
pixPaintSelfThroughMask(pix4, pix5, 0, 0, L_BOTH_DIRECTIONS, 50, 100, 5, 9);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 11 */
pixDisplayWithTitle(pix4, 900, 0, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 w, h, n, i, sum, sumi, empty;
BOX *box1, *box2, *box3, *box4;
BOXA *boxa, *boxat;
NUMA *na1, *na2, *na3, *na4, *na5;
NUMA *na2i, *na3i, *na4i, *nat, *naw, *nah;
PIX *pixs, *pixc, *pixt, *pixt2, *pixd, *pixcount;
PIXA *pixas, *pixad, *pixac;
pixDisplayWrite(NULL, -1);
/* Draw 4 filled boxes of different sizes */
pixs = pixCreate(200, 200, 1);
box1 = boxCreate(10, 10, 20, 30);
box2 = boxCreate(50, 10, 40, 20);
box3 = boxCreate(110, 10, 35, 5);
box4 = boxCreate(160, 10, 5, 15);
boxa = boxaCreate(4);
boxaAddBox(boxa, box1, L_INSERT);
boxaAddBox(boxa, box2, L_INSERT);
boxaAddBox(boxa, box3, L_INSERT);
boxaAddBox(boxa, box4, L_INSERT);
pixRenderBox(pixs, box1, 1, L_SET_PIXELS);
pixRenderBox(pixs, box2, 1, L_SET_PIXELS);
pixRenderBox(pixs, box3, 1, L_SET_PIXELS);
pixRenderBox(pixs, box4, 1, L_SET_PIXELS);
pixt = pixFillClosedBorders(pixs, 4);
pixDisplayWrite(pixt, 1);
pixt2 = pixCreateTemplate(pixs);
pixRenderHashBox(pixt2, box1, 6, 4, L_POS_SLOPE_LINE, 1, L_SET_PIXELS);
pixRenderHashBox(pixt2, box2, 7, 2, L_POS_SLOPE_LINE, 1, L_SET_PIXELS);
pixRenderHashBox(pixt2, box3, 4, 2, L_VERTICAL_LINE, 1, L_SET_PIXELS);
pixRenderHashBox(pixt2, box4, 3, 1, L_HORIZONTAL_LINE, 1, L_SET_PIXELS);
pixDisplayWrite(pixt2, 1);
/* Exercise the parameters */
pixd = pixSelectBySize(pixt, 0, 22, 8, L_SELECT_HEIGHT,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 0, 30, 8, L_SELECT_HEIGHT,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectBySize(pixt, 0, 5, 8, L_SELECT_HEIGHT,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectBySize(pixt, 0, 6, 8, L_SELECT_HEIGHT,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 20, 0, 8, L_SELECT_WIDTH,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 31, 0, 8, L_SELECT_WIDTH,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 21, 10, 8, L_SELECT_IF_EITHER,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectBySize(pixt, 20, 30, 8, L_SELECT_IF_EITHER,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 22, 32, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectBySize(pixt, 6, 32, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 5, 25, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectBySize(pixt, 25, 5, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GT, NULL);
count_pieces(pixd, 1);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.3, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.15, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.4, 8, L_SELECT_IF_LTE, NULL);
count_pieces(pixd, 2);
pixd = pixSelectByPerimToAreaRatio(pixt, 0.45, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByPerimSizeRatio(pixt2, 2.3, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
pixd = pixSelectByPerimSizeRatio(pixt2, 1.2, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByPerimSizeRatio(pixt2, 1.7, 8, L_SELECT_IF_LTE, NULL);
count_pieces(pixd, 1);
pixd = pixSelectByPerimSizeRatio(pixt2, 2.9, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByAreaFraction(pixt2, 0.3, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 0);
pixd = pixSelectByAreaFraction(pixt2, 0.9, 8, L_SELECT_IF_LT, NULL);
count_pieces(pixd, 4);
pixd = pixSelectByAreaFraction(pixt2, 0.5, 8, L_SELECT_IF_GTE, NULL);
count_pieces(pixd, 3);
pixd = pixSelectByAreaFraction(pixt2, 0.7, 8, L_SELECT_IF_GT, NULL);
count_pieces(pixd, 2);
boxat = boxaSelectBySize(boxa, 21, 10, L_SELECT_IF_EITHER,
L_SELECT_IF_LT, NULL);
count_pieces2(boxat, 3);
boxat = boxaSelectBySize(boxa, 22, 32, L_SELECT_IF_BOTH,
L_SELECT_IF_LT, NULL);
count_pieces2(boxat, 2);
boxaDestroy(&boxa);
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixs);
/* Here's the most general method for selecting components.
* We do it for area fraction, but any combination of
* size, area/perimeter ratio and area fraction can be used. */
pixs = pixRead("feyn.tif");
/* pixs = pixRead("rabi.png"); */
pixc = pixCopy(NULL, pixs); /* subtract bands from this */
pixt = pixCreateTemplate(pixs); /* add bands to this */
pixGetDimensions(pixs, &w, &h, NULL);
boxa = pixConnComp(pixs, &pixas, 8);
n = boxaGetCount(boxa);
fprintf(stderr, "total: %d\n", n);
na1 = pixaFindAreaFraction(pixas);
nat = numaCreate(0);
numaSetCount(nat, n); /* initialize to all 0 */
sum = sumi = 0;
pixac = pixaCreate(0);
for (i = 0; i < 12; i++) {
/* Compute within the intervals using an intersection. */
na2 = numaMakeThresholdIndicator(na1, edges[i], L_SELECT_IF_GTE);
if (i != 11)
na3 = numaMakeThresholdIndicator(na1, edges[i + 1], L_SELECT_IF_LT);
else
na3 = numaMakeThresholdIndicator(na1, edges[i + 1],
L_SELECT_IF_LTE);
na4 = numaLogicalOp(NULL, na2, na3, L_INTERSECTION);
sum += count_ones(na4, 0, 0, NULL);
/* Compute outside the intervals using a union, and invert */
na2i = numaMakeThresholdIndicator(na1, edges[i], L_SELECT_IF_LT);
if (i != 11)
na3i = numaMakeThresholdIndicator(na1, edges[i + 1],
L_SELECT_IF_GTE);
else
na3i = numaMakeThresholdIndicator(na1, edges[i + 1],
L_SELECT_IF_GT);
na4i = numaLogicalOp(NULL, na3i, na2i, L_UNION);
numaInvert(na4i, na4i);
sumi += count_ones(na4i, 0, 0, NULL);
/* Compare the two methods */
if (sum == sumi)
fprintf(stderr, "\nCorrect: sum = sumi = %d\n", sum);
else
fprintf(stderr, "\nWRONG: sum = %d, sumi = %d\n", sum, sumi);
/* Reconstruct the image, band by band. */
numaLogicalOp(nat, nat, na4, L_UNION);
pixad = pixaSelectWithIndicator(pixas, na4, NULL);
pixd = pixaDisplay(pixad, w, h);
pixOr(pixt, pixt, pixd); /* add them in */
pixcount = pixCopy(NULL, pixt); /* destroyed by count_pieces */
count_ones(na4, band[i], i, "band");
count_pieces(pixd, band[i]);
count_ones(nat, total[i], i, "total");
count_pieces(pixcount, total[i]);
pixaDestroy(&pixad);
/* Remove band successively from full image */
pixRemoveWithIndicator(pixc, pixas, na4);
pixSaveTiled(pixc, pixac, 0.25, 1 - i % 2, 25, 8);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
numaDestroy(&na2i);
numaDestroy(&na3i);
numaDestroy(&na4i);
}
/* Did we remove all components from pixc? */
pixZero(pixc, &empty);
if (!empty)
fprintf(stderr, "\nWRONG: not all pixels removed from pixc\n");
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pixt);
boxaDestroy(&boxa);
pixaDestroy(&pixas);
numaDestroy(&na1);
numaDestroy(&nat);
/* One last extraction. Get all components that have either
* a height of at least 50 or a width of between 30 and 35,
* and also have a relatively large perimeter/area ratio. */
pixs = pixRead("feyn.tif");
boxa = pixConnComp(pixs, &pixas, 8);
n = boxaGetCount(boxa);
pixaFindDimensions(pixas, &naw, &nah);
na1 = pixaFindPerimToAreaRatio(pixas);
na2 = numaMakeThresholdIndicator(nah, 50, L_SELECT_IF_GTE);
na3 = numaMakeThresholdIndicator(naw, 30, L_SELECT_IF_GTE);
na4 = numaMakeThresholdIndicator(naw, 35, L_SELECT_IF_LTE);
na5 = numaMakeThresholdIndicator(na1, 0.4, L_SELECT_IF_GTE);
numaLogicalOp(na3, na3, na4, L_INTERSECTION);
numaLogicalOp(na2, na2, na3, L_UNION);
numaLogicalOp(na2, na2, na5, L_INTERSECTION);
numaInvert(na2, na2); /* get components to be removed */
pixRemoveWithIndicator(pixs, pixas, na2);
pixSaveTiled(pixs, pixac, 0.25, 1, 25, 8);
pixDestroy(&pixs);
boxaDestroy(&boxa);
pixaDestroy(&pixas);
numaDestroy(&naw);
numaDestroy(&nah);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
numaDestroy(&na5);
pixDisplayMultiple("/tmp/display/file*");
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/comp.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
return 0;
}
