void
PixCompareDwa(L_REGPARAMS *rp,
l_int32 size,
const char *type,
PIX *pix1,
PIX *pix2,
PIX *pix3,
PIX *pix4,
PIX *pix5,
PIX *pix6)
{
l_int32 same;
pixEqual(pix1, pix2, &same);
regTestCompareValues(rp, TRUE, same, 0);
if (!same)
fprintf(stderr, "%s (%d, 1) not same\n", type, size);
pixEqual(pix3, pix4, &same);
regTestCompareValues(rp, TRUE, same, 0);
if (!same)
fprintf(stderr, "%s (1, %d) not same\n", type, size);
pixEqual(pix5, pix6, &same);
regTestCompareValues(rp, TRUE, same, 0);
if (!same)
fprintf(stderr, "%s (%d, %d) not same\n", type, size, size);
}
l_int32 main(int argc,
char **argv)
{
l_uint32 *colors;
l_int32 ncolors;
PIX *pix1, *pix2, *pix3;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Find the most populated colors */
pix1 = pixRead("fish24.jpg");
pixGetMostPopulatedColors(pix1, 2, 3, 10, &colors, NULL);
pix2 = pixDisplayColorArray(colors, 10, 190, 5, 1);
pixDisplayWithTitle(pix2, 0, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 0 */
lept_free(colors);
pixDestroy(&pix2);
/* Do a simple color quantization with sigbits = 2 */
pix2 = pixSimpleColorQuantize(pix1, 2, 3, 10);
pixDisplayWithTitle(pix2, 0, 400, NULL, rp->display);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
pix3 = pixRemoveColormap(pix2, REMOVE_CMAP_TO_FULL_COLOR);
regTestComparePix(rp, pix2, pix3); /* 2 */
pixNumColors(pix3, 1, &ncolors);
regTestCompareValues(rp, ncolors, 10, 0.0); /* 3 */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Do a simple color quantization with sigbits = 3 */
pix1 = pixRead("wyom.jpg");
pixNumColors(pix1, 1, &ncolors); /* >255, so should give 0 */
regTestCompareValues(rp, ncolors, 0, 0.0); /* 4 */
pix2 = pixSimpleColorQuantize(pix1, 3, 3, 20);
pixDisplayWithTitle(pix2, 1000, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 5 */
ncolors = pixcmapGetCount(pixGetColormap(pix2));
regTestCompareValues(rp, ncolors, 20, 0.0); /* 6 */
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Find the number of perceptually significant gray intensities */
pix1 = pixRead("marge.jpg");
pix2 = pixConvertTo8(pix1, 0);
pixNumSignificantGrayColors(pix2, 20, 236, 0.0001, 1, &ncolors);
regTestCompareValues(rp, ncolors, 219, 0.0); /* 7 */
pixDestroy(&pix1);
pixDestroy(&pix2);
return regTestCleanup(rp);
}
void DoWebpTest2(L_REGPARAMS *rp,
const char *fname,
l_int32 quality,
l_int32 lossless,
l_float32 expected,
l_float32 delta)
{
char buf[256];
l_float32 psnr;
PIX *pixs, *pix1;
pixs = pixRead(fname);
snprintf(buf, sizeof(buf), "/tmp/lept/webp/webpio.%d.webp", rp->index + 1);
if (lossless) startTimer();
pixWriteWebP("/tmp/lept/webp/junk.webp", pixs, quality, lossless);
if (lossless) fprintf(stderr, "Lossless write: %7.3f sec\n", stopTimer());
pix1 = pixRead("/tmp/lept/webp/junk.webp");
pixGetPSNR(pixs, pix1, 4, &psnr);
if (lossless)
fprintf(stderr, "lossless; psnr should be 1000: psnr = %7.3f\n", psnr);
else
fprintf(stderr, "qual = %d, psnr = %7.3f\n", quality, psnr);
regTestCompareValues(rp, expected, psnr, delta);
pixDestroy(&pixs);
pixDestroy(&pix1);
return;
}
static void
CompareResults(PIX *pixs,
PIX *pix1,
PIX *pix2,
l_int32 count1,
l_int32 count2,
const char *descr,
L_REGPARAMS *rp)
{
fprintf(stderr, "Compare set: %s; index starts at %d\n",
descr, rp->index + 1);
regTestComparePix(rp, pixs, pix1);
regTestComparePix(rp, pixs, pix2);
regTestCompareValues(rp, count1, count2, 1);
pixClearAll(pix1);
pixClearAll(pix2);
}
void DoWebpTest2(L_REGPARAMS *rp,
const char *fname,
l_int32 quality,
l_float32 expected,
l_float32 delta)
{
char buf[256];
l_float32 psnr;
PIX *pixs, *pix1;
pixs = pixRead(fname);
snprintf(buf, sizeof(buf), "/tmp/webpio.%d.webp", rp->index + 1);
pixWriteWebP("/tmp/junk.webp", pixs, quality);
pix1 = pixRead("/tmp/junk.webp");
pixGetPSNR(pixs, pix1, 4, &psnr);
fprintf(stderr, "qual = %d, psnr = %7.3f\n", quality, psnr);
regTestCompareValues(rp, expected, psnr, delta);
pixDestroy(&pixs);
pixDestroy(&pix1);
return;
}
PIX *
TestForRedColor(L_REGPARAMS *rp,
const char *fname,
l_float32 gold_red,
L_BMF *bmf)
{
char text[32];
PIX *pix1, *pix2;
l_int32 hasred;
l_float32 ratio;
pix1 = pixRead(fname);
pixHasHighlightRed(pix1, 1, 0.0001, 2.5, &hasred, &ratio, NULL);
regTestCompareValues(rp, gold_red, hasred, 0.0);
if (hasred)
snprintf(text, sizeof(text), "Has red: ratio = %6.1f", ratio);
else
snprintf(text, sizeof(text), "Does not have red: ratio = %6.1f", ratio);
pix2 = pixAddSingleTextblock(pix1, bmf, text, 0x0000ff00,
L_ADD_BELOW, NULL);
pixDestroy(&pix1);
return pix2;
}
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);
}
l_int32 main(int argc,
char **argv)
{
l_int32 ret, i, n, similar, x1, y1, val1, val2, val3, val4;
l_float32 minave, minave2, maxave, fract;
NUMA *na1, *na2, *na3, *na4, *na5, *na6;
NUMAA *naa;
PIX *pixs, *pix1, *pix2, *pix3, *pix4;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn.tif");
pix1 = pixScaleToGray6(pixs);
pixDisplayWithTitle(pix1, 100, 600, NULL, rp->display);
/* Find averages of min and max along about 120 horizontal lines */
fprintf(stderr, "Ignore the following 12 error messages:\n");
na1 = numaCreate(0);
na3 = numaCreate(0);
for (y1 = 40; y1 < 575; y1 += 5) {
ret = pixMinMaxNearLine(pix1, 20, y1, 400, y1, 5, L_SCAN_BOTH,
NULL, NULL, &minave, &maxave);
if (!ret) {
numaAddNumber(na1, (l_int32)minave);
numaAddNumber(na3, (l_int32)maxave);
if (rp->display)
fprintf(stderr, "y = %d: minave = %d, maxave = %d\n",
y1, (l_int32)minave, (l_int32)maxave);
}
}
/* Find averages along about 120 vertical lines. We've rotated
* the image by 90 degrees, so the results should be nearly
* identical to the first set. Also generate a single-sided
* scan (L_SCAN_NEGATIVE) for comparison with the double-sided scans. */
pix2 = pixRotateOrth(pix1, 3);
pixDisplayWithTitle(pix2, 600, 600, NULL, rp->display);
na2 = numaCreate(0);
na4 = numaCreate(0);
na5 = numaCreate(0);
for (x1 = 40; x1 < 575; x1 += 5) {
ret = pixMinMaxNearLine(pix2, x1, 20, x1, 400, 5, L_SCAN_BOTH,
NULL, NULL, &minave, &maxave);
pixMinMaxNearLine(pix2, x1, 20, x1, 400, 5, L_SCAN_NEGATIVE,
NULL, NULL, &minave2, NULL);
if (!ret) {
numaAddNumber(na2, (l_int32)minave);
numaAddNumber(na4, (l_int32)maxave);
numaAddNumber(na5, (l_int32)minave2);
if (rp->display)
fprintf(stderr,
"x = %d: minave = %d, minave2 = %d, maxave = %d\n",
x1, (l_int32)minave, (l_int32)minave2, (l_int32)maxave);
}
}
numaSimilar(na1, na2, 3.0, &similar); /* should be TRUE */
regTestCompareValues(rp, similar, 1, 0); /* 0 */
numaSimilar(na3, na4, 1.0, &similar); /* should be TRUE */
regTestCompareValues(rp, similar, 1, 0); /* 1 */
numaWrite("/tmp/lept/regout/na1.na", na1);
numaWrite("/tmp/lept/regout/na2.na", na2);
numaWrite("/tmp/lept/regout/na3.na", na3);
numaWrite("/tmp/lept/regout/na4.na", na4);
numaWrite("/tmp/lept/regout/na5.na", na5);
regTestCheckFile(rp, "/tmp/lept/regout/na1.na"); /* 2 */
regTestCheckFile(rp, "/tmp/lept/regout/na2.na"); /* 3 */
regTestCheckFile(rp, "/tmp/lept/regout/na3.na"); /* 4 */
regTestCheckFile(rp, "/tmp/lept/regout/na4.na"); /* 5 */
regTestCheckFile(rp, "/tmp/lept/regout/na5.na"); /* 6 */
/* Plot the average minimums for the 3 cases */
naa = numaaCreate(3);
numaaAddNuma(naa, na1, L_INSERT); /* portrait, double-sided */
numaaAddNuma(naa, na2, L_INSERT); /* landscape, double-sided */
numaaAddNuma(naa, na5, L_INSERT); /* landscape, single-sided */
gplotSimpleN(naa, GPLOT_PNG, "/tmp/lept/regout/nearline",
"Average minimums along lines");
#if 0
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
#endif
pix3 = pixRead("/tmp/lept/regout/nearline.png");
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix3, 100, 100, NULL, rp->display);
if (rp->display) {
n = numaGetCount(na3);
for (i = 0; i < n; i++) {
numaGetIValue(na1, i, &val1);
numaGetIValue(na2, i, &val2);
numaGetIValue(na3, i, &val3);
numaGetIValue(na4, i, &val4);
fprintf(stderr, "val1 = %d, val2 = %d, diff = %d; "
"val3 = %d, val4 = %d, diff = %d\n",
val1, val2, L_ABS(val1 - val2),
val3, val4, L_ABS(val3 - val4));
}
}
numaaDestroy(&naa);
numaDestroy(&na3);
numaDestroy(&na4);
/* Plot minima along a single line, with different distances */
pixMinMaxNearLine(pix1, 20, 200, 400, 200, 2, L_SCAN_BOTH,
&na1, NULL, NULL, NULL);
pixMinMaxNearLine(pix1, 20, 200, 400, 200, 5, L_SCAN_BOTH,
&na2, NULL, NULL, NULL);
pixMinMaxNearLine(pix1, 20, 200, 400, 200, 15, L_SCAN_BOTH,
&na3, NULL, NULL, NULL);
numaWrite("/tmp/lept/regout/na6.na", na1);
regTestCheckFile(rp, "/tmp/lept/regout/na6.na"); /* 8 */
n = numaGetCount(na1);
fract = 100.0 / n;
na4 = numaTransform(na1, 0.0, fract);
na5 = numaTransform(na2, 0.0, fract);
na6 = numaTransform(na3, 0.0, fract);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
na1 = numaUniformSampling(na4, 100);
na2 = numaUniformSampling(na5, 100);
na3 = numaUniformSampling(na6, 100);
naa = numaaCreate(3);
numaaAddNuma(naa, na1, L_INSERT);
numaaAddNuma(naa, na2, L_INSERT);
numaaAddNuma(naa, na3, L_INSERT);
gplotSimpleN(naa, GPLOT_PNG, "/tmp/lept/regout/nearline2",
"Min along line");
pix4 = pixRead("/tmp/lept/regout/nearline2.png");
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 9 */
pixDisplayWithTitle(pix4, 800, 100, NULL, rp->display);
numaaDestroy(&naa);
numaDestroy(&na4);
numaDestroy(&na5);
numaDestroy(&na6);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
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);
}
int main(int argc,
char **argv)
{
l_uint8 *array1, *array2;
l_int32 n1, n2, n3;
size_t size1, size2;
FILE *fp;
BOXA *boxa1, *boxa2;
PIX *pixs, *pix1;
PIXA *pixa1;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn.tif");
/* --------------------------------------------------------------- *
* Test pixConnComp() and pixCountConnComp(), *
* with output to both boxa and pixa *
* --------------------------------------------------------------- */
/* First, test with 4-cc */
boxa1= pixConnComp(pixs, &pixa1, 4);
n1 = boxaGetCount(boxa1);
boxa2= pixConnComp(pixs, NULL, 4);
n2 = boxaGetCount(boxa2);
pixCountConnComp(pixs, 4, &n3);
fprintf(stderr, "Number of 4 c.c.: n1 = %d; n2 = %d, n3 = %d\n",
n1, n2, n3);
regTestCompareValues(rp, n1, n2, 0); /* 0 */
regTestCompareValues(rp, n1, n3, 0); /* 1 */
regTestCompareValues(rp, n1, 4452, 0); /* 2 */
pix1 = pixaDisplay(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 3 */
regTestComparePix(rp, pixs, pix1); /* 4 */
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixDestroy(&pix1);
/* Test with 8-cc */
boxa1= pixConnComp(pixs, &pixa1, 8);
n1 = boxaGetCount(boxa1);
boxa2= pixConnComp(pixs, NULL, 8);
n2 = boxaGetCount(boxa2);
pixCountConnComp(pixs, 8, &n3);
fprintf(stderr, "Number of 8 c.c.: n1 = %d; n2 = %d, n3 = %d\n",
n1, n2, n3);
regTestCompareValues(rp, n1, n2, 0); /* 5 */
regTestCompareValues(rp, n1, n3, 0); /* 6 */
regTestCompareValues(rp, n1, 4305, 0); /* 7 */
pix1 = pixaDisplay(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8 */
regTestComparePix(rp, pixs, pix1); /* 9 */
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixDestroy(&pix1);
/* --------------------------------------------------------------- *
* Test boxa I/O *
* --------------------------------------------------------------- */
lept_mkdir("lept/conn");
boxa1 = pixConnComp(pixs, NULL, 4);
fp = lept_fopen("/tmp/lept/conn/boxa1.ba", "wb+");
boxaWriteStream(fp, boxa1);
lept_fclose(fp);
fp = lept_fopen("/tmp/lept/conn/boxa1.ba", "rb");
boxa2 = boxaReadStream(fp);
lept_fclose(fp);
fp = lept_fopen("/tmp/lept/conn/boxa2.ba", "wb+");
boxaWriteStream(fp, boxa2);
lept_fclose(fp);
array1 = l_binaryRead("/tmp/lept/conn/boxa1.ba", &size1);
array2 = l_binaryRead("/tmp/lept/conn/boxa2.ba", &size2);
regTestCompareStrings(rp, array1, size1, array2, size2); /* 10 */
lept_free(array1);
lept_free(array2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* --------------------------------------------------------------- *
* Just for fun, display each component as a random color in *
* cmapped 8 bpp. Background is color 0; it is set to white. *
* --------------------------------------------------------------- */
boxa1 = pixConnComp(pixs, &pixa1, 4);
pix1 = pixaDisplayRandomCmap(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
cmap = pixGetColormap(pix1);
pixcmapResetColor(cmap, 0, 255, 255, 255); /* reset background to white */
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 11 */
if (rp->display) pixDisplay(pix1, 100, 100);
boxaDestroy(&boxa1);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, j, w, h, same, width, height, cx, cy;
l_uint32 val;
BOX *box;
PIX *pix0, *pixs, *pixse, *pixd1, *pixd2;
SEL *sel;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pix0 = pixRead("feyn-fract.tif");
box = boxCreate(293, 37, pixGetWidth(pix0) - 691, pixGetHeight(pix0) -145);
pixs = pixClipRectangle(pix0, box, NULL);
boxDestroy(&box);
if (rp->display) pixDisplay(pixs, 100, 100);
/* Test 63 different sizes */
for (width = 1; width <= 25; width += 3) { /* 9 values */
for (height = 1; height <= 25; height += 4) { /* 7 values */
cx = width / 2;
cy = height / 2;
/* Dilate using an actual sel */
sel = selCreateBrick(height, width, cy, cx, SEL_HIT);
pixd1 = pixDilate(NULL, pixs, sel);
/* Dilate using a pix as a sel */
pixse = pixCreate(width, height, 1);
pixSetAll(pixse);
pixd2 = pixCopy(NULL, pixs);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
pixGetPixel(pixs, j, i, &val);
if (val)
pixRasterop(pixd2, j - cx, i - cy, width, height,
PIX_SRC | PIX_DST, pixse, 0, 0);
}
}
pixEqual(pixd1, pixd2, &same);
regTestCompareValues(rp, 1, same, 0.0); /* 0 - 62 */
if (same == 0) {
fprintf(stderr,
"Results differ for SE (width,height) = (%d,%d)\n",
width, height);
}
pixDestroy(&pixse);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
selDestroy(&sel);
}
}
pixDestroy(&pix0);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
void static
TestBoxa(L_REGPARAMS *rp,
l_int32 index)
{
l_uint8 *data;
l_int32 w, h, medw, medh, isame;
size_t size;
l_float32 scalefact, devw, devh, ratiowh, fvarp, fvarm;
BOXA *boxa1, *boxa2, *boxa3;
PIX *pix1;
boxa1 = boxaRead(boxafiles[index]);
/* Read and display initial boxa */
boxaGetExtent(boxa1, &w, &h, NULL);
scalefact = 100.0 / (l_float32)w;
boxa2 = boxaTransform(boxa1, 0, 0, scalefact, scalefact);
boxaWriteMem(&data, &size, boxa2);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 0, 13, 26 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa2, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 1, 14, 27 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
/* Find the median sizes */
boxaMedianDimensions(boxa2, &medw, &medh, NULL, NULL, NULL, NULL,
NULL, NULL);
if (rp->display)
fprintf(stderr, "median width = %d, median height = %d\n", medw, medh);
/* Check for deviations from median by pairs: method 1 */
boxaSizeConsistency1(boxa2, L_CHECK_HEIGHT, 0.0, 0.0,
&fvarp, &fvarm, &isame);
regTestCompareValues(rp, varp[index], fvarp, 0.003); /* 2, 15, 28 */
regTestCompareValues(rp, varm[index], fvarm, 0.003); /* 3, 16, 29 */
regTestCompareValues(rp, same[index], isame, 0); /* 4, 17, 30 */
if (rp->display)
fprintf(stderr, "fvarp = %7.4f, fvarm = %7.4f, same = %d\n",
fvarp, fvarm, isame);
/* Check for deviations from median by pairs: method 2 */
boxaSizeConsistency2(boxa2, &devw, &devh, 0);
regTestCompareValues(rp, devwidth[index], devw, 0.001); /* 5, 18, 31 */
regTestCompareValues(rp, devheight[index], devh, 0.001); /* 6, 19, 32 */
if (rp->display)
fprintf(stderr, "dev width = %7.4f, dev height = %7.4f\n", devw, devh);
/* Reconcile widths */
boxa3 = boxaReconcileSizeByMedian(boxa2, L_CHECK_WIDTH, 0.05, 0.04, 1.03,
NULL, NULL, &ratiowh);
boxaWriteMem(&data, &size, boxa3);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 7, 20, 33 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa3, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8, 21, 34 */
pixDisplayWithTitle(pix1, 500, 0, NULL, rp->display);
if (rp->display)
fprintf(stderr, "ratio median width/height = %6.3f\n", ratiowh);
boxaDestroy(&boxa3);
pixDestroy(&pix1);
/* Reconcile heights */
boxa3 = boxaReconcileSizeByMedian(boxa2, L_CHECK_HEIGHT, 0.05, 0.04, 1.03,
NULL, NULL, NULL);
boxaWriteMem(&data, &size, boxa3);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 9, 22, 35 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa3, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 10, 23, 36 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
boxaDestroy(&boxa3);
pixDestroy(&pix1);
/* Reconcile both widths and heights */
boxa3 = boxaReconcileSizeByMedian(boxa2, L_CHECK_BOTH, 0.05, 0.04, 1.03,
NULL, NULL, NULL);
boxaWriteMem(&data, &size, boxa3);
regTestWriteDataAndCheck(rp, data, size, "ba"); /* 11, 24, 37 */
lept_free(data);
pix1 = boxaDisplayTiled(boxa3, NULL, 0, -1, 2200, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12, 25, 38 */
pixDisplayWithTitle(pix1, 1500, 0, NULL, rp->display);
boxaDestroy(&boxa3);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
}
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);
}
void
DoWatershed(L_REGPARAMS *rp,
PIX *pixs)
{
l_uint8 *data;
size_t size;
l_int32 w, h, empty;
l_uint32 redval, greenval;
L_WSHED *wshed;
PIX *pixc, *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9;
PIXA *pixa;
PTA *pta;
/* Find local extrema */
pixa = pixaCreate(0);
pixGetDimensions(pixs, &w, &h, NULL);
regTestWritePixAndCheck(rp, pixs, IFF_PNG); /* 0 */
pixSaveTiled(pixs, pixa, 1.0, 1, 10, 32);
startTimer();
pixLocalExtrema(pixs, 0, 0, &pix1, &pix2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
pixSetOrClearBorder(pix1, 2, 2, 2, 2, PIX_CLR);
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixc = pixConvertTo32(pixs);
pixPaintThroughMask(pixc, pix2, 0, 0, greenval);
pixPaintThroughMask(pixc, pix1, 0, 0, redval);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 1 */
pixSaveTiled(pixc, pixa, 1.0, 0, 10, 32);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 2 */
pixSaveTiled(pix1, pixa, 1.0, 0, 10, 32);
/* Generate seeds for watershed */
pixSelectMinInConnComp(pixs, pix1, &pta, NULL);
pix3 = pixGenerateFromPta(pta, w, h);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
pixSaveTiled(pix3, pixa, 1.0, 1, 10, 32);
pix4 = pixConvertTo32(pixs);
pixPaintThroughMask(pix4, pix3, 0, 0, greenval);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixSaveTiled(pix4, pixa, 1.0, 0, 10, 32);
pix5 = pixRemoveSeededComponents(NULL, pix3, pix1, 8, 2);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 5 */
pixSaveTiled(pix5, pixa, 1.0, 0, 10, 32);
pixZero(pix5, &empty);
regTestCompareValues(rp, 1, empty, 0.0); /* 6 */
/* Make and display watershed */
wshed = wshedCreate(pixs, pix3, 10, 0);
startTimer();
wshedApply(wshed);
fprintf(stderr, "Time for wshed: %7.3f\n", stopTimer());
pix6 = pixaDisplayRandomCmap(wshed->pixad, w, h);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 7 */
pixSaveTiled(pix6, pixa, 1.0, 1, 10, 32);
numaWriteMem(&data, &size, wshed->nalevels);
regTestWriteDataAndCheck(rp, data, size, "na"); /* 8 */
pix7 = wshedRenderFill(wshed);
regTestWritePixAndCheck(rp, pix7, IFF_PNG); /* 9 */
pixSaveTiled(pix7, pixa, 1.0, 0, 10, 32);
pix8 = wshedRenderColors(wshed);
regTestWritePixAndCheck(rp, pix8, IFF_PNG); /* 10 */
pixSaveTiled(pix8, pixa, 1.0, 0, 10, 32);
wshedDestroy(&wshed);
pix9 = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pix9, IFF_PNG); /* 11 */
pixDisplayWithTitle(pix9, 100, 100, NULL, rp->display);
lept_free(data);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pix9);
pixDestroy(&pixc);
pixaDestroy(&pixa);
ptaDestroy(&pta);
}
l_int32 main(int argc,
char **argv)
{
l_int32 i, w, h, n, val, ne, no, nbins, minw, maxw, minh, maxh;
l_int32 mine, mino, maxe, maxo;
l_int32 w_diff, h_diff, median_w_diff, median_h_diff;
l_int32 noutw, nouth;
l_float32 medwe, medhe, medwo, medho;
BOXA *boxa1, *boxa2, *boxae, *boxao;
NUMA *na1, *nawe, *nahe, *nawo, *naho;
NUMA *nadiffw, *nadiffh; /* diff from median w and h */
NUMA *naiw, *naih; /* indicator arrays for small outlier dimensions */
NUMA *narbwe, *narbhe, *narbwo, *narbho; /* rank-binned w and h */
PIX *pix1;
PIXA *pixa1;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/boxa");
boxa1 = boxaRead("boxa4.ba");
/* Fill invalid boxes */
n = boxaGetCount(boxa1);
na1 = boxaFindInvalidBoxes(boxa1);
if (na1)
boxa2 = boxaFillSequence(boxa1, L_USE_SAME_PARITY_BOXES, 0);
else
boxa2 = boxaCopy(boxa1, L_CLONE);
boxaDestroy(&boxa1);
/* Get the widths and heights for even and odd parity */
boxaSplitEvenOdd(boxa2, 0, &boxae, &boxao);
boxaGetSizes(boxae, &nawe, &nahe);
boxaGetSizes(boxao, &nawo, &naho);
boxaDestroy(&boxa2);
/* Find the medians */
numaGetMedian(nawe, &medwe);
numaGetMedian(nahe, &medhe);
numaGetMedian(nawo, &medwo);
numaGetMedian(naho, &medho);
/* Find the median even/odd differences for width and height */
median_w_diff = L_ABS(medwe - medwo);
median_h_diff = L_ABS(medhe - medho);
regTestCompareValues(rp, 210, median_w_diff, 0.0); /* 0 */
regTestCompareValues(rp, 15, median_h_diff, 0.0); /* 1 */
if (rp->display) {
fprintf(stderr, "diff of e/o median widths = %d\n", median_w_diff);
fprintf(stderr, "diff of e/o median heights = %d\n", median_h_diff);
}
/* Find the differences of box width and height from the median */
nadiffw = numaMakeConstant(0, n);
nadiffh = numaMakeConstant(0, n);
ne = numaGetCount(nawe);
no = numaGetCount(nawo);
for (i = 0; i < ne; i++) {
numaGetIValue(nawe, i, &val);
numaSetValue(nadiffw, 2 * i, L_ABS(val - medwe));
numaGetIValue(nahe, i, &val);
numaSetValue(nadiffh, 2 * i, L_ABS(val - medhe));
}
for (i = 0; i < no; i++) {
numaGetIValue(nawo, i, &val);
numaSetValue(nadiffw, 2 * i + 1, L_ABS(val - medwo));
numaGetIValue(naho, i, &val);
numaSetValue(nadiffh, 2 * i + 1, L_ABS(val - medho));
}
/* Don't count invalid boxes; set the diffs to 0 for them */
if (na1) {
for (i = 0; i < n; i++) {
numaGetIValue(na1, i, &val);
if (val == 1) {
numaSetValue(nadiffw, i, 0);
numaSetValue(nadiffh, i, 0);
}
}
}
/* Make an indicator array for boxes that differ from the
* median by more than a threshold value for outliers */
naiw = numaMakeThresholdIndicator(nadiffw, 90, L_SELECT_IF_GT);
naih = numaMakeThresholdIndicator(nadiffh, 90, L_SELECT_IF_GT);
numaGetCountRelativeToZero(naiw, L_GREATER_THAN_ZERO, &noutw);
numaGetCountRelativeToZero(naih, L_GREATER_THAN_ZERO, &nouth);
regTestCompareValues(rp, 24, noutw, 0.0); /* 2 */
regTestCompareValues(rp, 0, nouth, 0.0); /* 3 */
if (rp->display)
fprintf(stderr, "num width outliers = %d, num height outliers = %d\n",
noutw, nouth);
numaDestroy(&nadiffw);
numaDestroy(&nadiffh);
numaDestroy(&naiw);
numaDestroy(&naih);
/* Find the rank bins for width and height */
nbins = L_MAX(5, ne / 50); // up to 50 pages/bin
numaGetRankBinValues(nawe, nbins, NULL, &narbwe);
numaGetRankBinValues(nawo, nbins, NULL, &narbwo);
numaGetRankBinValues(nahe, nbins, NULL, &narbhe);
numaGetRankBinValues(naho, nbins, NULL, &narbho);
numaDestroy(&nawe);
numaDestroy(&nawo);
numaDestroy(&nahe);
numaDestroy(&naho);
/* Find min and max binned widths and heights; get the max diffs */
numaGetIValue(narbwe, 0, &mine);
numaGetIValue(narbwe, nbins - 1, &maxe);
numaGetIValue(narbwo, 0, &mino);
numaGetIValue(narbwo, nbins - 1, &maxo);
minw = L_MIN(mine, mino);
maxw = L_MAX(maxe, maxo);
w_diff = maxw - minw;
numaGetIValue(narbhe, 0, &mine);
numaGetIValue(narbhe, nbins - 1, &maxe);
numaGetIValue(narbho, 0, &mino);
numaGetIValue(narbho, nbins - 1, &maxo);
minh = L_MIN(mine, mino);
maxh = L_MAX(maxe, maxo);
h_diff = maxh - minh;
numaDestroy(&narbwe);
numaDestroy(&narbhe);
numaDestroy(&narbwo);
numaDestroy(&narbho);
regTestCompareValues(rp, 409, w_diff, 0.0); /* 4 */
regTestCompareValues(rp, 49, h_diff, 0.0); /* 5 */
if (rp->display)
fprintf(stderr, "Binned rank results: w_diff = %d, h_diff = %d\n",
w_diff, h_diff);
/* Plot the results */
if (noutw > 0 || nouth > 0) {
pixa1 = pixaCreate(2);
boxaPlotSizes(boxae, "even", NULL, NULL, &pix1);
pixaAddPix(pixa1, pix1, L_INSERT);
boxaPlotSizes(boxao, "odd", NULL, NULL, &pix1);
pixaAddPix(pixa1, pix1, L_INSERT);
pix1 = pixaDisplayTiledInRows(pixa1, 32, 1500, 1.0, 0, 30, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 6 */
pixDisplayWithTitle(pix1, 100, 100, NULL, rp->display);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
}
boxaDestroy(&boxae);
boxaDestroy(&boxao);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
l_float32 dist, distr, distg, distb;
NUMA *na1, *na2;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Test earthmover distance: extreme DC */
fprintf(stderr, "Test earthmover distance\n");
na1 = numaMakeConstant(0, 201);
na2 = numaMakeConstant(0, 201);
numaSetValue(na1, 0, 100);
numaSetValue(na2, 200, 100);
numaEarthMoverDistance(na1, na2, &dist);
regTestCompareValues(rp, 200.0, dist, 0.0001); /* 0 */
numaDestroy(&na1);
numaDestroy(&na2);
/* Test connected component labelling */
fprintf(stderr, "Test c.c. labelling\n");
pix1 = pixRead("feyn-fract.tif");
pix2 = pixConnCompTransform(pix1, 8, 8);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
pixDisplayWithTitle(pix2, 0, 0, NULL, rp->display);
pix3 = pixConnCompTransform(pix1, 8, 16);
pix4 = pixConvert16To8(pix3, L_LS_BYTE);
regTestCompareSimilarPix(rp, pix2, pix4, 3, 0.001, 0); /* 2 */
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Test connected component area labelling */
fprintf(stderr, "Test c.c. area labelling\n");
pix2 = pixConnCompAreaTransform(pix1, 8);
pix3 = pixConvert16To8(pix2, L_CLIP_TO_255);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
pixDisplayWithTitle(pix3, 0, 350, NULL, rp->display);
pixMultConstantGray(pix2, 0.3);
pix4 = pixConvert16To8(pix2, L_LS_BYTE);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 0, 700, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Test color transform: 4-fold symmetry */
fprintf(stderr, "Test color transform: 4-fold symmetry\n");
pix1 = pixRead("form1.tif");
pix2 = pixRotateOrth(pix1, 1);
pix3 = pixRotateOrth(pix1, 2);
pix4 = pixRotateOrth(pix1, 3);
pix5 = pixLocToColorTransform(pix1);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 5 */
pix6 = pixLocToColorTransform(pix2);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 6 */
FindEMD(pix5, pix6, &distr, &distg, &distb);
regTestCompareValues(rp, 0.12, distr, 0.01); /* 7 */
regTestCompareValues(rp, 0.00, distg, 0.01); /* 8 */
regTestCompareValues(rp, 0.00, distb, 0.01); /* 9 */
fprintf(stderr, "90 deg rotation: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix6);
pix6 = pixLocToColorTransform(pix3);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 10 */
FindEMD(pix5, pix6, &distr, &distg, &distb);
regTestCompareValues(rp, 0.12, distr, 0.01); /* 11 */
regTestCompareValues(rp, 0.09, distg, 0.01); /* 12 */
regTestCompareValues(rp, 0.00, distb, 0.01); /* 13 */
fprintf(stderr, "180 deg rotation: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix6);
pix6 = pixLocToColorTransform(pix4);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 14 */
FindEMD(pix5, pix6, &distr, &distg, &distb);
regTestCompareValues(rp, 0.00, distr, 0.01); /* 15 */
regTestCompareValues(rp, 0.09, distg, 0.01); /* 16 */
regTestCompareValues(rp, 0.00, distb, 0.01); /* 17 */
fprintf(stderr, "270 deg rotation: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
/* Test color transform: same form with translation */
fprintf(stderr, "Test color transform with translation\n");
pix1 = pixRead("form1.tif");
pix2 = pixLocToColorTransform(pix1);
pixDisplayWithTitle(pix2, 0, 0, NULL, rp->display);
pixTranslate(pix1, pix1, 10, 10, L_BRING_IN_WHITE);
pix3 = pixLocToColorTransform(pix1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 18 */
pixDisplayWithTitle(pix3, 470, 0, NULL, rp->display);
FindEMD(pix2, pix3, &distr, &distg, &distb);
regTestCompareValues(rp, 1.76, distr, 0.01); /* 19 */
regTestCompareValues(rp, 2.65, distg, 0.01); /* 20 */
regTestCompareValues(rp, 2.03, distb, 0.01); /* 21 */
fprintf(stderr, "Translation dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Test color transform: same form with small rotation */
fprintf(stderr, "Test color transform with small rotation\n");
pix1 = pixRead("form1.tif");
pix2 = pixLocToColorTransform(pix1);
pixRotateShearCenterIP(pix1, 0.1, L_BRING_IN_WHITE);
pix3 = pixLocToColorTransform(pix1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 22 */
pixDisplayWithTitle(pix3, 880, 0, NULL, rp->display);
FindEMD(pix2, pix3, &distr, &distg, &distb);
regTestCompareValues(rp, 1.50, distr, 0.01); /* 23 */
regTestCompareValues(rp, 1.71, distg, 0.01); /* 24 */
regTestCompareValues(rp, 1.42, distb, 0.01); /* 25 */
fprintf(stderr, "Rotation dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Test color transform: 2 different forms */
fprintf(stderr, "Test color transform (2 forms)\n");
pix1 = pixRead("form1.tif");
pix2 = pixLocToColorTransform(pix1);
pixDisplayWithTitle(pix2, 0, 600, NULL, rp->display);
pix3 = pixRead("form2.tif");
pix4 = pixLocToColorTransform(pix3);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 25 */
pixDisplayWithTitle(pix4, 470, 600, NULL, rp->display);
FindEMD(pix2, pix4, &distr, &distg, &distb);
regTestCompareValues(rp, 6.10, distr, 0.02); /* 27 */
regTestCompareValues(rp, 11.13, distg, 0.01); /* 28 */
regTestCompareValues(rp, 10.53, distb, 0.01); /* 29 */
fprintf(stderr, "Different forms: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
return regTestCleanup(rp);
}
void TestLeptCpRm(L_REGPARAMS *rp,
const char *srctail,
const char *newdir,
const char *newtail)
{
char realnewdir[256], newnewdir[256];
char *realtail, *newsrc, *fname;
l_int32 nfiles1, nfiles2, nfiles3;
SARRAY *sa;
/* Remove old version if it exists */
realtail = (newtail) ? stringNew(newtail) : stringNew(srctail);
lept_rm(newdir, realtail);
makeTempDirname(realnewdir, 256, newdir);
if (rp->display) {
fprintf(stderr, "\nInput: srctail = %s, newdir = %s, newtail = %s\n",
srctail, newdir, newtail);
fprintf(stderr, " realnewdir = %s, realtail = %s\n",
realnewdir, realtail);
}
sa = getFilenamesInDirectory(realnewdir);
nfiles1 = sarrayGetCount(sa);
sarrayDestroy(&sa);
/* Copy */
lept_cp(srctail, newdir, newtail, &fname);
sa = getFilenamesInDirectory(realnewdir);
nfiles2 = sarrayGetCount(sa);
if (rp->display) {
fprintf(stderr, " File copied to directory: %s\n", realnewdir);
fprintf(stderr, " ... with this filename: %s\n", fname);
fprintf(stderr, " delta files should be 1: %d\n", nfiles2 - nfiles1);
}
regTestCompareValues(rp, 1, nfiles2 - nfiles1, 0.0); /* '1' */
sarrayDestroy(&sa);
lept_free(fname);
/* Remove it */
lept_rm(newdir, realtail);
sa = getFilenamesInDirectory(realnewdir);
nfiles2 = sarrayGetCount(sa);
if (rp->display) {
fprintf(stderr, " File removed from directory: %s\n", realnewdir);
fprintf(stderr, " delta files should be 0: %d\n", nfiles2 - nfiles1);
}
regTestCompareValues(rp, 0, nfiles2 - nfiles1, 0.0); /* '2' */
sarrayDestroy(&sa);
/* Copy it again ... */
lept_cp(srctail, newdir, newtail, &fname);
if (rp->display)
fprintf(stderr, " File copied to: %s\n", fname);
/* move it elsewhere ... */
lept_rmdir("junko"); /* clear out this directory */
lept_mkdir("junko");
newsrc = pathJoin(realnewdir, realtail);
lept_mv(newsrc, "junko", NULL, &fname);
if (rp->display) {
fprintf(stderr, " Move file at: %s\n", newsrc);
fprintf(stderr, " ... to: %s\n", fname);
}
lept_free(fname);
lept_free(newsrc);
makeTempDirname(newnewdir, 256, "junko");
if (rp->display) fprintf(stderr, " In this directory: %s\n", newnewdir);
sa = getFilenamesInDirectory(newnewdir); /* check if it landed ok */
nfiles3 = sarrayGetCount(sa);
if (rp->display) fprintf(stderr, " num files should be 1: %d\n", nfiles3);
regTestCompareValues(rp, 1, nfiles3, 0.0); /* '3' */
sarrayDestroy(&sa);
/* and verify it was removed from the original location */
sa = getFilenamesInDirectory(realnewdir); /* check if it was removed */
nfiles2 = sarrayGetCount(sa);
if (rp->display) {
fprintf(stderr, " In this directory: %s\n", realnewdir);
fprintf(stderr, " delta files should be 0: %d\n", nfiles2 - nfiles1);
}
regTestCompareValues(rp, 0, nfiles2 - nfiles1, 0.0); /* '4' */
sarrayDestroy(&sa);
lept_free(realtail);
}
l_int32 main(int argc,
char **argv)
{
l_int32 exists;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
fprintf(stderr, " ===================================================\n");
fprintf(stderr, " =================== Test pathJoin() ===============\n");
fprintf(stderr, " ===================================================\n");
TestPathJoin(rp, "/a/b//c///d//", "//e//f//g//", "/a/b/c/d/e/f/g"); /* 0 */
TestPathJoin(rp, "/tmp/", "junk//", "/tmp/junk"); /* 1 */
TestPathJoin(rp, "//tmp/", "junk//", "/tmp/junk"); /* 2 */
TestPathJoin(rp, "tmp/", "//junk//", "tmp/junk"); /* 3 */
TestPathJoin(rp, "tmp/", "junk/////", "tmp/junk"); /* 4 */
TestPathJoin(rp, "/tmp/", "///", "/tmp"); /* 5 */
TestPathJoin(rp, "////", NULL, "/"); /* 6 */
TestPathJoin(rp, "//", "/junk//", "/junk"); /* 7 */
TestPathJoin(rp, NULL, "/junk//", "/junk"); /* 8 */
TestPathJoin(rp, NULL, "//junk//", "/junk"); /* 9 */
TestPathJoin(rp, NULL, "junk//", "junk"); /* 10 */
TestPathJoin(rp, NULL, "//", "/"); /* 11 */
TestPathJoin(rp, NULL, NULL, ""); /* 12 */
TestPathJoin(rp, "", "", ""); /* 13 */
TestPathJoin(rp, "/", "", "/"); /* 14 */
TestPathJoin(rp, "", "//", "/"); /* 15 */
TestPathJoin(rp, "", "a", "a"); /* 16 */
fprintf(stderr, "The next 3 joins properly give error messages:\n");
fprintf(stderr, "join: .. + a --> NULL\n");
pathJoin("..", "a"); /* returns NULL */
fprintf(stderr, "join: %s + .. --> NULL\n", "/tmp");
pathJoin("/tmp", ".."); /* returns NULL */
fprintf(stderr, "join: ./ + .. --> NULL\n");
pathJoin("./", ".."); /* returns NULL */
fprintf(stderr, "\n ===================================================\n");
fprintf(stderr, " ======= Test lept_rmdir() and lept_mkdir()) =======\n");
fprintf(stderr, " ===================================================\n");
lept_rmdir("junkfiles");
lept_direxists("/tmp/junkfiles", &exists);
if (rp->display) fprintf(stderr, "directory removed?: %d\n", !exists);
regTestCompareValues(rp, 0, exists, 0.0); /* 17 */
lept_mkdir("junkfiles");
lept_direxists("/tmp/junkfiles", &exists);
if (rp->display) fprintf(stderr, "directory made?: %d\n", exists);
regTestCompareValues(rp, 1, exists, 0.0); /* 18 */
fprintf(stderr, "\n ===================================================\n");
fprintf(stderr, " ======= Test lept_mv(), lept_cp(), lept_rm() ======\n");
fprintf(stderr, " ===================================================");
TestLeptCpRm(rp, "weasel2.png", NULL, NULL); /* 19 - 22 */
TestLeptCpRm(rp, "weasel2.png", "junkfiles", NULL); /* 23 - 26 */
TestLeptCpRm(rp, "weasel2.png", NULL, "new_weasel2.png"); /* 27 - 30 */
TestLeptCpRm(rp, "weasel2.png", "junkfiles", "new_weasel2.png"); /* 31-34 */
fprintf(stderr, "\n ===================================================\n");
fprintf(stderr, " =============== Test genPathname() ================\n");
fprintf(stderr, " ===================================================\n");
TestGenPathname(rp, "what/", NULL, "what"); /* 35 */
TestGenPathname(rp, "what", "abc", "what/abc"); /* 36 */
TestGenPathname(rp, NULL, "abc/def", "abc/def"); /* 37 */
TestGenPathname(rp, "", "abc/def", "abc/def"); /* 38 */
#ifndef _WIN32 /* unix only */
TestGenPathname(rp, "/tmp", NULL, "/tmp"); /* 39 */
TestGenPathname(rp, "/tmp/", NULL, "/tmp"); /* 40 */
TestGenPathname(rp, "/tmp/junk", NULL, "/tmp/junk"); /* 41 */
TestGenPathname(rp, "/tmp/junk/abc", NULL, "/tmp/junk/abc"); /* 42 */
TestGenPathname(rp, "/tmp/junk/", NULL, "/tmp/junk"); /* 43 */
TestGenPathname(rp, "/tmp/junk", "abc", "/tmp/junk/abc"); /* 44 */
#endif /* !_WIN32 */
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 1 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 2 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 3 */
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 4 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 5 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 6 */
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix1, 200, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
regTestCompareValues(rp, 1, same, 0.0); /* 8 */
regTestCompareValues(rp, 0.053, diffarea, 0.002); /* 9 */
regTestCompareValues(rp, 0.240, diffxor, 0.002); /* 10 */
regTestWritePixAndCheck(rp, pixdb, IFF_PNG); /* 11 */
pixDisplayWithTitle(pixdb, 400, 0, NULL, rp->display);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix1, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
regTestCompareValues(rp, 1, same, 0.0); /* 15 */
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* ----------- Test pixaDisplayBoxaa() ------------ */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
/* Check that the transpose is reversible */
regTestCompareValues(rp, 1, success, 0.0); /* 16 */
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 17 */
pixDisplayWithTitle(pix1, 0, 600, NULL, rp->display);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
l_pdfSetDateAndVersion(FALSE);
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
regTestCheckFile(rp, "/tmp/lept/boxa/show.pdf"); /* 18 */
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *data;
l_int32 w, h, n1, n2, n, i, minval, maxval;
l_int32 ncolors, rval, gval, bval, equal;
l_int32 *rmap, *gmap, *bmap;
l_uint32 color;
l_float32 gamma;
BOX *box;
FILE *fp;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixb, *pixg, *pixc, *pixd;
PIX *pixg2, *pixcs1, *pixcs2, *pixd1, *pixd2;
PIXA *pixa, *pixa2, *pixa3;
PIXCMAP *cmap, *cmap2;
RGBA_QUAD *cta;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------------------ (1) ----------------------------*/
/* Blend with a white background */
pix1 = pixRead("books_logo.png");
pixDisplayWithTitle(pix1, 100, 0, NULL, rp->display);
pix2 = pixAlphaBlendUniform(pix1, 0xffffff00);
pixDisplayWithTitle(pix2, 100, 150, NULL, rp->display);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
/* Generate an alpha layer based on the white background */
pix3 = pixSetAlphaOverWhite(pix2);
pixSetSpp(pix3, 3);
pixWrite("/tmp/alphaops.2.png", pix3, IFF_PNG); /* without alpha */
regTestCheckFile(rp, "/tmp/alphaops.2.png"); /* 2 */
pixSetSpp(pix3, 4);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3, with alpha */
pixDisplayWithTitle(pix3, 100, 300, NULL, rp->display);
/* Render on a light yellow background */
pix4 = pixAlphaBlendUniform(pix3, 0xffffe000);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 100, 450, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* ------------------------ (2) ----------------------------*/
lept_rmdir("alpha");
lept_mkdir("alpha");
/* Make the transparency (alpha) layer.
* pixs is the mask. We turn it into a transparency (alpha)
* layer by converting to 8 bpp. A small convolution fuzzes
* the mask edges so that you don't see the pixels. */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
pixg = pixConvert1To8(NULL, pixs, 0, 255);
pixg2 = pixBlockconvGray(pixg, NULL, 1, 1);
regTestWritePixAndCheck(rp, pixg2, IFF_JFIF_JPEG); /* 5 */
pixDisplayWithTitle(pixg2, 0, 0, "alpha", rp->display);
/* Make the viewable image.
* pixc is the image that we see where the alpha layer is
* opaque -- i.e., greater than 0. Scale it to the same
* size as the mask. To visualize what this will look like
* when displayed over a black background, create the black
* background image, pixb, and do the blending with pixcs1
* explicitly using the alpha layer pixg2. */
pixc = pixRead("tetons.jpg");
pixcs1 = pixScaleToSize(pixc, w, h);
regTestWritePixAndCheck(rp, pixcs1, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixcs1, 300, 0, "viewable", rp->display);
pixb = pixCreateTemplate(pixcs1); /* black */
pixd1 = pixBlendWithGrayMask(pixb, pixcs1, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd1, IFF_JFIF_JPEG); /* 7 */
pixDisplayWithTitle(pixd1, 600, 0, "alpha-blended 1", rp->display);
/* Embed the alpha layer pixg2 into the color image pixc.
* Write it out as is. Then clean pixcs1 (to 0) under the fully
* transparent part of the alpha layer, and write that result
* out as well. */
pixSetRGBComponent(pixcs1, pixg2, L_ALPHA_CHANNEL);
pixWrite("/tmp/alpha/pixcs1.png", pixcs1, IFF_PNG);
pixcs2 = pixSetUnderTransparency(pixcs1, 0, 0);
pixWrite("/tmp/alpha/pixcs2.png", pixcs2, IFF_PNG);
/* What will this look like over a black background?
* Do the blending explicitly and display. It should
* look identical to the blended result pixd1 before cleaning. */
pixd2 = pixBlendWithGrayMask(pixb, pixcs2, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd2, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd2, 0, 400, "alpha blended 2", rp->display);
/* Read the two images back, ignoring the transparency layer.
* The uncleaned image will come back identical to pixcs1.
* However, the cleaned image will be black wherever
* the alpha layer was fully transparent. It will
* look the same when viewed through the alpha layer,
* but have much better compression. */
pix1 = pixRead("/tmp/alpha/pixcs1.png"); /* just pixcs1 */
pix2 = pixRead("/tmp/alpha/pixcs2.png"); /* cleaned under transparent */
n1 = nbytesInFile("/tmp/alpha/pixcs1.png");
n2 = nbytesInFile("/tmp/alpha/pixcs2.png");
fprintf(stderr, " Original: %d bytes\n Cleaned: %d bytes\n", n1, n2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 9 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 10 */
pixDisplayWithTitle(pix1, 300, 400, "without alpha", rp->display);
pixDisplayWithTitle(pix2, 600, 400, "cleaned under transparent",
rp->display);
pixa = pixaCreate(0);
pixSaveTiled(pixg2, pixa, 1.0, 1, 20, 32);
pixSaveTiled(pixcs1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pix1, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pixd1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pixd2, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pix2, pixa, 1.0, 1, 20, 0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 200, 200, "composite", rp->display);
pixWrite("/tmp/alpha/alpha.png", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixg);
pixDestroy(&pixg2);
pixDestroy(&pixc);
pixDestroy(&pixcs1);
pixDestroy(&pixcs2);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------------------ (3) ----------------------------*/
color = 0xffffa000;
gamma = 1.0;
minval = 0;
maxval = 200;
box = boxCreate(0, 85, 600, 100);
pixa = pixaCreate(6);
pix1 = pixRead("blend-green1.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green2.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green3.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-orange.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-yellow.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-red.png");
pixaAddPix(pixa, pix1, L_INSERT);
n = pixaGetCount(pixa);
pixa2 = pixaCreate(n);
pixa3 = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 1);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 12, 14, ... 22 */
pixDisplayWithTitle(pix2, 150 * i, 0, NULL, rp->display);
pixaAddPix(pixa2, pix2, L_INSERT);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 2);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 13, 15, ... 23 */
pixDisplayWithTitle(pix2, 150 * i, 200, NULL, rp->display);
pixaAddPix(pixa3, pix2, L_INSERT);
pixDestroy(&pix1);
}
if (rp->display) {
pixaConvertToPdf(pixa2, 0, 0.75, L_FLATE_ENCODE, 0, "blend 1 test",
"/tmp/alpha/blending1.pdf");
pixaConvertToPdf(pixa3, 0, 0.75, L_FLATE_ENCODE, 0, "blend 2 test",
"/tmp/alpha/blending2.pdf");
}
pixaDestroy(&pixa);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
boxDestroy(&box);
/* ------------------------ (4) ----------------------------*/
/* Use one image as the alpha component for a second image */
pix1 = pixRead("test24.jpg");
pix2 = pixRead("marge.jpg");
pix3 = pixScale(pix2, 1.9, 2.2);
pix4 = pixConvertTo8(pix3, 0);
pixSetRGBComponent(pix1, pix4, L_ALPHA_CHANNEL);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 24 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
/* Set the alpha value in a colormap to bval */
pix5 = pixOctreeColorQuant(pix1, 128, 0);
cmap = pixGetColormap(pix5);
pixcmapToArrays(cmap, &rmap, &gmap, &bmap, NULL);
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
cta = (RGBA_QUAD *)cmap->array;
cta[i].alpha = bval;
}
/* Test binary serialization/deserialization of colormap with alpha */
pixcmapSerializeToMemory(cmap, 4, &ncolors, &data);
cmap2 = pixcmapDeserializeFromMemory(data, 4, ncolors);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 25 */
pixcmapDestroy(&cmap2);
lept_free(data);
/* Test ascii serialization/deserialization of colormap with alpha */
fp = fopenWriteStream("/tmp/alpha/cmap.4", "w");
pixcmapWriteStream(fp, cmap);
fclose(fp);
fp = fopenReadStream("/tmp/alpha/cmap.4");
cmap2 = pixcmapReadStream(fp);
fclose(fp);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 26 */
pixcmapDestroy(&cmap2);
/* Test r/w for cmapped pix with non-opaque alpha */
pixDisplayWithTitle(pix5, 900, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 27 */
pixWrite("/tmp/alpha/fourcomp.png", pix5, IFF_PNG);
pix6 = pixRead("/tmp/alpha/fourcomp.png");
regTestComparePix(rp, pix5, pix6); /* 28 */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
lept_free(rmap);
lept_free(gmap);
lept_free(bmap);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 i, nbins, ival;
l_float64 pi, angle, val, sum;
L_DNA *da1, *da2, *da3, *da4, *da5;
L_DNAA *daa1, *daa2;
GPLOT *gplot;
NUMA *na, *nahisto, *nax;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pi = 3.1415926535;
da1 = l_dnaCreate(50);
for (i = 0; i < 5000; i++) {
angle = 0.02293 * i * pi;
val = 999. * sin(angle);
l_dnaAddNumber(da1, val);
}
/* Conversion to Numa; I/O for Dna */
na = l_dnaConvertToNuma(da1);
da2 = numaConvertToDna(na);
l_dnaWrite("/tmp/dna1.da", da1);
l_dnaWrite("/tmp/dna2.da", da2);
da3 = l_dnaRead("/tmp/dna2.da");
l_dnaWrite("/tmp/dna3.da", da3);
regTestCheckFile(rp, "/tmp/dna1.da"); /* 0 */
regTestCheckFile(rp, "/tmp/dna2.da"); /* 1 */
regTestCheckFile(rp, "/tmp/dna3.da"); /* 2 */
regTestCompareFiles(rp, 1, 2); /* 3 */
/* I/O for Dnaa */
daa1 = l_dnaaCreate(3);
l_dnaaAddDna(daa1, da1, L_INSERT);
l_dnaaAddDna(daa1, da2, L_INSERT);
l_dnaaAddDna(daa1, da3, L_INSERT);
l_dnaaWrite("/tmp/dnaa1.daa", daa1);
daa2 = l_dnaaRead("/tmp/dnaa1.daa");
l_dnaaWrite("/tmp/dnaa2.daa", daa2);
regTestCheckFile(rp, "/tmp/dnaa1.daa"); /* 4 */
regTestCheckFile(rp, "/tmp/dnaa2.daa"); /* 5 */
regTestCompareFiles(rp, 4, 5); /* 6 */
l_dnaaDestroy(&daa1);
l_dnaaDestroy(&daa2);
/* Just for fun -- is the numa ok? */
nahisto = numaMakeHistogramClipped(na, 12, 2000);
nbins = numaGetCount(nahisto);
nax = numaMakeSequence(0, 1, nbins);
gplot = gplotCreate("/tmp/historoot", GPLOT_PNG, "Histo example",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
regTestCheckFile(rp, "/tmp/historoot.png"); /* 7 */
gplotDestroy(&gplot);
numaDestroy(&na);
numaDestroy(&nax);
numaDestroy(&nahisto);
/* Handling precision of int32 in double */
da4 = l_dnaCreate(25);
for (i = 0; i < 1000; i++)
l_dnaAddNumber(da4, 1928374 * i);
l_dnaWrite("/tmp/dna4.da", da4);
da5 = l_dnaRead("/tmp/dna4.da");
sum = 0;
for (i = 0; i < 1000; i++) {
l_dnaGetIValue(da5, i, &ival);
sum += L_ABS(ival - i * 1928374); /* we better be adding 0 each time */
}
regTestCompareValues(rp, sum, 0.0, 0.0); /* 8 */
l_dnaDestroy(&da4);
l_dnaDestroy(&da5);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, n, binsize, binstart, nbins;
l_float32 pi, val, angle, xval, yval, x0, y0, startval, fbinsize;
l_float32 minval, maxval, meanval, median, variance, rankval, rank, rmsdev;
GPLOT *gplot;
NUMA *na, *nahisto, *nax, *nay, *nap, *nasx, *nasy;
NUMA *nadx, *nady, *nafx, *nafy, *na1, *na2, *na3, *na4;
PIX *pixs, *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/numa1");
/* -------------------------------------------------------------------*
* Histograms *
* -------------------------------------------------------------------*/
pi = 3.1415926535;
na = numaCreate(5000);
for (i = 0; i < 500000; i++) {
angle = 0.02293 * i * pi;
val = (l_float32)(999. * sin(angle));
numaAddNumber(na, val);
}
nahisto = numaMakeHistogramClipped(na, 6, 2000);
nbins = numaGetCount(nahisto);
nax = numaMakeSequence(0, 1, nbins);
gplot = gplotCreate("/tmp/lept/numa1/histo1", GPLOT_PNG, "example histo 1",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
numaDestroy(&nahisto);
nahisto = numaMakeHistogram(na, 1000, &binsize, &binstart);
nbins = numaGetCount(nahisto);
nax = numaMakeSequence(binstart, binsize, nbins);
fprintf(stderr, " binsize = %d, binstart = %d\n", binsize, binstart);
gplot = gplotCreate("/tmp/lept/numa1/histo2", GPLOT_PNG, "example histo 2",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
numaDestroy(&nahisto);
nahisto = numaMakeHistogram(na, 1000, &binsize, NULL);
nbins = numaGetCount(nahisto);
nax = numaMakeSequence(0, binsize, nbins);
fprintf(stderr, " binsize = %d, binstart = %d\n", binsize, 0);
gplot = gplotCreate("/tmp/lept/numa1/histo3", GPLOT_PNG, "example histo 3",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
numaDestroy(&nahisto);
nahisto = numaMakeHistogramAuto(na, 1000);
nbins = numaGetCount(nahisto);
numaGetParameters(nahisto, &startval, &fbinsize);
nax = numaMakeSequence(startval, fbinsize, nbins);
fprintf(stderr, " binsize = %7.4f, binstart = %8.3f\n",
fbinsize, startval);
gplot = gplotCreate("/tmp/lept/numa1/histo4", GPLOT_PNG, "example histo 4",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
pix1 = pixRead("/tmp/lept/numa1/histo1.png");
pix2 = pixRead("/tmp/lept/numa1/histo2.png");
pix3 = pixRead("/tmp/lept/numa1/histo3.png");
pix4 = pixRead("/tmp/lept/numa1/histo4.png");
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 2 */
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 3 */
pixa = pixaCreate(4);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 0, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
numaDestroy(&nax);
numaDestroy(&nahisto);
numaGetStatsUsingHistogram(na, 2000, &minval, &maxval, &meanval,
&variance, &median, 0.80, &rankval, &nahisto);
rmsdev = sqrt((l_float64)variance);
numaHistogramGetRankFromVal(nahisto, rankval, &rank);
regTestCompareValues(rp, -999.00, minval, 0.1); /* 4 */
regTestCompareValues(rp, 999.00, maxval, 0.1); /* 5 */
regTestCompareValues(rp, 0.055, meanval, 0.001); /* 6 */
regTestCompareValues(rp, 0.30, median, 0.005); /* 7 */
regTestCompareValues(rp, 706.41, rmsdev, 0.1); /* 8 */
regTestCompareValues(rp, 808.15, rankval, 0.1); /* 9 */
regTestCompareValues(rp, 0.800, rank, 0.01); /* 10 */
if (rp->display) {
fprintf(stderr, "Sin histogram: \n"
" min val = %7.3f -- should be -999.00\n"
" max val = %7.3f -- should be 999.00\n"
" mean val = %7.3f -- should be 0.055\n"
" median = %7.3f -- should be 0.30\n"
" rmsdev = %7.3f -- should be 706.41\n"
" rank val = %7.3f -- should be 808.152\n"
" rank = %7.3f -- should be 0.800\n",
minval, maxval, meanval, median, rmsdev, rankval, rank);
}
numaDestroy(&nahisto);
numaDestroy(&na);
/* -------------------------------------------------------------------*
* Interpolation *
* -------------------------------------------------------------------*/
/* Test numaInterpolateEqxInterval() */
pixs = pixRead("test8.jpg");
na = pixGetGrayHistogramMasked(pixs, NULL, 0, 0, 1);
nasy = numaGetPartialSums(na);
gplotSimple1(nasy, GPLOT_PNG, "/tmp/lept/numa1/int1", "partial sums");
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/numa1/int2", "simple test");
numaInterpolateEqxInterval(0.0, 1.0, na, L_LINEAR_INTERP,
0.0, 255.0, 15, &nax, &nay);
gplot = gplotCreate("/tmp/lept/numa1/int3", GPLOT_PNG, "test interpolation",
"pix val", "num pix");
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "plot 1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&na);
numaDestroy(&nasy);
numaDestroy(&nax);
numaDestroy(&nay);
pixDestroy(&pixs);
/* Test numaInterpolateArbxInterval() */
pixs = pixRead("test8.jpg");
na = pixGetGrayHistogramMasked(pixs, NULL, 0, 0, 1);
nasy = numaGetPartialSums(na);
numaInsertNumber(nasy, 0, 0.0);
nasx = numaMakeSequence(0.0, 1.0, 257);
numaInterpolateArbxInterval(nasx, nasy, L_LINEAR_INTERP,
10.0, 250.0, 23, &nax, &nay);
gplot = gplotCreate("/tmp/lept/numa1/int4", GPLOT_PNG, "arbx interpolation",
"pix val", "cum num pix");
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "plot 1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&na);
numaDestroy(&nasx);
numaDestroy(&nasy);
numaDestroy(&nax);
numaDestroy(&nay);
pixDestroy(&pixs);
/* Test numaInterpolateArbxVal() */
pixs = pixRead("test8.jpg");
na = pixGetGrayHistogramMasked(pixs, NULL, 0, 0, 1);
nasy = numaGetPartialSums(na);
numaInsertNumber(nasy, 0, 0.0);
nasx = numaMakeSequence(0.0, 1.0, 257);
nax = numaMakeSequence(15.0, (250.0 - 15.0) / 23.0, 24);
n = numaGetCount(nax);
nay = numaCreate(n);
for (i = 0; i < n; i++) {
numaGetFValue(nax, i, &xval);
numaInterpolateArbxVal(nasx, nasy, L_QUADRATIC_INTERP, xval, &yval);
numaAddNumber(nay, yval);
}
gplot = gplotCreate("/tmp/lept/numa1/int5", GPLOT_PNG, "arbx interpolation",
"pix val", "cum num pix");
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "plot 1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&na);
numaDestroy(&nasx);
numaDestroy(&nasy);
numaDestroy(&nax);
numaDestroy(&nay);
pixDestroy(&pixs);
/* Test interpolation */
nasx = numaRead("testangle.na");
nasy = numaRead("testscore.na");
gplot = gplotCreate("/tmp/lept/numa1/int6", GPLOT_PNG, "arbx interpolation",
"angle", "score");
numaInterpolateArbxInterval(nasx, nasy, L_LINEAR_INTERP,
-2.00, 0.0, 50, &nax, &nay);
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "linear");
numaDestroy(&nax);
numaDestroy(&nay);
numaInterpolateArbxInterval(nasx, nasy, L_QUADRATIC_INTERP,
-2.00, 0.0, 50, &nax, &nay);
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "quadratic");
numaDestroy(&nax);
numaDestroy(&nay);
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
gplot = gplotCreate("/tmp/lept/numa1/int7", GPLOT_PNG, "arbx interpolation",
"angle", "score");
numaInterpolateArbxInterval(nasx, nasy, L_LINEAR_INTERP,
-1.2, -0.8, 50, &nax, &nay);
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "quadratic");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaFitMax(nay, &yval, nax, &xval);
if (rp->display) fprintf(stderr, "max = %f at loc = %f\n", yval, xval);
pixa = pixaCreate(7);
pix1 = pixRead("/tmp/lept/numa1/int1.png");
pix2 = pixRead("/tmp/lept/numa1/int2.png");
pix3 = pixRead("/tmp/lept/numa1/int3.png");
pix4 = pixRead("/tmp/lept/numa1/int4.png");
pix5 = pixRead("/tmp/lept/numa1/int5.png");
pix6 = pixRead("/tmp/lept/numa1/int6.png");
pix7 = pixRead("/tmp/lept/numa1/int7.png");
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 11 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 12 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 13 */
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 14 */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 15 */
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 16 */
regTestWritePixAndCheck(rp, pix7, IFF_PNG); /* 17 */
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
pixaAddPix(pixa, pix5, L_INSERT);
pixaAddPix(pixa, pix6, L_INSERT);
pixaAddPix(pixa, pix7, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 300, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
numaDestroy(&nasx);
numaDestroy(&nasy);
numaDestroy(&nax);
numaDestroy(&nay);
/* -------------------------------------------------------------------*
* Integration and differentiation *
* -------------------------------------------------------------------*/
/* Test integration and differentiation */
nasx = numaRead("testangle.na");
nasy = numaRead("testscore.na");
/* ---------- Plot the derivative ---------- */
numaDifferentiateInterval(nasx, nasy, -2.0, 0.0, 50, &nadx, &nady);
gplot = gplotCreate("/tmp/lept/numa1/diff1", GPLOT_PNG, "derivative",
"angle", "slope");
gplotAddPlot(gplot, nadx, nady, GPLOT_LINES, "derivative");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
/* ---------- Plot the original function ----------- */
/* and the integral of the derivative; the two */
/* should be approximately the same. */
gplot = gplotCreate("/tmp/lept/numa1/diff2", GPLOT_PNG, "integ-diff",
"angle", "val");
numaInterpolateArbxInterval(nasx, nasy, L_LINEAR_INTERP,
-2.00, 0.0, 50, &nafx, &nafy);
gplotAddPlot(gplot, nafx, nafy, GPLOT_LINES, "function");
n = numaGetCount(nadx);
numaGetFValue(nafx, 0, &x0);
numaGetFValue(nafy, 0, &y0);
nay = numaCreate(n);
/* (Note: this tests robustness of the integrator: we go from
* i = 0, and choose to have only 1 point in the interpolation
* there, which is too small and causes the function to bomb out.) */
fprintf(stderr, "We must get a 'npts < 2' error here:\n");
for (i = 0; i < n; i++) {
numaGetFValue(nadx, i, &xval);
numaIntegrateInterval(nadx, nady, x0, xval, 2 * i + 1, &yval);
numaAddNumber(nay, y0 + yval);
}
gplotAddPlot(gplot, nafx, nay, GPLOT_LINES, "anti-derivative");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
pixa = pixaCreate(2);
pix1 = pixRead("/tmp/lept/numa1/diff1.png");
pix2 = pixRead("/tmp/lept/numa1/diff2.png");
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 18 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 19 */
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 600, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
numaDestroy(&nasx);
numaDestroy(&nasy);
numaDestroy(&nafx);
numaDestroy(&nafy);
numaDestroy(&nadx);
numaDestroy(&nady);
numaDestroy(&nay);
/* -------------------------------------------------------------------*
* Rank extraction *
* -------------------------------------------------------------------*/
/* Rank extraction with interpolation */
pixs = pixRead("test8.jpg");
nasy= pixGetGrayHistogramMasked(pixs, NULL, 0, 0, 1);
numaMakeRankFromHistogram(0.0, 1.0, nasy, 350, &nax, &nay);
gplot = gplotCreate("/tmp/lept/numa1/rank1", GPLOT_PNG,
"test rank extractor", "pix val", "rank val");
gplotAddPlot(gplot, nax, nay, GPLOT_LINES, "plot 1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nasy);
numaDestroy(&nax);
numaDestroy(&nay);
pixDestroy(&pixs);
/* Rank extraction, point by point */
pixs = pixRead("test8.jpg");
nap = numaCreate(200);
pixGetRankValueMasked(pixs, NULL, 0, 0, 2, 0.0, &val, &na);
for (i = 0; i < 101; i++) {
rank = 0.01 * i;
numaHistogramGetValFromRank(na, rank, &val);
numaAddNumber(nap, val);
}
gplotSimple1(nap, GPLOT_PNG, "/tmp/lept/numa1/rank2", "rank value");
pixa = pixaCreate(2);
pix1 = pixRead("/tmp/lept/numa1/rank1.png");
pix2 = pixRead("/tmp/lept/numa1/rank2.png");
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 20 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 21 */
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 900, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
numaDestroy(&na);
numaDestroy(&nap);
pixDestroy(&pixs);
/* -------------------------------------------------------------------*
* Numa-morphology *
* -------------------------------------------------------------------*/
na = numaRead("lyra.5.na");
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/numa1/lyra1", "Original");
na1 = numaErode(na, 21);
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/numa1/lyra2", "Erosion");
na2 = numaDilate(na, 21);
gplotSimple1(na2, GPLOT_PNG, "/tmp/lept/numa1/lyra3", "Dilation");
na3 = numaOpen(na, 21);
gplotSimple1(na3, GPLOT_PNG, "/tmp/lept/numa1/lyra4", "Opening");
na4 = numaClose(na, 21);
gplotSimple1(na4, GPLOT_PNG, "/tmp/lept/numa1/lyra5", "Closing");
pixa = pixaCreate(2);
pix1 = pixRead("/tmp/lept/numa1/lyra1.png");
pix2 = pixRead("/tmp/lept/numa1/lyra2.png");
pix3 = pixRead("/tmp/lept/numa1/lyra3.png");
pix4 = pixRead("/tmp/lept/numa1/lyra4.png");
pix5 = pixRead("/tmp/lept/numa1/lyra5.png");
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
pixaAddPix(pixa, pix5, L_INSERT);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 22 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 23 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 24 */
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 25 */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 26 */
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 1200, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
numaDestroy(&na);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, j;
l_int32 w, h, bw, bh, wpls, rval, gval, bval, same;
l_uint32 pixel;
l_uint32 *lines, *datas;
l_float32 sum1, sum2, ave1, ave2, ave3, ave4, diff1, diff2;
l_float32 var1, var2, var3;
BOX *box1, *box2;
NUMA *na, *na1, *na2, *na3, *na4;
PIX *pix, *pixs, *pix1, *pix2, *pix3, *pix4, *pix5, *pixg, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/numa2");
/* -------------------------------------------------------------------*
* Numa-windowed stats *
* -------------------------------------------------------------------*/
na = numaRead("lyra.5.na");
numaWindowedStats(na, 5, &na1, &na2, &na3, &na4);
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/numa2/lyra1", "Original");
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/numa2/lyra2", "Mean");
gplotSimple1(na2, GPLOT_PNG, "/tmp/lept/numa2/lyra3", "Mean Square");
gplotSimple1(na3, GPLOT_PNG, "/tmp/lept/numa2/lyra4", "Variance");
gplotSimple1(na4, GPLOT_PNG, "/tmp/lept/numa2/lyra5", "RMS Difference");
pix1 = pixRead("/tmp/lept/numa2/lyra1.png");
pix2 = pixRead("/tmp/lept/numa2/lyra2.png");
pix3 = pixRead("/tmp/lept/numa2/lyra3.png");
pix4 = pixRead("/tmp/lept/numa2/lyra4.png");
pix5 = pixRead("/tmp/lept/numa2/lyra5.png");
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 2 */
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 3 */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 4 */
pixa = pixaCreate(5);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
pixaAddPix(pixa, pix5, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 0, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
numaDestroy(&na);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
/* -------------------------------------------------------------------*
* Extraction on a line *
* -------------------------------------------------------------------*/
/* First, make a pretty image */
w = h = 200;
pixs = pixCreate(w, h, 32);
wpls = pixGetWpl(pixs);
datas = pixGetData(pixs);
for (i = 0; i < 200; i++) {
lines = datas + i * wpls;
for (j = 0; j < 200; j++) {
rval = (l_int32)((255. * j) / w + (255. * i) / h);
gval = (l_int32)((255. * 2 * j) / w + (255. * 2 * i) / h) % 255;
bval = (l_int32)((255. * 4 * j) / w + (255. * 4 * i) / h) % 255;
composeRGBPixel(rval, gval, bval, &pixel);
lines[j] = pixel;
}
}
pixg = pixConvertTo8(pixs, 0); /* and a grayscale version */
regTestWritePixAndCheck(rp, pixg, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixg, 0, 300, NULL, rp->display);
na1 = pixExtractOnLine(pixg, 20, 20, 180, 20, 1);
na2 = pixExtractOnLine(pixg, 40, 30, 40, 170, 1);
na3 = pixExtractOnLine(pixg, 20, 170, 180, 30, 1);
na4 = pixExtractOnLine(pixg, 20, 190, 180, 10, 1);
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/numa2/ext1", "Horizontal");
gplotSimple1(na2, GPLOT_PNG, "/tmp/lept/numa2/ext2", "Vertical");
gplotSimple1(na3, GPLOT_PNG, "/tmp/lept/numa2/ext3",
"Slightly more horizontal than vertical");
gplotSimple1(na4, GPLOT_PNG, "/tmp/lept/numa2/ext4",
"Slightly more vertical than horizontal");
pix1 = pixRead("/tmp/lept/numa2/ext1.png");
pix2 = pixRead("/tmp/lept/numa2/ext2.png");
pix3 = pixRead("/tmp/lept/numa2/ext3.png");
pix4 = pixRead("/tmp/lept/numa2/ext4.png");
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 6 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 7 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 8 */
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 9 */
pixa = pixaCreate(4);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 300, 0, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
pixDestroy(&pixg);
pixDestroy(&pixs);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
/* -------------------------------------------------------------------*
* Row and column pixel sums *
* -------------------------------------------------------------------*/
/* Sum by columns in two halves (left and right) */
pixs = pixRead("test8.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
box1 = boxCreate(0, 0, w / 2, h);
box2 = boxCreate(w / 2, 0, w - 2 / 2, h);
na1 = pixAverageByColumn(pixs, box1, L_BLACK_IS_MAX);
na2 = pixAverageByColumn(pixs, box2, L_BLACK_IS_MAX);
numaJoin(na1, na2, 0, -1);
na3 = pixAverageByColumn(pixs, NULL, L_BLACK_IS_MAX);
numaSimilar(na1, na3, 0.0, &same); /* for columns */
regTestCompareValues(rp, 1, same, 0); /* 10 */
pix1 = pixConvertTo32(pixs);
pixRenderPlotFromNumaGen(&pix1, na3, L_HORIZONTAL_LINE, 3, h / 2, 80, 1,
0xff000000);
pixRenderPlotFromNuma(&pix1, na3, L_PLOT_AT_BOT, 3, 80, 0xff000000);
boxDestroy(&box1);
boxDestroy(&box2);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
/* Sum by rows in two halves (top and bottom) */
box1 = boxCreate(0, 0, w, h / 2);
box2 = boxCreate(0, h / 2, w, h - h / 2);
na1 = pixAverageByRow(pixs, box1, L_WHITE_IS_MAX);
na2 = pixAverageByRow(pixs, box2, L_WHITE_IS_MAX);
numaJoin(na1, na2, 0, -1);
na3 = pixAverageByRow(pixs, NULL, L_WHITE_IS_MAX);
numaSimilar(na1, na3, 0.0, &same); /* for rows */
regTestCompareValues(rp, 1, same, 0); /* 11 */
pixRenderPlotFromNumaGen(&pix1, na3, L_VERTICAL_LINE, 3, w / 2, 80, 1,
0x00ff0000);
pixRenderPlotFromNuma(&pix1, na3, L_PLOT_AT_RIGHT, 3, 80, 0x00ff0000);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix1, 0, 600, NULL, rp->display);
pixDestroy(&pix1);
boxDestroy(&box1);
boxDestroy(&box2);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
/* Average left by rows; right by columns; compare totals */
box1 = boxCreate(0, 0, w / 2, h);
box2 = boxCreate(w / 2, 0, w - 2 / 2, h);
na1 = pixAverageByRow(pixs, box1, L_WHITE_IS_MAX);
na2 = pixAverageByColumn(pixs, box2, L_WHITE_IS_MAX);
numaGetSum(na1, &sum1); /* sum of averages of left box */
numaGetSum(na2, &sum2); /* sum of averages of right box */
ave1 = sum1 / h;
ave2 = 2.0 * sum2 / w;
ave3 = 0.5 * (ave1 + ave2); /* average over both halves */
regTestCompareValues(rp, 189.59, ave1, 0.01); /* 13 */
regTestCompareValues(rp, 207.89, ave2, 0.01); /* 14 */
if (rp->display) {
fprintf(stderr, "ave1 = %8.4f\n", sum1 / h);
fprintf(stderr, "ave2 = %8.4f\n", 2.0 * sum2 / w);
}
pixAverageInRect(pixs, NULL, &ave4); /* entire image */
diff1 = ave4 - ave3;
diff2 = w * h * ave4 - (0.5 * w * sum1 + h * sum2);
regTestCompareValues(rp, 0.0, diff1, 0.001); /* 15 */
regTestCompareValues(rp, 10.0, diff2, 10.0); /* 16 */
/* Variance left and right halves. Variance doesn't average
* in a simple way, unlike pixel sums. */
pixVarianceInRect(pixs, box1, &var1); /* entire image */
pixVarianceInRect(pixs, box2, &var2); /* entire image */
pixVarianceInRect(pixs, NULL, &var3); /* entire image */
regTestCompareValues(rp, 82.06, 0.5 * (var1 + var2), 0.01); /* 17 */
regTestCompareValues(rp, 82.66, var3, 0.01); /* 18 */
boxDestroy(&box1);
boxDestroy(&box2);
numaDestroy(&na1);
numaDestroy(&na2);
/* -------------------------------------------------------------------*
* Row and column variances *
* -------------------------------------------------------------------*/
/* Display variance by rows and columns */
box1 = boxCreate(415, 0, 130, 425);
boxGetGeometry(box1, NULL, NULL, &bw, &bh);
na1 = pixVarianceByRow(pixs, box1);
na2 = pixVarianceByColumn(pixs, box1);
pix1 = pixConvertTo32(pixs);
pix2 = pixCopy(NULL, pix1);
pixRenderPlotFromNumaGen(&pix1, na1, L_VERTICAL_LINE, 3, 415, 100, 1,
0xff000000);
pixRenderPlotFromNumaGen(&pix1, na2, L_HORIZONTAL_LINE, 3, bh / 2, 100, 1,
0x00ff0000);
pixRenderPlotFromNuma(&pix2, na1, L_PLOT_AT_LEFT, 3, 60, 0x00ff0000);
pixRenderPlotFromNuma(&pix2, na1, L_PLOT_AT_MID_VERT, 3, 60, 0x0000ff00);
pixRenderPlotFromNuma(&pix2, na1, L_PLOT_AT_RIGHT, 3, 60, 0xff000000);
pixRenderPlotFromNuma(&pix2, na2, L_PLOT_AT_TOP, 3, 60, 0x0000ff00);
pixRenderPlotFromNuma(&pix2, na2, L_PLOT_AT_MID_HORIZ, 3, 60, 0xff000000);
pixRenderPlotFromNuma(&pix2, na2, L_PLOT_AT_BOT, 3, 60, 0x00ff0000);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 19 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 20 */
pixa = pixaCreate(2);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 400, 600, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
boxDestroy(&box1);
numaDestroy(&na1);
numaDestroy(&na2);
pixDestroy(&pixs);
/* Again on a different image */
pix1 = pixRead("boxedpage.jpg");
pix2 = pixConvertTo8(pix1, 0);
pixGetDimensions(pix2, &w, &h, NULL);
na1 = pixVarianceByRow(pix2, NULL);
pix3 = pixConvertTo32(pix1);
pixRenderPlotFromNumaGen(&pix3, na1, L_VERTICAL_LINE, 3, 0, 70, 1,
0xff000000);
na2 = pixVarianceByColumn(pix2, NULL);
pixRenderPlotFromNumaGen(&pix3, na2, L_HORIZONTAL_LINE, 3, bh - 1, 70, 1,
0x00ff0000);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 21 */
numaDestroy(&na1);
numaDestroy(&na2);
/* Again, with an erosion */
pix4 = pixErodeGray(pix2, 3, 21);
na1 = pixVarianceByRow(pix4, NULL);
pix5 = pixConvertTo32(pix1);
pixRenderPlotFromNumaGen(&pix5, na1, L_VERTICAL_LINE, 3, 30, 70, 1,
0xff000000);
na2 = pixVarianceByColumn(pix4, NULL);
pixRenderPlotFromNumaGen(&pix5, na2, L_HORIZONTAL_LINE, 3, bh - 1, 70, 1,
0x00ff0000);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 22 */
pixa = pixaCreate(2);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix5, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 800, 600, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix4);
numaDestroy(&na1);
numaDestroy(&na2);
/* -------------------------------------------------------------------*
* Windowed variance along a line *
* -------------------------------------------------------------------*/
pix1 = pixRead("boxedpage.jpg");
pix2 = pixConvertTo8(pix1, 0);
pixGetDimensions(pix2, &w, &h, NULL);
pix3 = pixCopy(NULL, pix1);
/* Plot along horizontal line */
pixWindowedVarianceOnLine(pix2, L_HORIZONTAL_LINE, h / 2 - 30, 0,
w, 5, &na1);
pixRenderPlotFromNumaGen(&pix1, na1, L_HORIZONTAL_LINE, 3, h / 2 - 30,
80, 1, 0xff000000);
pixRenderPlotFromNuma(&pix3, na1, L_PLOT_AT_TOP, 3, 60, 0x00ff0000);
pixRenderPlotFromNuma(&pix3, na1, L_PLOT_AT_BOT, 3, 60, 0x0000ff00);
/* Plot along vertical line */
pixWindowedVarianceOnLine(pix2, L_VERTICAL_LINE, 0.78 * w, 0,
h, 5, &na2);
pixRenderPlotFromNumaGen(&pix1, na2, L_VERTICAL_LINE, 3, 0.78 * w, 60,
1, 0x00ff0000);
pixRenderPlotFromNuma(&pix3, na2, L_PLOT_AT_LEFT, 3, 60, 0xff000000);
pixRenderPlotFromNuma(&pix3, na2, L_PLOT_AT_RIGHT, 3, 60, 0x00ff0000);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 23 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 24 */
pixa = pixaCreate(2);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
if (rp->display) {
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplayWithTitle(pixd, 1200, 600, NULL, 1);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
pixDestroy(&pix2);
numaDestroy(&na1);
numaDestroy(&na2);
return regTestCleanup(rp);;
}
