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;
static char mainName[] = "numa2_reg";
if (argc != 1)
return ERROR_INT(" Syntax: numa2_reg", mainName, 1);
lept_mkdir("lept/numa2");
/* -------------------------------------------------------------------*
* Numa-windowed stats *
* -------------------------------------------------------------------*/
#if DO_ALL
na = numaRead("lyra.5.na");
numaWindowedStats(na, 5, &na1, &na2, &na3, &na4);
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/numa2/lyra6", "Original");
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/numa2/lyra7", "Mean");
gplotSimple1(na2, GPLOT_PNG, "/tmp/lept/numa2/lyra8", "Mean Square");
gplotSimple1(na3, GPLOT_PNG, "/tmp/lept/numa2/lyra9", "Variance");
gplotSimple1(na4, GPLOT_PNG, "/tmp/lept/numa2/lyra10", "RMS Difference");
pixa = pixaCreate(5);
pix1 = pixRead("/tmp/lept/numa2/lyra6.png");
pix2 = pixRead("/tmp/lept/numa2/lyra7.png");
pix3 = pixRead("/tmp/lept/numa2/lyra8.png");
pix4 = pixRead("/tmp/lept/numa2/lyra9.png");
pix5 = pixRead("/tmp/lept/numa2/lyra10.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);
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplay(pixd, 100, 0);
pixWrite("/tmp/lept/numa2/window.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
numaDestroy(&na);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
#endif
/* -------------------------------------------------------------------*
* Extraction on a line *
* -------------------------------------------------------------------*/
#if DO_ALL
/* 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 */
pixWrite("/tmp/lept/numa_pixg.png", pixg, IFF_PNG);
pixDisplay(pixg, 450, 100);
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");
pixa = pixaCreate(4);
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");
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix3, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
pixd = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 20, 2);
pixDisplay(pixd, 100, 450);
pixWrite("/tmp/lept/numa2/extract.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixg);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
#endif
/* -------------------------------------------------------------------*
* Row and column pixel sums *
* -------------------------------------------------------------------*/
#if DO_ALL
/* 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);
if (same)
fprintf(stderr, "Same for columns\n");
else
fprintf(stderr, "Error for columns\n");
pix = pixConvertTo32(pixs);
pixRenderPlotFromNumaGen(&pix, na3, L_HORIZONTAL_LINE, 3, h / 2, 80, 1,
0xff000000);
pixRenderPlotFromNuma(&pix, 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);
if (same)
fprintf(stderr, "Same for rows\n");
else
fprintf(stderr, "Error for rows\n");
pixRenderPlotFromNumaGen(&pix, na3, L_VERTICAL_LINE, 3, w / 2, 80, 1,
0x00ff0000);
pixRenderPlotFromNuma(&pix, na3, L_PLOT_AT_RIGHT, 3, 80, 0x00ff0000);
pixDisplay(pix, 500, 200);
boxDestroy(&box1);
boxDestroy(&box2);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
pixDestroy(&pix);
/* 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 */
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);
if (diff1 < 0.001)
fprintf(stderr, "Average diffs are correct\n");
else
fprintf(stderr, "Average diffs are wrong: diff1 = %7.5f\n", diff1);
if (diff2 < 20) /* float-to-integer roundoff */
fprintf(stderr, "Pixel sums are correct\n");
else
fprintf(stderr, "Pixel sums are in error: diff = %7.0f\n", diff2);
/* 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 */
fprintf(stderr, "0.5 * (var1 + var2) = %7.3f, var3 = %7.3f\n",
0.5 * (var1 + var2), var3);
boxDestroy(&box1);
boxDestroy(&box2);
numaDestroy(&na1);
numaDestroy(&na2);
#endif
/* -------------------------------------------------------------------*
* Row and column variances *
* -------------------------------------------------------------------*/
#if DO_ALL
/* 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);
pix = pixConvertTo32(pixs);
pix1 = pixCopy(NULL, pix);
pixRenderPlotFromNumaGen(&pix, na1, L_VERTICAL_LINE, 3, 415, 100, 1,
0xff000000);
pixRenderPlotFromNumaGen(&pix, na2, L_HORIZONTAL_LINE, 3, bh / 2, 100, 1,
0x00ff0000);
pixRenderPlotFromNuma(&pix1, na1, L_PLOT_AT_LEFT, 3, 60, 0x00ff0000);
pixRenderPlotFromNuma(&pix1, na1, L_PLOT_AT_MID_VERT, 3, 60, 0x0000ff00);
pixRenderPlotFromNuma(&pix1, na1, L_PLOT_AT_RIGHT, 3, 60, 0xff000000);
pixRenderPlotFromNuma(&pix1, na2, L_PLOT_AT_TOP, 3, 60, 0x0000ff00);
pixRenderPlotFromNuma(&pix1, na2, L_PLOT_AT_MID_HORIZ, 3, 60, 0xff000000);
pixRenderPlotFromNuma(&pix1, na2, L_PLOT_AT_BOT, 3, 60, 0x00ff0000);
pixDisplay(pix, 500, 900);
pixDisplay(pix1, 500, 1000);
boxDestroy(&box1);
numaDestroy(&na1);
numaDestroy(&na2);
pixDestroy(&pix);
pixDestroy(&pix1);
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);
pixDisplay(pix3, 1000, 0);
numaDestroy(&na1);
numaDestroy(&na2);
pixDestroy(&pix3);
/* Again, with an erosion */
pix3 = pixErodeGray(pix2, 3, 21);
pixDisplay(pix3, 1400, 0);
na1 = pixVarianceByRow(pix3, NULL);
pix4 = pixConvertTo32(pix1);
pixRenderPlotFromNumaGen(&pix4, na1, L_VERTICAL_LINE, 3, 30, 70, 1,
0xff000000);
na2 = pixVarianceByColumn(pix3, NULL);
pixRenderPlotFromNumaGen(&pix4, na2, L_HORIZONTAL_LINE, 3, bh - 1, 70, 1,
0x00ff0000);
pixDisplay(pix4, 1000, 550);
numaDestroy(&na1);
numaDestroy(&na2);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
#endif
/* -------------------------------------------------------------------*
* Windowed variance along a line *
* -------------------------------------------------------------------*/
#if DO_ALL
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);
pixDisplay(pix1, 1000, 1000);
pixDisplay(pix3, 1500, 1000);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
numaDestroy(&na1);
numaDestroy(&na2);
#endif
return 0;
}
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, 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);;
}
