int main(int argc,
char **argv)
{
char *filein, *fileout;
char bigbuf[512];
l_int32 iplot, same;
l_float32 gam;
l_float64 gamma[] = {.5, 1.0, 1.5, 2.0, 2.5, -1.0};
GPLOT *gplot;
NUMA *na, *nax;
PIX *pixs, *pixd;
static char mainName[] = "gammatest";
if (argc != 4)
return ERROR_INT(" Syntax: gammatest filein gam fileout", mainName, 1);
lept_mkdir("lept/gamma");
filein = argv[1];
gam = atof(argv[2]);
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
startTimer();
pixd = pixGammaTRC(NULL, pixs, gam, MINVAL, MAXVAL);
fprintf(stderr, "Time for gamma: %7.3f sec\n", stopTimer());
pixGammaTRC(pixs, pixs, gam, MINVAL, MAXVAL);
pixEqual(pixs, pixd, &same);
if (!same)
fprintf(stderr, "Error in pixGammaTRC!\n");
pixWrite(fileout, pixs, IFF_JFIF_JPEG);
pixDestroy(&pixs);
na = numaGammaTRC(gam, MINVAL, MAXVAL);
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/gamma/trc", "gamma trc");
l_fileDisplay("/tmp/lept/gamma/trc.png", 100, 100, 1.0);
numaDestroy(&na);
/* Plot gamma TRC maps */
gplot = gplotCreate("/tmp/lept/gamma/corr", GPLOT_PNG,
"Mapping function for gamma correction",
"value in", "value out");
nax = numaMakeSequence(0.0, 1.0, 256);
for (iplot = 0; gamma[iplot] >= 0.0; iplot++) {
na = numaGammaTRC(gamma[iplot], 30, 215);
sprintf(bigbuf, "gamma = %3.1f", gamma[iplot]);
gplotAddPlot(gplot, nax, na, GPLOT_LINES, bigbuf);
numaDestroy(&na);
}
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
l_fileDisplay("/tmp/lept/gamma/corr.png", 100, 100, 1.0);
numaDestroy(&nax);
return 0;
}
int main(int argc,
char **argv)
{
char *filein, *fileout;
char bigbuf[512];
l_int32 iplot;
l_float32 factor; /* scaled width of atan curve */
l_float32 fact[] = {.2, 0.4, 0.6, 0.8, 1.0, -1.0};
GPLOT *gplot;
NUMA *na, *nax;
PIX *pixs;
static char mainName[] = "contrasttest";
if (argc != 4)
return ERROR_INT(" Syntax: contrasttest filein factor fileout",
mainName, 1);
lept_mkdir("lept/contrast");
filein = argv[1];
factor = atof(argv[2]);
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
na = numaContrastTRC(factor);
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/contrast/trc1", "contrast trc");
l_fileDisplay("/tmp/lept/contrast/trc1.png", 0, 100, 1.0);
numaDestroy(&na);
/* Plot contrast TRC maps */
nax = numaMakeSequence(0.0, 1.0, 256);
gplot = gplotCreate("/tmp/lept/contrast/trc2", GPLOT_PNG,
"Atan mapping function for contrast enhancement",
"value in", "value out");
for (iplot = 0; fact[iplot] >= 0.0; iplot++) {
na = numaContrastTRC(fact[iplot]);
sprintf(bigbuf, "factor = %3.1f", fact[iplot]);
gplotAddPlot(gplot, nax, na, GPLOT_LINES, bigbuf);
numaDestroy(&na);
}
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
l_fileDisplay("/tmp/lept/contrast/trc2.png", 600, 100, 1.0);
numaDestroy(&nax);
/* Apply the input contrast enhancement */
pixContrastTRC(pixs, pixs, factor);
pixWrite(fileout, pixs, IFF_PNG);
pixDestroy(&pixs);
return 0;
}
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 size, i, n, n0;
BOXA *boxa;
GPLOT *gplot;
NUMA *nax, *nay1, *nay2;
PIX *pixs, *pixd;
static char mainName[] = "pixa1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: pixa1_reg", mainName, 1);
if ((pixs = pixRead("feyn.tif")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
/* ---------------- Remove small components --------------- */
boxa = pixConnComp(pixs, NULL, 8);
n0 = boxaGetCount(boxa);
nax = numaMakeSequence(0, 2, 51);
nay1 = numaCreate(51);
nay2 = numaCreate(51);
boxaDestroy(&boxa);
fprintf(stderr, "\n Select Large if Both\n");
fprintf(stderr, "Iter 0: n = %d\n", n0);
numaAddNumber(nay1, n0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_BOTH, L_SELECT_IF_GTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay1, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
fprintf(stderr, "\n Select Large if Either\n");
fprintf(stderr, "Iter 0: n = %d\n", n0);
numaAddNumber(nay2, n0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_EITHER, L_SELECT_IF_GTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay2, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
gplot = gplotCreate("/tmp/junkroot1", GPLOT_X11,
"Select large: number of cc vs size removed",
"min size", "number of c.c.");
gplotAddPlot(gplot, nax, nay1, GPLOT_LINES, "select if both");
gplotAddPlot(gplot, nax, nay2, GPLOT_LINES, "select if either");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
/* ---------------- Remove large components --------------- */
numaEmpty(nay1);
numaEmpty(nay2);
fprintf(stderr, "\n Select Small if Both\n");
fprintf(stderr, "Iter 0: n = %d\n", 0);
numaAddNumber(nay1, 0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_BOTH, L_SELECT_IF_LTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay1, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
fprintf(stderr, "\n Select Small if Either\n");
fprintf(stderr, "Iter 0: n = %d\n", 0);
numaAddNumber(nay2, 0);
for (i = 1; i <= 50; i++) {
size = 2 * i;
pixd = pixSelectBySize(pixs, size, size, CONNECTIVITY,
L_SELECT_IF_EITHER, L_SELECT_IF_LTE, NULL);
boxa = pixConnComp(pixd, NULL, 8);
n = boxaGetCount(boxa);
numaAddNumber(nay2, n);
fprintf(stderr, "Iter %d: n = %d\n", i, n);
boxaDestroy(&boxa);
pixDestroy(&pixd);
}
gplot = gplotCreate("/tmp/junkroot2", GPLOT_X11,
"Remove large: number of cc vs size removed",
"min size", "number of c.c.");
gplotAddPlot(gplot, nax, nay1, GPLOT_LINES, "select if both");
gplotAddPlot(gplot, nax, nay2, GPLOT_LINES, "select if either");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
numaDestroy(&nay1);
numaDestroy(&nay2);
pixDestroy(&pixs);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, j, w, h, same;
l_float32 t, t1, t2;
GPLOT *gplot;
NUMA *nax, *nay1, *nay2;
PIX *pixs, *pixd, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa;
static char mainName[] = "rank_reg";
if (argc != 1)
return ERROR_INT(" Syntax: rank_reg", mainName, 1);
if ((pixs = pixRead("lucasta.150.jpg")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, NULL);
startTimer();
pixd = pixRankFilterGray(pixs, 15, 15, 0.4);
t = stopTimer();
fprintf(stderr, "Time = %7.3f sec\n", t);
fprintf(stderr, "MPix/sec: %7.3f\n", 0.000001 * w * h / t);
pixDisplay(pixs, 0, 200);
pixDisplay(pixd, 600, 200);
pixWrite("/tmp/filter.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Get results for dilation */
startTimer();
pixt1 = pixDilateGray(pixs, 15, 15);
t = stopTimer();
fprintf(stderr, "Dilation time = %7.3f sec\n", t);
/* Get results for erosion */
pixt2 = pixErodeGray(pixs, 15, 15);
/* Get results using the rank filter for rank = 0.0 and 1.0.
* Don't use 0.0 or 1.0, because those are dispatched
* automatically to erosion and dilation! */
pixt3 = pixRankFilterGray(pixs, 15, 15, 0.0001);
pixt4 = pixRankFilterGray(pixs, 15, 15, 0.9999);
/* Compare */
pixEqual(pixt1, pixt4, &same);
if (same)
fprintf(stderr, "Correct: dilation results same as rank 1.0\n");
else
fprintf(stderr, "Error: dilation results differ from rank 1.0\n");
pixEqual(pixt2, pixt3, &same);
if (same)
fprintf(stderr, "Correct: erosion results same as rank 0.0\n");
else
fprintf(stderr, "Error: erosion results differ from rank 0.0\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
fprintf(stderr, "\n----------------------------------------\n");
fprintf(stderr, "The next part takes about 30 seconds\n");
fprintf(stderr, "----------------------------------------\n\n");
nax = numaMakeSequence(1, 1, SIZE);
nay1 = numaCreate(SIZE);
nay2 = numaCreate(SIZE);
gplot = gplotCreate("/tmp/rankroot", GPLOT_X11, "sec/MPix vs filter size",
"size", "time");
for (i = 1; i <= SIZE; i++) {
t1 = t2 = 0.0;
for (j = 0; j < 5; j++) {
startTimer();
pixt1 = pixRankFilterGray(pixs, i, SIZE + 1, 0.5);
t1 += stopTimer();
pixDestroy(&pixt1);
startTimer();
pixt1 = pixRankFilterGray(pixs, SIZE + 1, i, 0.5);
t2 += stopTimer();
if (j == 0)
pixDisplayWrite(pixt1, 1);
pixDestroy(&pixt1);
}
numaAddNumber(nay1, 1000000. * t1 / (5. * w * h));
numaAddNumber(nay2, 1000000. * t2 / (5. * w * h));
}
gplotAddPlot(gplot, nax, nay1, GPLOT_LINES, "vertical");
gplotAddPlot(gplot, nax, nay2, GPLOT_LINES, "horizontal");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
/* Display tiled */
pixa = pixaReadFiles("/tmp/display", "file");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 250, 5, 0, 25, 2);
pixWrite("/tmp/tiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDisplayWrite(NULL, -1); /* clear out */
pixs = pixRead("test8.jpg");
for (i = 1; i <= 4; i++) {
pixt1 = pixScaleGrayRank2(pixs, i);
pixDisplay(pixt1, 300 * (i - 1), 100);
pixDestroy(&pixt1);
}
pixDestroy(&pixs);
pixs = pixRead("test24.jpg");
pixt1 = pixConvertRGBToLuminance(pixs);
pixt2 = pixScale(pixt1, 1.5, 1.5);
for (i = 1; i <= 4; i++) {
for (j = 1; j <= 4; j++) {
pixt3 = pixScaleGrayRankCascade(pixt2, i, j, 0, 0);
pixDisplayWrite(pixt3, 1);
pixDestroy(&pixt3);
}
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDisplayMultiple("/tmp/display/file*");
return 0;
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb;
PIXA *pixa;
PIXCMAP *cmap;
static char mainName[] = "colorspacetest";
if (argc != 2)
return ERROR_INT(" Syntax: colorspacetest filein", mainName, 1);
if ((pixs = pixRead(argv[1])) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
/* Generate colors by sampling hue with max sat and value.
* This was used to make the color strip 19-colors.png. */
pixa = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixa, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixa, 32, 1100, 1.0, 0, 0, 0);
pixDisplayWrite(pixt2, 1);
pixDestroy(&pixt2);
pixaDestroy(&pixa);
/* Colorspace conversion in rgb */
pixDisplayWrite(pixs, 1);
pixt = pixConvertRGBToHSV(NULL, pixs);
pixDisplayWrite(pixt, 1);
pixConvertHSVToRGB(pixt, pixt);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
pixDisplayWrite(pixt, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixcmapConvertHSVToRGB(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
pixDisplayWrite(pixr, 1);
pixDisplayWrite(pixg, 1);
pixDisplayWrite(pixb, 1);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Color content measurement */
pixa = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/junkplot1", GPLOT_X11,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/junkplot2", GPLOT_X11,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, 250, 4, 0, 10, 2);
pixWrite("/tmp/junkcolormag", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", 1);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
pixDisplayMultiple("/tmp/display/file*");
pixDestroy(&pixs);
return 0;
}
int main(int argc,
char **argv) {
l_int32 i, w, h, d, rotflag;
PIX *pixs, *pixt, *pixd;
l_float32 angle, deg2rad, pops, ang;
char *filein, *fileout;
static char mainName[] = "rotatetest1";
if (argc != 4)
return ERROR_INT(" Syntax: rotatetest1 filein angle fileout",
mainName, 1);
filein = argv[1];
angle = atof(argv[2]);
fileout = argv[3];
deg2rad = 3.1415926535 / 180.;
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pix not made", mainName, 1);
if (pixGetDepth(pixs) == 1) {
pixt = pixScaleToGray3(pixs);
pixDestroy(&pixs);
pixs = pixAddBorderGeneral(pixt, 1, 0, 1, 0, 255);
pixDestroy(&pixt);
}
pixGetDimensions(pixs, &w, &h, &d);
fprintf(stderr, "w = %d, h = %d\n", w, h);
#if 0
/* repertory of rotation operations to choose from */
pixd = pixRotateAM(pixs, deg2rad * angle, L_BRING_IN_WHITE);
pixd = pixRotateAMColor(pixs, deg2rad * angle, 0xffffff00);
pixd = pixRotateAMColorFast(pixs, deg2rad * angle, 255);
pixd = pixRotateAMCorner(pixs, deg2rad * angle, L_BRING_IN_WHITE);
pixd = pixRotateShear(pixs, w /2, h / 2, deg2rad * angle,
L_BRING_IN_WHITE);
pixd = pixRotate3Shear(pixs, w /2, h / 2, deg2rad * angle,
L_BRING_IN_WHITE);
pixRotateShearIP(pixs, w / 2, h / 2, deg2rad * angle); pixd = pixs;
#endif
#if 0
/* timing of shear rotation */
for (i = 0; i < NITERS; i++) {
pixd = pixRotateShear(pixs, (i * w) / NITERS,
(i * h) / NITERS, deg2rad * angle,
L_BRING_IN_WHITE);
pixDisplay(pixd, 100 + 20 * i, 100 + 20 * i);
pixDestroy(&pixd);
}
#endif
#if 0
/* timing of in-place shear rotation */
for (i = 0; i < NITERS; i++) {
pixRotateShearIP(pixs, w/2, h/2, deg2rad * angle, L_BRING_IN_WHITE);
/* pixRotateShearCenterIP(pixs, deg2rad * angle, L_BRING_IN_WHITE); */
pixDisplay(pixs, 100 + 20 * i, 100 + 20 * i);
}
pixd = pixs;
if (pixGetDepth(pixd) == 1)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixs);
#endif
#if 0
/* timing of various rotation operations (choose) */
startTimer();
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
for (i = 0; i < NTIMES; i++) {
pixd = pixRotateShearCenter(pixs, deg2rad * angle, L_BRING_IN_WHITE);
pixDestroy(&pixd);
}
pops = (l_float32)(w * h * NTIMES / 1000000.) / stopTimer();
fprintf(stderr, "vers. 1, mpops: %f\n", pops);
startTimer();
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
for (i = 0; i < NTIMES; i++) {
pixRotateShearIP(pixs, w/2, h/2, deg2rad * angle, L_BRING_IN_WHITE);
}
pops = (l_float32)(w * h * NTIMES / 1000000.) / stopTimer();
fprintf(stderr, "shear, mpops: %f\n", pops);
pixWrite(fileout, pixs, IFF_PNG);
for (i = 0; i < NTIMES; i++) {
pixRotateShearIP(pixs, w/2, h/2, -deg2rad * angle, L_BRING_IN_WHITE);
}
pixWrite("/usr/tmp/junkout", pixs, IFF_PNG);
#endif
#if 0
/* area-mapping rotation operations */
pixd = pixRotateAM(pixs, deg2rad * angle, L_BRING_IN_WHITE);
/* pixd = pixRotateAMColorFast(pixs, deg2rad * angle, 255); */
if (pixGetDepth(pixd) == 1)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
#endif
#if 0
/* compare the standard area-map color rotation with
* the fast area-map color rotation, on a pixel basis */
{
PIX *pix1, *pix2;
NUMA *nar, *nag, *nab, *naseq;
GPLOT *gplot;
startTimer();
pix1 = pixRotateAMColor(pixs, 0.12, 0xffffff00);
fprintf(stderr, " standard color rotate: %7.2f sec\n", stopTimer());
pixWrite("junkcolor1", pix1, IFF_JFIF_JPEG);
startTimer();
pix2 = pixRotateAMColorFast(pixs, 0.12, 0xffffff00);
fprintf(stderr, " fast color rotate: %7.2f sec\n", stopTimer());
pixWrite("junkcolor2", pix2, IFF_JFIF_JPEG);
pixd = pixAbsDifference(pix1, pix2);
pixGetColorHistogram(pixd, 1, &nar, &nag, &nab);
naseq = numaMakeSequence(0., 1., 256);
gplot = gplotCreate("junk_absdiff", GPLOT_X11, "Number vs diff",
"diff", "number");
gplotAddPlot(gplot, naseq, nar, GPLOT_POINTS, "red");
gplotAddPlot(gplot, naseq, nag, GPLOT_POINTS, "green");
gplotAddPlot(gplot, naseq, nab, GPLOT_POINTS, "blue");
gplotMakeOutput(gplot);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixd);
numaDestroy(&nar);
numaDestroy(&nag);
numaDestroy(&nab);
numaDestroy(&naseq);
gplotDestroy(&gplot);
}
#endif
/* Do a succession of 180 7-degree rotations in a cw
* direction, and unwind the result with another set in
* a ccw direction. Although there is a considerable amount
* of distortion after successive rotations, after all
* 360 rotations, the resulting image is restored to
* its original pristine condition! */
#if 1
rotflag = L_ROTATE_AREA_MAP;
/* rotflag = L_ROTATE_SHEAR; */
/* rotflag = L_ROTATE_SAMPLING; */
ang = 7.0 * deg2rad;
pixGetDimensions(pixs, &w, &h, NULL);
pixd = pixRotate(pixs, ang, rotflag, L_BRING_IN_WHITE, w, h);
pixWrite("junkrot7", pixd, IFF_PNG);
for (i = 1; i < 180; i++) {
pixs = pixd;
pixd = pixRotate(pixs, ang, rotflag, L_BRING_IN_WHITE, w, h);
if ((i % 30) == 0) pixDisplay(pixd, 600, 0);
pixDestroy(&pixs);
}
pixWrite("junkspin", pixd, IFF_PNG);
pixDisplay(pixd, 0, 0);
for (i = 0; i < 180; i++) {
pixs = pixd;
pixd = pixRotate(pixs, -ang, rotflag, L_BRING_IN_WHITE, w, h);
if (i && (i % 30) == 0) pixDisplay(pixd, 600, 500);
pixDestroy(&pixs);
}
pixWrite("junkunspin", pixd, IFF_PNG);
pixDisplay(pixd, 0, 500);
pixDestroy(&pixd);
#endif
return 0;
}
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, rank, startval, fbinsize;
l_float32 minval, maxval, meanval, median, variance, rankval;
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, *pixd;
PIXA *pixa;
static char mainName[] = "numa1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: numa1_reg", mainName, 1);
lept_mkdir("lept");
/* -------------------------------------------------------------------*
* Histograms *
* -------------------------------------------------------------------*/
#if DO_ALL
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/numa_histo1", GPLOT_X11, "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/numa_histo2", GPLOT_X11, "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/numa_histo3", GPLOT_X11, "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/numa_histo4", GPLOT_X11, "example histo 4",
"i", "histo[i]");
gplotAddPlot(gplot, nax, nahisto, GPLOT_LINES, "sine");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
numaDestroy(&nahisto);
numaGetStatsUsingHistogram(na, 2000, &minval, &maxval, &meanval,
&variance, &median, 0.80, &rankval, &nahisto);
fprintf(stderr, "Sin histogram: \n"
" min val = %7.2f -- should be -999.00\n"
" max val = %7.2f -- should be 999.00\n"
" mean val = %7.2f -- should be 0.06\n"
" median = %7.2f -- should be 0.30\n"
" rmsdev = %7.2f -- should be 706.41\n"
" rank val = %7.2f -- should be 808.15\n",
minval, maxval, meanval, median, sqrt((l_float64) variance),
rankval);
numaHistogramGetRankFromVal(nahisto, 808.15, &rank);
fprintf(stderr, " rank = %7.3f -- should be 0.800\n", rank);
numaDestroy(&nahisto);
numaDestroy(&na);
#endif
/* -------------------------------------------------------------------*
* Interpolation *
* -------------------------------------------------------------------*/
#if DO_ALL
/* Test numaInterpolateEqxInterval() */
pixs = pixRead("test8.jpg");
na = pixGetGrayHistogramMasked(pixs, NULL, 0, 0, 1);
/* numaWriteStream(stderr, na); */
nasy = numaGetPartialSums(na);
gplotSimple1(nasy, GPLOT_X11, "/tmp/lept/numa_int1", "partial sums");
gplotSimple1(na, GPLOT_X11, "/tmp/lept/numa_int2", "simple test");
numaInterpolateEqxInterval(0.0, 1.0, na, L_LINEAR_INTERP,
0.0, 255.0, 15, &nax, &nay);
gplot = gplotCreate("/tmp/lept/numa_int3", GPLOT_X11, "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);
#endif
#if DO_ALL
/* 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);
/* gplotSimple1(nasy, GPLOT_X11, "/tmp/numa/nasy", "partial sums"); */
numaInterpolateArbxInterval(nasx, nasy, L_LINEAR_INTERP,
10.0, 250.0, 23, &nax, &nay);
gplot = gplotCreate("/tmp/lept/numa_int4", GPLOT_X11, "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);
#endif
#if DO_ALL
/* 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);
/* gplotSimple1(nasy, GPLOT_X11, "/tmp/numa/nasy", "partial sums"); */
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/numa_int5", GPLOT_X11, "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);
#endif
#if DO_ALL
/* Test interpolation */
nasx = numaRead("testangle.na");
nasy = numaRead("testscore.na");
gplot = gplotCreate("/tmp/lept/numa_int6", GPLOT_X11, "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/numa_int7", GPLOT_X11, "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);
fprintf(stderr, "max = %f at loc = %f\n", yval, xval);
numaDestroy(&nasx);
numaDestroy(&nasy);
numaDestroy(&nax);
numaDestroy(&nay);
#endif
/* -------------------------------------------------------------------*
* Integration and differentiation *
* -------------------------------------------------------------------*/
#if DO_ALL
/* 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/numa_diff1", GPLOT_X11, "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/numa_diff2", GPLOT_X11, "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);
numaDestroy(&nasx);
numaDestroy(&nasy);
numaDestroy(&nafx);
numaDestroy(&nafy);
numaDestroy(&nadx);
numaDestroy(&nady);
numaDestroy(&nay);
#endif
/* -------------------------------------------------------------------*
* Rank extraction *
* -------------------------------------------------------------------*/
#if DO_ALL
/* 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/numa_rank1", GPLOT_X11,
"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);
#endif
#if DO_ALL
/* 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_X11, "/tmp/lept/numa_rank2", "rank value");
numaDestroy(&na);
numaDestroy(&nap);
pixDestroy(&pixs);
#endif
/* -------------------------------------------------------------------*
* Numa-morphology *
* -------------------------------------------------------------------*/
#if DO_ALL
na = numaRead("lyra.5.na");
gplotSimple1(na, GPLOT_PNG, "/tmp/lept/numa_lyra1", "Original");
na1 = numaErode(na, 21);
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/numa_lyra2", "Erosion");
na2 = numaDilate(na, 21);
gplotSimple1(na2, GPLOT_PNG, "/tmp/lept/numa_lyra3", "Dilation");
na3 = numaOpen(na, 21);
gplotSimple1(na3, GPLOT_PNG, "/tmp/lept/numa_lyra4", "Opening");
na4 = numaClose(na, 21);
gplotSimple1(na4, GPLOT_PNG, "/tmp/lept/numa_lyra5", "Closing");
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixa = pixaCreate(5);
pix1 = pixRead("/tmp/lept/numa_lyra1.png");
pix2 = pixRead("/tmp/lept/numa_lyra2.png");
pix3 = pixRead("/tmp/lept/numa_lyra3.png");
pix4 = pixRead("/tmp/lept/numa_lyra4.png");
pix5 = pixRead("/tmp/lept/numa_lyra5.png");
pixSaveTiled(pix1, pixa, 1.0, 1, 25, 32);
pixSaveTiled(pix2, pixa, 1.0, 1, 25, 32);
pixSaveTiled(pix3, pixa, 1.0, 0, 25, 32);
pixSaveTiled(pix4, pixa, 1.0, 1, 25, 32);
pixSaveTiled(pix5, pixa, 1.0, 0, 25, 32);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/lept/numa_morph.png", pixd, IFF_PNG);
numaDestroy(&na);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
pixaDestroy(&pixa);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pixd);
#endif
return 0;
}
/*!
* wshedApply()
*
* Input: wshed (generated from wshedCreate())
* Return: 0 if OK, 1 on error
*
* Iportant note:
* (1) This is buggy. It seems to locate watersheds that are
* duplicates. The watershed extraction after complete fill
* grabs some regions belonging to existing watersheds.
* See prog/watershedtest.c for testing.
*/
l_int32
wshedApply(L_WSHED *wshed) {
char two_new_watersheds[] = "Two new watersheds";
char seed_absorbed_into_seeded_basin[] = "Seed absorbed into seeded basin";
char one_new_watershed_label[] = "One new watershed (label)";
char one_new_watershed_index[] = "One new watershed (index)";
char minima_absorbed_into_seeded_basin[] =
"Minima absorbed into seeded basin";
char minima_absorbed_by_filler_or_another[] =
"Minima absorbed by filler or another";
l_int32 nseeds, nother, nboth, arraysize;
l_int32 i, j, val, x, y, w, h, index, mindepth;
l_int32 imin, imax, jmin, jmax, cindex, clabel, nindex;
l_int32 hindex, hlabel, hmin, hmax, minhindex, maxhindex;
l_int32 *lut;
l_uint32 ulabel, uval;
void **lines8, **linelab32;
NUMA *nalut, *nalevels, *nash, *namh, *nasi;
NUMA **links;
L_HEAP *lh;
PIX *pixmin, *pixsd;
PIXA *pixad;
L_STACK *rstack;
PTA *ptas, *ptao;
PROCNAME("wshedApply");
if (!wshed)
return ERROR_INT("wshed not defined", procName, 1);
/* ------------------------------------------------------------ *
* Initialize priority queue and pixlab with seeds and minima *
* ------------------------------------------------------------ */
lh = lheapCreate(0, L_SORT_INCREASING); /* remove lowest values first */
rstack = lstackCreate(0); /* for reusing the WSPixels */
pixGetDimensions(wshed->pixs, &w, &h, NULL);
lines8 = wshed->lines8; /* wshed owns this */
linelab32 = wshed->linelab32; /* ditto */
/* Identify seed (marker) pixels, 1 for each c.c. in pixm */
pixSelectMinInConnComp(wshed->pixs, wshed->pixm, &ptas, &nash);
pixsd = pixGenerateFromPta(ptas, w, h);
nseeds = ptaGetCount(ptas);
for (i = 0; i < nseeds; i++) {
ptaGetIPt(ptas, i, &x, &y);
uval = GET_DATA_BYTE(lines8[y], x);
pushWSPixel(lh, rstack, (l_int32) uval, x, y, i);
}
wshed->ptas = ptas;
nasi = numaMakeConstant(1, nseeds); /* indicator array */
wshed->nasi = nasi;
wshed->nash = nash;
wshed->nseeds = nseeds;
/* Identify minima that are not seeds. Use these 4 steps:
* (1) Get the local minima, which can have components
* of arbitrary size. This will be a clipping mask.
* (2) Get the image of the actual seeds (pixsd)
* (3) Remove all elements of the clipping mask that have a seed.
* (4) Shrink each of the remaining elements of the minima mask
* to a single pixel. */
pixLocalExtrema(wshed->pixs, 200, 0, &pixmin, NULL);
pixRemoveSeededComponents(pixmin, pixsd, pixmin, 8, 2);
pixSelectMinInConnComp(wshed->pixs, pixmin, &ptao, &namh);
nother = ptaGetCount(ptao);
for (i = 0; i < nother; i++) {
ptaGetIPt(ptao, i, &x, &y);
uval = GET_DATA_BYTE(lines8[y], x);
pushWSPixel(lh, rstack, (l_int32) uval, x, y, nseeds + i);
}
wshed->namh = namh;
/* ------------------------------------------------------------ *
* Initialize merging lookup tables *
* ------------------------------------------------------------ */
/* nalut should always give the current after-merging index.
* links are effectively backpointers: they are numas associated with
* a dest index of all indices in nalut that point to that index. */
mindepth = wshed->mindepth;
nboth = nseeds + nother;
arraysize = 2 * nboth;
wshed->arraysize = arraysize;
nalut = numaMakeSequence(0, 1, arraysize);
lut = numaGetIArray(nalut);
wshed->lut = lut; /* wshed owns this */
links = (NUMA **) CALLOC(arraysize, sizeof(NUMA * ));
wshed->links = links; /* wshed owns this */
nindex = nseeds + nother; /* the next unused index value */
/* ------------------------------------------------------------ *
* Fill the basins, using the priority queue *
* ------------------------------------------------------------ */
pixad = pixaCreate(nseeds);
wshed->pixad = pixad; /* wshed owns this */
nalevels = numaCreate(nseeds);
wshed->nalevels = nalevels; /* wshed owns this */
L_INFO("nseeds = %d, nother = %d\n", procName, nseeds, nother);
while (lheapGetCount(lh) > 0) {
popWSPixel(lh, rstack, &val, &x, &y, &index);
/* fprintf(stderr, "x = %d, y = %d, index = %d\n", x, y, index); */
ulabel = GET_DATA_FOUR_BYTES(linelab32[y], x);
if (ulabel == MAX_LABEL_VALUE)
clabel = ulabel;
else
clabel = lut[ulabel];
cindex = lut[index];
if (clabel == cindex) continue; /* have already seen this one */
if (clabel == MAX_LABEL_VALUE) { /* new one; assign index and try to
* propagate to all neighbors */
SET_DATA_FOUR_BYTES(linelab32[y], x, cindex);
imin = L_MAX(0, y - 1);
imax = L_MIN(h - 1, y + 1);
jmin = L_MAX(0, x - 1);
jmax = L_MIN(w - 1, x + 1);
for (i = imin; i <= imax; i++) {
for (j = jmin; j <= jmax; j++) {
if (i == y && j == x) continue;
uval = GET_DATA_BYTE(lines8[i], j);
pushWSPixel(lh, rstack, (l_int32) uval, j, i, cindex);
}
}
} else { /* pixel is already labeled (differently); must resolve */
/* If both indices are seeds, check if the min height is
* greater than mindepth. If so, we have two new watersheds;
* locate them and assign to both regions a new index
* for further waterfill. If not, absorb the shallower
* watershed into the deeper one and continue filling it. */
pixGetPixel(pixsd, x, y, &uval);
if (clabel < nseeds && cindex < nseeds) {
wshedGetHeight(wshed, val, clabel, &hlabel);
wshedGetHeight(wshed, val, cindex, &hindex);
hmin = L_MIN(hlabel, hindex);
hmax = L_MAX(hlabel, hindex);
if (hmin == hmax) {
hmin = hlabel;
hmax = hindex;
}
if (wshed->debug) {
fprintf(stderr, "clabel,hlabel = %d,%d\n", clabel, hlabel);
fprintf(stderr, "hmin = %d, hmax = %d\n", hmin, hmax);
fprintf(stderr, "cindex,hindex = %d,%d\n", cindex, hindex);
if (hmin < mindepth)
fprintf(stderr, "Too shallow!\n");
}
if (hmin >= mindepth) {
debugWshedMerge(wshed, two_new_watersheds,
x, y, clabel, cindex);
wshedSaveBasin(wshed, cindex, val - 1);
wshedSaveBasin(wshed, clabel, val - 1);
numaSetValue(nasi, cindex, 0);
numaSetValue(nasi, clabel, 0);
if (wshed->debug) fprintf(stderr, "nindex = %d\n", nindex);
debugPrintLUT(lut, nindex, wshed->debug);
mergeLookup(wshed, clabel, nindex);
debugPrintLUT(lut, nindex, wshed->debug);
mergeLookup(wshed, cindex, nindex);
debugPrintLUT(lut, nindex, wshed->debug);
nindex++;
} else /* extraneous seed within seeded basin; absorb */ {
debugWshedMerge(wshed, seed_absorbed_into_seeded_basin,
x, y, clabel, cindex);
}
maxhindex = clabel; /* TODO: is this part of above 'else'? */
minhindex = cindex;
if (hindex > hlabel) {
maxhindex = cindex;
minhindex = clabel;
}
mergeLookup(wshed, minhindex, maxhindex);
} else if (clabel < nseeds && cindex >= nboth) {
/* If one index is a seed and the other is a merge of
* 2 watersheds, generate a single watershed. */
debugWshedMerge(wshed, one_new_watershed_label,
x, y, clabel, cindex);
wshedSaveBasin(wshed, clabel, val - 1);
numaSetValue(nasi, clabel, 0);
mergeLookup(wshed, clabel, cindex);
} else if (cindex < nseeds && clabel >= nboth) {
debugWshedMerge(wshed, one_new_watershed_index,
x, y, clabel, cindex);
wshedSaveBasin(wshed, cindex, val - 1);
numaSetValue(nasi, cindex, 0);
mergeLookup(wshed, cindex, clabel);
} else if (clabel < nseeds) { /* cindex from minima; absorb */
/* If one index is a seed and the other is from a minimum,
* merge the minimum wshed into the seed wshed. */
debugWshedMerge(wshed, minima_absorbed_into_seeded_basin,
x, y, clabel, cindex);
mergeLookup(wshed, cindex, clabel);
} else if (cindex < nseeds) { /* clabel from minima; absorb */
debugWshedMerge(wshed, minima_absorbed_into_seeded_basin,
x, y, clabel, cindex);
mergeLookup(wshed, clabel, cindex);
} else { /* If neither index is a seed, just merge */
debugWshedMerge(wshed, minima_absorbed_by_filler_or_another,
x, y, clabel, cindex);
mergeLookup(wshed, clabel, cindex);
}
}
}
#if 0
/* Use the indicator array to save any watersheds that fill
* to the maximum value. This seems to screw things up! */
for (i = 0; i < nseeds; i++) {
numaGetIValue(nasi, i, &ival);
if (ival == 1) {
wshedSaveBasin(wshed, lut[i], val - 1);
numaSetValue(nasi, i, 0);
}
}
#endif
numaDestroy(&nalut);
pixDestroy(&pixmin);
pixDestroy(&pixsd);
ptaDestroy(&ptao);
lheapDestroy(&lh, TRUE);
lstackDestroy(&rstack, TRUE);
return 0;
}
int main(int argc,
char **argv)
{
char *selname;
l_int32 i, j, nsels, sx, sy;
l_float32 fact, time;
GPLOT *gplot;
NUMA *na1, *na2, *na3, *na4, *nac1, *nac2, *nac3, *nac4, *nax;
PIX *pixs, *pixt;
PIXA *pixa;
SEL *sel;
SELA *selalinear;
static char mainName[] = "dwamorph2_reg";
if (argc != 1)
return ERROR_INT(" Syntax: dwamorph2_reg", mainName, 1);
pixs = pixRead("feyn-fract.tif");
pixt = pixCreateTemplate(pixs);
selalinear = selaAddDwaLinear(NULL);
nsels = selaGetCount(selalinear);
fact = 1000. / (l_float32)NTIMES; /* converts to time in msec */
na1 = numaCreate(64);
na2 = numaCreate(64);
na3 = numaCreate(64);
na4 = numaCreate(64);
lept_mkdir("lept/morph");
/* --------- dilation ----------*/
for (i = 0; i < nsels / 2; i++)
{
sel = selaGetSel(selalinear, i);
selGetParameters(sel, &sy, &sx, NULL, NULL);
selname = selGetName(sel);
fprintf(stderr, " %d .", i);
startTimer();
for (j = 0; j < NTIMES; j++)
pixDilate(pixt, pixs, sel);
time = fact * stopTimer();
numaAddNumber(na1, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixDilateCompBrick(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na2, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixMorphDwa_3(pixt, pixs, L_MORPH_DILATE, selname);
time = fact * stopTimer();
numaAddNumber(na3, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixDilateCompBrickDwa(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na4, time);
}
nax = numaMakeSequence(2, 1, nsels / 2);
nac1 = numaWindowedMean(na1, HALFWIDTH);
nac2 = numaWindowedMean(na2, HALFWIDTH);
nac3 = numaWindowedMean(na3, HALFWIDTH);
nac4 = numaWindowedMean(na4, HALFWIDTH);
gplot = gplotCreate("/tmp/lept/morph/dilate", GPLOT_PNG,
"Dilation time vs sel size", "size", "time (ms)");
gplotAddPlot(gplot, nax, nac1, GPLOT_LINES, "linear rasterop");
gplotAddPlot(gplot, nax, nac2, GPLOT_LINES, "composite rasterop");
gplotAddPlot(gplot, nax, nac3, GPLOT_LINES, "linear dwa");
gplotAddPlot(gplot, nax, nac4, GPLOT_LINES, "composite dwa");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nac1);
numaDestroy(&nac2);
numaDestroy(&nac3);
numaDestroy(&nac4);
/* --------- erosion ----------*/
numaEmpty(na1);
numaEmpty(na2);
numaEmpty(na3);
numaEmpty(na4);
for (i = 0; i < nsels / 2; i++)
{
sel = selaGetSel(selalinear, i);
selGetParameters(sel, &sy, &sx, NULL, NULL);
selname = selGetName(sel);
fprintf(stderr, " %d .", i);
startTimer();
for (j = 0; j < NTIMES; j++)
pixErode(pixt, pixs, sel);
time = fact * stopTimer();
numaAddNumber(na1, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixErodeCompBrick(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na2, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixMorphDwa_3(pixt, pixs, L_MORPH_ERODE, selname);
time = fact * stopTimer();
numaAddNumber(na3, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixErodeCompBrickDwa(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na4, time);
}
nac1 = numaWindowedMean(na1, HALFWIDTH);
nac2 = numaWindowedMean(na2, HALFWIDTH);
nac3 = numaWindowedMean(na3, HALFWIDTH);
nac4 = numaWindowedMean(na4, HALFWIDTH);
gplot = gplotCreate("/tmp/lept/morph/erode", GPLOT_PNG,
"Erosion time vs sel size", "size", "time (ms)");
gplotAddPlot(gplot, nax, nac1, GPLOT_LINES, "linear rasterop");
gplotAddPlot(gplot, nax, nac2, GPLOT_LINES, "composite rasterop");
gplotAddPlot(gplot, nax, nac3, GPLOT_LINES, "linear dwa");
gplotAddPlot(gplot, nax, nac4, GPLOT_LINES, "composite dwa");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nac1);
numaDestroy(&nac2);
numaDestroy(&nac3);
numaDestroy(&nac4);
/* --------- opening ----------*/
numaEmpty(na1);
numaEmpty(na2);
numaEmpty(na3);
numaEmpty(na4);
for (i = 0; i < nsels / 2; i++)
{
sel = selaGetSel(selalinear, i);
selGetParameters(sel, &sy, &sx, NULL, NULL);
selname = selGetName(sel);
fprintf(stderr, " %d .", i);
startTimer();
for (j = 0; j < NTIMES; j++)
pixOpen(pixt, pixs, sel);
time = fact * stopTimer();
numaAddNumber(na1, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixOpenCompBrick(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na2, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixMorphDwa_3(pixt, pixs, L_MORPH_OPEN, selname);
time = fact * stopTimer();
numaAddNumber(na3, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixOpenCompBrickDwa(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na4, time);
}
nac1 = numaWindowedMean(na1, HALFWIDTH);
nac2 = numaWindowedMean(na2, HALFWIDTH);
nac3 = numaWindowedMean(na3, HALFWIDTH);
nac4 = numaWindowedMean(na4, HALFWIDTH);
gplot = gplotCreate("/tmp/lept/morph/open", GPLOT_PNG,
"Opening time vs sel size", "size", "time (ms)");
gplotAddPlot(gplot, nax, nac1, GPLOT_LINES, "linear rasterop");
gplotAddPlot(gplot, nax, nac2, GPLOT_LINES, "composite rasterop");
gplotAddPlot(gplot, nax, nac3, GPLOT_LINES, "linear dwa");
gplotAddPlot(gplot, nax, nac4, GPLOT_LINES, "composite dwa");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nac1);
numaDestroy(&nac2);
numaDestroy(&nac3);
numaDestroy(&nac4);
/* --------- closing ----------*/
numaEmpty(na1);
numaEmpty(na2);
numaEmpty(na3);
numaEmpty(na4);
for (i = 0; i < nsels / 2; i++)
{
sel = selaGetSel(selalinear, i);
selGetParameters(sel, &sy, &sx, NULL, NULL);
selname = selGetName(sel);
fprintf(stderr, " %d .", i);
startTimer();
for (j = 0; j < NTIMES; j++)
pixClose(pixt, pixs, sel);
time = fact * stopTimer();
numaAddNumber(na1, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixCloseCompBrick(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na2, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixMorphDwa_3(pixt, pixs, L_MORPH_CLOSE, selname);
time = fact * stopTimer();
numaAddNumber(na3, time);
startTimer();
for (j = 0; j < NTIMES; j++)
pixCloseCompBrickDwa(pixt, pixs, sx, sy);
time = fact * stopTimer();
numaAddNumber(na4, time);
}
nac1 = numaWindowedMean(na1, HALFWIDTH);
nac2 = numaWindowedMean(na2, HALFWIDTH);
nac3 = numaWindowedMean(na3, HALFWIDTH);
nac4 = numaWindowedMean(na4, HALFWIDTH);
gplot = gplotCreate("/tmp/lept/morph/close", GPLOT_PNG,
"Closing time vs sel size", "size", "time (ms)");
gplotAddPlot(gplot, nax, nac1, GPLOT_LINES, "linear rasterop");
gplotAddPlot(gplot, nax, nac2, GPLOT_LINES, "composite rasterop");
gplotAddPlot(gplot, nax, nac3, GPLOT_LINES, "linear dwa");
gplotAddPlot(gplot, nax, nac4, GPLOT_LINES, "composite dwa");
gplotMakeOutput(gplot);
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
gplotDestroy(&gplot);
numaDestroy(&nac1);
numaDestroy(&nac2);
numaDestroy(&nac3);
numaDestroy(&nac4);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
numaDestroy(&na4);
numaDestroy(&nax);
selaDestroy(&selalinear);
pixDestroy(&pixt);
pixDestroy(&pixs);
/* Display the results together */
pixa = pixaCreate(0);
pixs = pixRead("/tmp/lept/morph/dilate.png");
pixaAddPix(pixa, pixs, L_INSERT);
pixs = pixRead("/tmp/lept/morph/erode.png");
pixaAddPix(pixa, pixs, L_INSERT);
pixs = pixRead("/tmp/lept/morph/open.png");
pixaAddPix(pixa, pixs, L_INSERT);
pixs = pixRead("/tmp/lept/morph/close.png");
pixaAddPix(pixa, pixs, L_INSERT);
pixt = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 40, 3);
pixWrite("/tmp/lept/morph/timings.png", pixt, IFF_PNG);
pixDisplay(pixt, 100, 100);
pixDestroy(&pixt);
pixaDestroy(&pixa);
return 0;
}
main(int argc,
char **argv)
{
PIX *pixs;
l_int32 d;
static char mainName[] = "scaletest2";
if (argc != 2)
return ERROR_INT(" Syntax: scaletest2 filein", mainName, 1);
if ((pixs = pixRead(argv[1])) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
d = pixGetDepth(pixs);
#if 1
/* Integer scale-to-gray functions */
if (d == 1)
{
PIX *pixd;
pixd = pixScaleToGray2(pixs);
pixWrite("/tmp/s2g_2x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray3(pixs);
pixWrite("/tmp/s2g_3x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray4(pixs);
pixWrite("/tmp/s2g_4x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray6(pixs);
pixWrite("/tmp/s2g_6x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray8(pixs);
pixWrite("/tmp/s2g_8x", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray16(pixs);
pixWrite("/tmp/s2g_16x", pixd, IFF_PNG);
pixDestroy(&pixd);
}
#endif
#if 1
/* Various non-integer scale-to-gray, compared with
* with different ways of getting similar results */
if (d == 1)
{
PIX *pixt, *pixd;
pixd = pixScaleToGray8(pixs);
pixWrite("/tmp/s2g_8.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray(pixs, 0.124);
pixWrite("/tmp/s2g_124.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixd = pixScaleToGray(pixs, 0.284);
pixWrite("/tmp/s2g_284.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleBySampling(pixt, 284./250., 284./250.);
pixWrite("/tmp/s2g_284.2.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleGrayLI(pixt, 284./250., 284./250.);
pixWrite("/tmp/s2g_284.3.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleBinary(pixs, 284./250., 284./250.);
pixd = pixScaleToGray4(pixt);
pixWrite("/tmp/s2g_284.4.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleGrayLI(pixt, 0.49, 0.49);
pixWrite("/tmp/s2g_42.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleToGray4(pixs);
pixd = pixScaleSmooth(pixt, 0.49, 0.49);
pixWrite("/tmp/s2g_4sm.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixt = pixScaleBinary(pixs, .16/.125, .16/.125);
pixd = pixScaleToGray8(pixt);
pixWrite("/tmp/s2g_16.png", pixd, IFF_PNG);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixd = pixScaleToGray(pixs, .16);
pixWrite("/tmp/s2g_16.2.png", pixd, IFF_PNG);
pixDestroy(&pixd);
}
#endif
#if 1
/* Antialiased (smoothed) reduction, along with sharpening */
if (d != 1)
{
PIX *pixt1, *pixt2;
startTimer();
pixt1 = pixScaleSmooth(pixs, 0.154, 0.154);
fprintf(stderr, "fast scale: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt1, 0, 0, "smooth scaling", DISPLAY);
pixWrite("/tmp/smooth1.png", pixt1, IFF_PNG);
pixt2 = pixUnsharpMasking(pixt1, 1, 0.3);
pixWrite("/tmp/smooth2.png", pixt2, IFF_PNG);
pixDisplayWithTitle(pixt2, 200, 0, "sharp scaling", DISPLAY);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
#endif
#if 1
/* Test a large range of scale-to-gray reductions */
if (d == 1)
{
l_int32 i;
l_float32 scale;
PIX *pixd;
for (i = 2; i < 15; i++) {
scale = 1. / (l_float32)i;
startTimer();
pixd = pixScaleToGray(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 75 * i, 100, "scaletogray", DISPLAY);
pixDestroy(&pixd);
}
for (i = 8; i < 14; i++) {
scale = 1. / (l_float32)(2 * i);
startTimer();
pixd = pixScaleToGray(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 100 * i, 600, "scaletogray", DISPLAY);
pixDestroy(&pixd);
}
}
#endif
#if 1
/* Test the same range of scale-to-gray mipmap reductions */
if (d == 1)
{
l_int32 i;
l_float32 scale;
PIX *pixd;
for (i = 2; i < 15; i++) {
scale = 1. / (l_float32)i;
startTimer();
pixd = pixScaleToGrayMipmap(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 75 * i, 100, "scale mipmap", DISPLAY);
pixDestroy(&pixd);
}
for (i = 8; i < 12; i++) {
scale = 1. / (l_float32)(2 * i);
startTimer();
pixd = pixScaleToGrayMipmap(pixs, scale);
fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n",
scale, stopTimer());
pixDisplayWithTitle(pixd, 100 * i, 600, "scale mipmap", DISPLAY);
pixDestroy(&pixd);
}
}
#endif
#if 1
/* Test several methods for antialiased reduction,
* along with sharpening */
if (d != 1)
{
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6, *pixt7;
l_float32 SCALING = 0.27;
l_int32 SIZE = 7;
l_int32 smooth;
l_float32 FRACT = 1.0;
smooth = SIZE / 2;
startTimer();
pixt1 = pixScaleSmooth(pixs, SCALING, SCALING);
fprintf(stderr, "fast scale: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt1, 0, 0, "smooth scaling", DISPLAY);
pixWrite("/tmp/sm_1.png", pixt1, IFF_PNG);
pixt2 = pixUnsharpMasking(pixt1, 1, 0.3);
pixDisplayWithTitle(pixt2, 150, 0, "sharpened scaling", DISPLAY);
startTimer();
pixt3 = pixBlockconv(pixs, smooth, smooth);
pixt4 = pixScaleBySampling(pixt3, SCALING, SCALING);
fprintf(stderr, "slow scale: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt4, 200, 200, "sampled scaling", DISPLAY);
pixWrite("/tmp/sm_2.png", pixt4, IFF_PNG);
startTimer();
pixt5 = pixUnsharpMasking(pixs, smooth, FRACT);
pixt6 = pixBlockconv(pixt5, smooth, smooth);
pixt7 = pixScaleBySampling(pixt6, SCALING, SCALING);
fprintf(stderr, "very slow scale + sharp: %5.3f sec\n", stopTimer());
pixDisplayWithTitle(pixt7, 500, 200, "sampled scaling", DISPLAY);
pixWrite("/tmp/sm_3.jpg", pixt7, IFF_JFIF_JPEG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
}
#endif
#if 1
/* Test the color scaling function, comparing the
* special case of scaling factor 2.0 with the
* general case. */
if (d == 32)
{
PIX *pix1, *pix2, *pixd;
NUMA *nar, *nag, *nab, *naseq;
GPLOT *gplot;
startTimer();
pix1 = pixScaleColorLI(pixs, 2.00001, 2.0);
fprintf(stderr, " Time with regular LI: %7.3f\n", stopTimer());
pixWrite("/tmp/color1.jpg", pix1, IFF_JFIF_JPEG);
startTimer();
pix2 = pixScaleColorLI(pixs, 2.0, 2.0);
fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer());
pixWrite("/tmp/color2.jpg", pix2, IFF_JFIF_JPEG);
pixd = pixAbsDifference(pix1, pix2);
pixGetColorHistogram(pixd, 1, &nar, &nag, &nab);
naseq = numaMakeSequence(0., 1., 256);
gplot = gplotCreate("/tmp/plot_absdiff", GPLOT_X11, "Number vs diff",
"diff", "number");
gplotSetScaling(gplot, GPLOT_LOG_SCALE_Y);
gplotAddPlot(gplot, naseq, nar, GPLOT_POINTS, "red");
gplotAddPlot(gplot, naseq, nag, GPLOT_POINTS, "green");
gplotAddPlot(gplot, naseq, nab, GPLOT_POINTS, "blue");
gplotMakeOutput(gplot);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixd);
numaDestroy(&naseq);
numaDestroy(&nar);
numaDestroy(&nag);
numaDestroy(&nab);
gplotDestroy(&gplot);
}
#endif
#if 1
/* Test the gray LI scaling function, comparing the
* special cases of scaling factor 2.0 and 4.0 with the
* general case */
if (d == 8 || d == 32)
{
PIX *pixt, *pix0, *pix1, *pix2, *pixd;
NUMA *nagray, *naseq;
GPLOT *gplot;
if (d == 8)
pixt = pixClone(pixs);
else
pixt = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33);
pix0 = pixScaleGrayLI(pixt, 0.5, 0.5);
#if 1
startTimer();
pix1 = pixScaleGrayLI(pix0, 2.00001, 2.0);
fprintf(stderr, " Time with regular LI 2x: %7.3f\n", stopTimer());
startTimer();
pix2 = pixScaleGrayLI(pix0, 2.0, 2.0);
fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer());
#else
startTimer();
pix1 = pixScaleGrayLI(pix0, 4.00001, 4.0);
fprintf(stderr, " Time with regular LI 4x: %7.3f\n", stopTimer());
startTimer();
pix2 = pixScaleGrayLI(pix0, 4.0, 4.0);
fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer());
#endif
pixWrite("/tmp/gray1", pix1, IFF_JFIF_JPEG);
pixWrite("/tmp/gray2", pix2, IFF_JFIF_JPEG);
pixd = pixAbsDifference(pix1, pix2);
nagray = pixGetGrayHistogram(pixd, 1);
naseq = numaMakeSequence(0., 1., 256);
gplot = gplotCreate("/tmp/g_absdiff", GPLOT_X11, "Number vs diff",
"diff", "number");
gplotSetScaling(gplot, GPLOT_LOG_SCALE_Y);
gplotAddPlot(gplot, naseq, nagray, GPLOT_POINTS, "gray");
gplotMakeOutput(gplot);
pixDestroy(&pixt);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixd);
numaDestroy(&naseq);
numaDestroy(&nagray);
gplotDestroy(&gplot);
}
#endif
pixDestroy(&pixs);
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout;
char bigbuf[512];
l_int32 iplot;
l_float32 factor; /* scaled width of atan curve */
l_float32 fact[NPLOTS] = {.2, 0.4, 0.6, 0.8, 1.0};
GPLOT *gplot;
NUMA *na, *nax;
PIX *pixs, *pixd;
static char mainName[] = "contrasttest";
if (argc != 4)
return ERROR_INT(" Syntax: contrasttest filein factor fileout",
mainName, 1);
filein = argv[1];
factor = atof(argv[2]);
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
#if 0
startTimer();
pixContrastTRC(pixs, pixs, factor);
fprintf(stderr, "Time for contrast: %7.3f sec\n", stopTimer());
pixWrite(fileout, pixs, IFF_JFIF_JPEG);
pixDestroy(&pixs);
#endif
#if 0
startTimer();
pixd = pixContrastTRC(NULL, pixs, factor);
fprintf(stderr, "Time for contrast: %7.3f sec\n", stopTimer());
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixs);
pixDestroy(&pixd);
#endif
na = numaContrastTRC(factor);
gplotSimple1(na, GPLOT_X11, "junkroot", "contrast trc");
numaDestroy(&na);
#if 1 /* plot contrast TRC maps */
nax = numaMakeSequence(0.0, 1.0, 256);
gplot = gplotCreate("junkmap", GPLOT_X11,
"Atan mapping function for contrast enhancement",
"value in", "value out");
for (iplot = 0; iplot < NPLOTS; iplot++) {
na = numaContrastTRC(fact[iplot]);
sprintf(bigbuf, "factor = %3.1f", fact[iplot]);
gplotAddPlot(gplot, nax, na, GPLOT_LINES, bigbuf);
numaDestroy(&na);
}
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
#endif
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout;
char bigbuf[512];
l_int32 iplot;
l_float32 gam;
l_float64 gamma[NPLOTS] = {.5, 1.0, 1.5, 2.0, 2.5};
GPLOT *gplot;
NUMA *na, *nax;
PIX *pixs, *pixd;
static char mainName[] = "gammatest";
if (argc != 4)
exit(ERROR_INT(" Syntax: gammatest filein gam fileout", mainName, 1));
filein = argv[1];
gam = atof(argv[2]);
fileout = argv[3];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
#if 1
startTimer();
pixGammaTRC(pixs, pixs, gam, MINVAL, MAXVAL);
fprintf(stderr, "Time for gamma: %7.3f sec\n", stopTimer());
pixWrite(fileout, pixs, IFF_JFIF_JPEG);
pixDestroy(&pixs);
#endif
#if 0
startTimer();
pixd = pixGammaTRC(NULL, pixs, gam, MINVAL, MAXVAL);
fprintf(stderr, "Time for gamma: %7.3f sec\n", stopTimer());
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixs);
pixDestroy(&pixd);
#endif
na = numaGammaTRC(gam, MINVAL, MAXVAL);
gplotSimple1(na, GPLOT_X11, "/tmp/junkroot", "gamma trc");
numaDestroy(&na);
#if 1 /* plot gamma TRC maps */
gplot = gplotCreate("/tmp/junkmap", GPLOT_X11,
"Mapping function for gamma correction",
"value in", "value out");
nax = numaMakeSequence(0.0, 1.0, 256);
for (iplot = 0; iplot < NPLOTS; iplot++) {
na = numaGammaTRC(gamma[iplot], 30, 215);
sprintf(bigbuf, "gamma = %3.1f", gamma[iplot]);
gplotAddPlot(gplot, nax, na, GPLOT_LINES, bigbuf);
numaDestroy(&na);
}
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&nax);
#endif
return 0;
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb; /* for color content extraction */
PIXA *pixa, *pixat;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate a pdf of results when called with display */
pixa = pixaCreate(0);
/* Generate colors by sampling hue with max sat and value.
* This image has been saved as 19-colors.png. */
pixat = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixat, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixat, 32, 1100, 1.0, 0, 0, 0);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 0 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixaDestroy(&pixat);
/* Colorspace conversion in rgb */
pixs = pixRead("wyom.jpg");
pixaAddPix(pixa, pixs, L_INSERT);
pixt = pixConvertRGBToHSV(NULL, pixs);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_COPY);
pixConvertHSVToRGB(pixt, pixt);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 2 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 3 */
pixaAddPix(pixa, pixt, L_COPY);
cmap = pixGetColormap(pixt);
if (rp->display) pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixcmapConvertHSVToRGB(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
regTestWritePixAndCheck(rp, pixr, IFF_JFIF_JPEG); /* 6 */
pixaAddPix(pixa, pixr, L_INSERT);
regTestWritePixAndCheck(rp, pixg, IFF_JFIF_JPEG); /* 7 */
pixaAddPix(pixa, pixg, L_INSERT);
regTestWritePixAndCheck(rp, pixb, IFF_JFIF_JPEG); /* 8 */
pixaAddPix(pixa, pixb, L_INSERT);
/* Color content measurement. This tests the global
* mapping of (r,g,b) --> (white), for 20 different
* values of (r,g,b). For each mappings, we compute
* the color magnitude and threshold it at six values.
* For each of those six thresholds, we plot the
* fraction of pixels that exceeds the threshold
* color magnitude, where the red value (mapped to
* white) goes between 100 and 195. */
pixat = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixat, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/regout/colorspace.10", GPLOT_PNG,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/regout/colorspace.11", GPLOT_PNG,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixat, 32, 250, 4, 0, 10, 2);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 9 */
pixaAddPix(pixa, pixt1, L_INSERT);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", rp->display);
pixaDestroy(&pixat);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
/* Give gnuplot time to write out the files */
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
/* Save as golden files, or check against them */
regTestCheckFile(rp, "/tmp/regout/colorspace.10.png"); /* 10 */
regTestCheckFile(rp, "/tmp/regout/colorspace.11.png"); /* 11 */
if (rp->display) {
pixt = pixRead("/tmp/regout/colorspace.10.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixt = pixRead("/tmp/regout/colorspace.11.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixaConvertToPdf(pixa, 0, 1.0, 0, 0, "colorspace tests",
"/tmp/regout/colorspace.pdf");
L_INFO("Output pdf: /tmp/regout/colorspace.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}