void DoJp2kTest1(L_REGPARAMS *rp,
const char *fname)
{
char buf[256];
l_int32 w, h;
BOX *box;
PIX *pix1, *pix2, *pix3;
pix1 = pixRead(fname);
pixGetDimensions(pix1, &w, &h, NULL);
box = boxCreate(w / 4, h / 4, w / 2, h / 2);
snprintf(buf, sizeof(buf), "/tmp/lept/jp2kio.%03d.jp2", rp->index + 1);
pixWrite(buf, pix1, IFF_JP2);
regTestCheckFile(rp, buf);
pix2 = pixRead(buf);
pixDisplayWithTitle(pix2, 0, 100, "1", rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pix1 = pixReadJp2k(buf, 1, box, 0, 0); /* just read the box region */
snprintf(buf, sizeof(buf), "/tmp/lept/jp2kio.%03d.jp2", rp->index + 1);
pixWriteJp2k(buf, pix1, 38, 0, 0, 0);
regTestCheckFile(rp, buf);
pix2 = pixRead(buf);
regTestWritePixAndCheck(rp, pix2, IFF_JP2);
pixDisplayWithTitle(pix2, 500, 100, "2", rp->display);
pix3 = pixReadJp2k(buf, 2, NULL, 0, 0); /* read image at 2x reduction */
regTestWritePixAndCheck(rp, pix3, IFF_JP2);
pixDisplayWithTitle(pix3, 1000, 100, "3", rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
return;
}
main(int argc,
char **argv)
{
PIX *pix;
SEL *sel;
SELA *sela1, *sela2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* selaRead() / selaWrite() */
sela1 = selaAddBasic(NULL);
selaWrite("/tmp/sel.0.sela", sela1);
regTestCheckFile(rp, "/tmp/sel.0.sela"); /* 0 */
sela2 = selaRead("/tmp/sel.0.sela");
selaWrite("/tmp/sel.1.sela", sela2);
regTestCheckFile(rp, "/tmp/sel.1.sela"); /* 1 */
regTestCompareFiles(rp, 0, 1); /* 2 */
selaDestroy(&sela1);
selaDestroy(&sela2);
/* Create from file and display result */
sela1 = selaCreateFromFile("flipsels.txt");
pix = selaDisplayInPix(sela1, 31, 3, 15, 4);
regTestWritePixAndCheck(rp, pix, IFF_PNG); /* 3 */
pixDisplayWithTitle(pix, 100, 100, NULL, rp->display);
selaWrite("/tmp/sel.3.sela", sela1);
regTestCheckFile(rp, "/tmp/sel.3.sela"); /* 4 */
pixDestroy(&pix);
selaDestroy(&sela1);
/* Create the same set of Sels from compiled strings and compare */
sela2 = selaCreate(4);
sel = selCreateFromString(textsel1, 5, 6, "textsel1");
selaAddSel(sela2, sel, NULL, 0);
sel = selCreateFromString(textsel2, 5, 6, "textsel2");
selaAddSel(sela2, sel, NULL, 0);
sel = selCreateFromString(textsel3, 5, 6, "textsel3");
selaAddSel(sela2, sel, NULL, 0);
sel = selCreateFromString(textsel4, 5, 6, "textsel4");
selaAddSel(sela2, sel, NULL, 0);
selaWrite("/tmp/sel.4.sela", sela2);
regTestCheckFile(rp, "/tmp/sel.4.sela"); /* 5 */
regTestCompareFiles(rp, 4, 5); /* 6 */
selaDestroy(&sela2);
return regTestCleanup(rp);
}
void DoWebpTest1(L_REGPARAMS *rp,
const char *fname)
{
char buf[256];
PIX *pixs, *pix1, *pix2;
startTimer();
pixs = pixRead(fname);
fprintf(stderr, "Time to read jpg: %7.3f\n", stopTimer());
startTimer();
snprintf(buf, sizeof(buf), "/tmp/lept/webp/webpio.%d.webp", rp->index + 1);
pixWrite(buf, pixs, IFF_WEBP);
fprintf(stderr, "Time to write webp: %7.3f\n", stopTimer());
regTestCheckFile(rp, buf);
startTimer();
pix1 = pixRead(buf);
fprintf(stderr, "Time to read webp: %7.3f\n", stopTimer());
pix2 = pixConvertTo32(pixs);
regTestCompareSimilarPix(rp, pix1, pix2, 20, 0.1, 0);
pixDisplayWithTitle(pix1, 100, 100, "pix1", rp->display);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
return;
}
/*!
* regTestWritePixAndCheck()
*
* Input: pix (to be written)
* format (of output pix)
* &count (index to be written into filename)
* rp (regression test params; required here)
* Return: 0 if OK, 1 on error (a failure in comparison is not an error)
*
* Notes:
* (1) This function makes it easy to write the pix in a numbered
* sequence of files, and either write the golden files (with
* the "generate" argument to the regression test) or compare
* the written file with an existing golden file.
* (2) This function can be called repeatedly in a single reg test.
* Each time it is called, the count is incremented.
* (3) The canonical format of the local filename is:
* /tmp/<root of main name>.<count>.<format extension string>
* e.g., for scale_reg,
* /tmp/scale.0.png
*/
l_int32
regTestWritePixAndCheck(PIX *pix,
l_int32 format,
l_int32 *pcount,
L_REGPARAMS *rp)
{
char *root;
char namebuf[256];
PROCNAME("regTestWritePixAndCheck");
if (!pix)
return ERROR_INT("pix not defined", procName, 1);
if (!pcount)
return ERROR_INT("&count not defined", procName, 1);
if (format < 0 || format >= NumImageFileFormatExtensions)
return ERROR_INT("invalid format", procName, 1);
if (!rp)
return ERROR_INT("rp not defined", procName, 1);
/* Generate the local file name */
if ((root = getRootNameFromArgv0(rp->argv[0])) == NULL)
return ERROR_INT("invalid root", procName, 1);
snprintf(namebuf, sizeof(namebuf), "/tmp/%s.%d.%s", root, *pcount,
ImageFileFormatExtensions[format]);
FREE(root);
/* Write the local file. Then, either write the golden file
* or check the local file against an existing golden file. */
pixWrite(namebuf, pix, format);
regTestCheckFile(rp->fp, rp->argv, namebuf, (*pcount)++, &rp->success);
return 0;
}
/*!
* regTestWritePixAndCheck()
*
* Input: rp (regtest parameters)
* pix (to be written)
* format (of output pix)
* Return: 0 if OK, 1 on error (a failure in comparison is not an error)
*
* Notes:
* (1) This function makes it easy to write the pix in a numbered
* sequence of files, and either to:
* (a) write the golden file ("generate" arg to regression test)
* (b) make a local file and "compare" with the golden file
* (c) make a local file and "display" the results
* (3) The canonical format of the local filename is:
* /tmp/regout/<root of main name>.<count>.<format extension string>
* e.g., for scale_reg,
* /tmp/regout/scale.0.png
*/
l_int32
regTestWritePixAndCheck(L_REGPARAMS *rp,
PIX *pix,
l_int32 format) {
char namebuf[256];
PROCNAME("regTestWritePixAndCheck");
if (!rp)
return ERROR_INT("rp not defined", procName, 1);
if (!pix) {
rp->success = FALSE;
return ERROR_INT("pix not defined", procName, 1);
}
if (format < 0 || format >= NumImageFileFormatExtensions) {
rp->success = FALSE;
return ERROR_INT("invalid format", procName, 1);
}
/* Generate the local file name */
snprintf(namebuf, sizeof(namebuf), "/tmp/regout/%s.%02d.%s", rp->testname,
rp->index + 1, ImageFileFormatExtensions[format]);
/* Write the local file */
if (pixGetDepth(pix) < 8)
pixSetPadBits(pix, 0);
pixWrite(namebuf, pix, format);
/* Either write the golden file ("generate") or check the
local file against an existing golden file ("compare") */
regTestCheckFile(rp, namebuf);
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, ival, n;
l_float32 f, val;
GPLOT *gplot;
NUMA *na1, *na2, *na3;
PIX *pixt;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate a 1D signal and plot it */
na1 = numaCreate(500);
for (i = 0; i < 500; i++) {
f = 48.3 * sin(0.13 * (l_float32)i);
f += 63.4 * cos(0.21 * (l_float32)i);
numaAddNumber(na1, f);
}
gplot = gplotCreate("/tmp/extrema", GPLOT_PNG, "Extrema test", "x", "y");
gplotAddPlot(gplot, NULL, na1, GPLOT_LINES, "plot 1");
/* Find the local min and max and plot them */
na2 = numaFindExtrema(na1, 38.3);
n = numaGetCount(na2);
na3 = numaCreate(n);
for (i = 0; i < n; i++) {
numaGetIValue(na2, i, &ival);
numaGetFValue(na1, ival, &val);
numaAddNumber(na3, val);
}
gplotAddPlot(gplot, na2, na3, GPLOT_POINTS, "plot 2");
gplotMakeOutput(gplot);
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
regTestCheckFile(rp, "/tmp/extrema.png"); /* 0 */
pixt = pixRead("/tmp/extrema.png");
pixDisplayWithTitle(pixt, 100, 100, "Extrema test", rp->display);
pixDestroy(&pixt);
gplotDestroy(&gplot);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, n;
size_t size1, size2;
BOX *box;
PIX *pix, *pix1, *pix2, *pix3;
PIXA *pixa, *pixa1;
PIXC *pixc, *pixc1, *pixc2;
PIXAC *pixac, *pixac1, *pixac2;
L_REGPARAMS *rp;
SARRAY *sa;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/comp");
pixac = pixacompCreate(1);
pixa = pixaCreate(0);
/* --- Read in the images --- */
pix1 = pixRead("marge.jpg");
pixc1 = pixcompCreateFromPix(pix1, IFF_JFIF_JPEG);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_JFIF_JPEG);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 0 */
pixSaveTiledOutline(pix3, pixa, 1.0, 1, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
pix = pixRead("feyn.tif");
pix1 = pixScaleToGray6(pix);
pixc1 = pixcompCreateFromPix(pix1, IFF_JFIF_JPEG);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_JFIF_JPEG);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 1 */
pixSaveTiledOutline(pix3, pixa, 1.0, 1, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
box = boxCreate(1144, 611, 690, 180);
pix1 = pixClipRectangle(pix, box, NULL);
pixc1 = pixcompCreateFromPix(pix1, IFF_TIFF_G4);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_TIFF_G4);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_TIFF_G4); /* 2 */
pixSaveTiledOutline(pix3, pixa, 1.0, 0, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
boxDestroy(&box);
pixDestroy(&pix);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
pix1 = pixRead("weasel4.11c.png");
pixc1 = pixcompCreateFromPix(pix1, IFF_PNG);
pix2 = pixCreateFromPixcomp(pixc1);
pixc2 = pixcompCreateFromPix(pix2, IFF_PNG);
pix3 = pixCreateFromPixcomp(pixc2);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
pixSaveTiledOutline(pix3, pixa, 1.0, 0, 30, 2, 32);
pixacompAddPix(pixac, pix1, IFF_DEFAULT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixcompDestroy(&pixc1);
pixcompDestroy(&pixc2);
/* --- Extract formatting info from compressed strings --- */
for (i = 0; i < 4; i++) {
pixc = pixacompGetPixcomp(pixac, i, L_NOCOPY);
get_format_data(i, pixc->data, pixc->size);
}
/* Save a tiled composite from the pixa */
pix1 = pixaDisplayTiledAndScaled(pixa, 32, 400, 4, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 4 */
pixDestroy(&pix1);
/* Convert the pixac --> pixa and save a tiled composite */
pixa1 = pixaCreateFromPixacomp(pixac, L_COPY);
pix1 = pixaDisplayTiledAndScaled(pixa1, 32, 400, 4, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 5 */
pixaDestroy(&pixa1);
pixDestroy(&pix1);
/* Make a pixacomp from files, and join */
sa = sarrayCreate(0);
for (i = 0; i < 6; i++)
sarrayAddString(sa, (char *)fnames[i], L_COPY);
pixac1 = pixacompCreateFromSA(sa, IFF_DEFAULT);
pixacompJoin(pixac1, pixac, 0, -1);
pixa1 = pixaCreateFromPixacomp(pixac1, L_COPY);
pix1 = pixaDisplayTiledAndScaled(pixa1, 32, 250, 10, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 6 */
pixacompDestroy(&pixac1);
pixaDestroy(&pixa1);
pixDestroy(&pix1);
sarrayDestroy(&sa);
/* Test serialized I/O */
pixacompWrite("/tmp/lept/comp/file1.pac", pixac);
regTestCheckFile(rp, "/tmp/lept/comp/file1.pac"); /* 7 */
pixac1 = pixacompRead("/tmp/lept/comp/file1.pac");
pixacompWrite("/tmp/lept/comp/file2.pac", pixac1);
regTestCheckFile(rp, "/tmp/lept/comp/file2.pac"); /* 8 */
regTestCompareFiles(rp, 7, 8); /* 9 */
pixac2 = pixacompRead("/tmp/lept/comp/file2.pac");
pixa1 = pixaCreateFromPixacomp(pixac2, L_COPY);
pix1 = pixaDisplayTiledAndScaled(pixa1, 32, 250, 4, 0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 10 */
pixacompDestroy(&pixac1);
pixacompDestroy(&pixac2);
pixaDestroy(&pixa1);
pixDestroy(&pix1);
/* Test serialized pixacomp I/O to and from memory */
pixacompWriteMem(&data1, &size1, pixac);
pixac1 = pixacompReadMem(data1, size1);
pixacompWriteMem(&data2, &size2, pixac1);
pixac2 = pixacompReadMem(data2, size2);
pixacompWrite("/tmp/lept/comp/file3.pac", pixac1);
regTestCheckFile(rp, "/tmp/lept/comp/file3.pac"); /* 11 */
pixacompWrite("/tmp/lept/comp/file4.pac", pixac2);
regTestCheckFile(rp, "/tmp/lept/comp/file4.pac"); /* 12 */
regTestCompareFiles(rp, 11, 12); /* 13 */
pixacompDestroy(&pixac1);
pixacompDestroy(&pixac2);
lept_free(data1);
lept_free(data2);
pixaDestroy(&pixa);
pixacompDestroy(&pixac);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 i, n, w, h, success, display;
FILE *fp;
BOXA *boxa;
NUMA *naindex, *naw, *nah, *naw_med, *nah_med;
PIX *pixs, *pixt, *pixd;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Generate arrays of word widths and heights */
pixs = pixRead("feyn.tif");
pixGetWordBoxesInTextlines(pixs, 1, 6, 6, 500, 50, &boxa, &naindex);
n = boxaGetCount(boxa);
naw = numaCreate(0);
nah = numaCreate(0);
for (i = 0; i < n; i++) {
boxaGetBoxGeometry(boxa, i, NULL, NULL, &w, &h);
numaAddNumber(naw, w);
numaAddNumber(nah, h);
}
boxaDestroy(&boxa);
numaDestroy(&naindex);
/* Make the rank bin arrays of median values, with 10 bins */
numaGetRankBinValues(naw, 10, NULL, &naw_med);
numaGetRankBinValues(nah, 10, NULL, &nah_med);
gplotSimple1(naw_med, GPLOT_PNG, "/tmp/w_10bin",
"width vs rank bins (10)");
gplotSimple1(nah_med, GPLOT_PNG, "/tmp/h_10bin",
"height vs rank bins (10)");
numaDestroy(&naw_med);
numaDestroy(&nah_med);
/* Make the rank bin arrays of median values, with 30 bins */
numaGetRankBinValues(naw, 30, NULL, &naw_med);
numaGetRankBinValues(nah, 30, NULL, &nah_med);
gplotSimple1(naw_med, GPLOT_PNG, "/tmp/w_30bin",
"width vs rank bins (30)");
gplotSimple1(nah_med, GPLOT_PNG, "/tmp/h_30bin",
"height vs rank bins (30)");
numaDestroy(&naw_med);
numaDestroy(&nah_med);
/* Give gnuplot time to write out the files */
#ifndef _WIN32
sleep(2);
#else
Sleep(2000);
#endif /* _WIN32 */
/* Save as golden files, or check against them */
regTestCheckFile(fp, argv, "/tmp/w_10bin.png", 0, &success);
regTestCheckFile(fp, argv, "/tmp/h_10bin.png", 1, &success);
regTestCheckFile(fp, argv, "/tmp/w_30bin.png", 2, &success);
regTestCheckFile(fp, argv, "/tmp/h_30bin.png", 3, &success);
/* Display results for debugging */
pixt = pixRead("/tmp/w_10bin.png");
pixDisplayWithTitle(pixt, 0, 0, NULL, display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/h_10bin.png");
pixDisplayWithTitle(pixt, 650, 0, NULL, display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/w_30bin.png");
pixDisplayWithTitle(pixt, 0, 550, NULL, display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/h_30bin.png");
pixDisplayWithTitle(pixt, 650, 550, NULL, display);
pixDestroy(&pixt);
pixDestroy(&pixs);
numaDestroy(&naw);
numaDestroy(&nah);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc,
char **argv)
{
char buf[512];
char *pathname, *datastr, *formstr;
l_uint8 *data1, *data2;
l_int32 i, bl1, bl2, bl3, sbytes, formbytes, fontsize, rbytes;
size_t nbytes;
PIX *pix1, *pix2, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Generate pixa char bitmap files from file ----------- */
lept_rmdir("filefonts");
lept_mkdir("filefonts");
for (i = 0; i < 9; i++) {
pixaSaveFont("fonts", "/tmp/filefonts", sizes[i]);
pathname = genPathname("/tmp/filefonts", outputfonts[i]);
pixa = pixaRead(pathname);
if (rp->display) {
fprintf(stderr, "Found %d chars in font size %d\n",
pixaGetCount(pixa), sizes[i]);
}
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 - 8 */
if (i == 2) pixDisplayWithTitle(pixd, 100, 0, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
lept_free(pathname);
}
lept_rmdir("filefonts");
/* ---------- Generate pixa char bitmap files from string --------- */
lept_rmdir("strfonts");
lept_mkdir("strfonts");
for (i = 0; i < 9; i++) {
pixaSaveFont(NULL, "/tmp/strfonts", sizes[i]);
pathname = genPathname("/tmp/strfonts", outputfonts[i]);
pixa = pixaRead(pathname);
if (rp->display) {
fprintf(stderr, "Found %d chars in font size %d\n",
pixaGetCount(pixa), sizes[i]);
}
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 9 - 17 */
if (i == 2) pixDisplayWithTitle(pixd, 100, 150, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
lept_free(pathname);
}
/* ----- Use pixaGetFont() and write the result out -----*/
lept_rmdir("pafonts");
lept_mkdir("pafonts");
for (i = 0; i < 9; i++) {
pixa = pixaGetFont("/tmp/strfonts", sizes[i], &bl1, &bl2, &bl3);
fprintf(stderr, "Baselines are at: %d, %d, %d\n", bl1, bl2, bl3);
snprintf(buf, sizeof(buf), "/tmp/pafonts/chars-%d.pa", sizes[i]);
pixaWrite(buf, pixa);
if (i == 2) {
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
pixDisplayWithTitle(pixd, 100, 300, NULL, rp->display);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
}
lept_rmdir("pafonts");
/* ------- Generate 4/3 encoded ascii strings from tiff files ------ */
lept_rmdir("fontencode");
lept_mkdir("fontencode");
for (i = 0; i < 9; i++) {
fontsize = 2 * i + 4;
pathname = genPathname("fonts", inputfonts[i]);
data1 = l_binaryRead(pathname, &nbytes);
datastr = encodeBase64(data1, nbytes, &sbytes);
if (rp->display)
fprintf(stderr, "nbytes = %lu, sbytes = %d\n",
(unsigned long)nbytes, sbytes);
formstr = reformatPacked64(datastr, sbytes, 4, 72, 1, &formbytes);
snprintf(buf, sizeof(buf), "/tmp/fontencode/formstr_%d.txt", fontsize);
l_binaryWrite(buf, "w", formstr, formbytes);
regTestCheckFile(rp, buf); /* 18-26 */
if (i == 8)
pix1 = pixReadMem(data1, nbytes); /* original */
FREE(data1);
data2 = decodeBase64(datastr, sbytes, &rbytes);
snprintf(buf, sizeof(buf), "/tmp/fontencode/image_%d.tif", fontsize);
l_binaryWrite(buf, "w", data2, rbytes);
if (i == 8) {
pix2 = pixReadMem(data2, rbytes); /* encode/decode */
regTestComparePix(rp, pix1, pix2); /* 27 */
pixDestroy(&pix1);
pixDestroy(&pix2);
}
FREE(data2);
FREE(pathname);
FREE(datastr);
FREE(formstr);
}
/* ------------ Get timing for font generation ----------- */
startTimer();
for (i = 0; i < 100; i++) {
pixa = pixaGenerateFontFromString(sizes[5], &bl1, &bl2, &bl3);
pixaDestroy(&pixa);
}
fprintf(stderr, "Time for font gen = %7.4f sec\n", stopTimer() / 100.0);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 1 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 2 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 3 */
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 4 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 5 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 6 */
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix1, 200, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
regTestCompareValues(rp, 1, same, 0.0); /* 8 */
regTestCompareValues(rp, 0.053, diffarea, 0.002); /* 9 */
regTestCompareValues(rp, 0.240, diffxor, 0.002); /* 10 */
regTestWritePixAndCheck(rp, pixdb, IFF_PNG); /* 11 */
pixDisplayWithTitle(pixdb, 400, 0, NULL, rp->display);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix1, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
regTestCompareValues(rp, 1, same, 0.0); /* 15 */
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* ----------- Test pixaDisplayBoxaa() ------------ */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
/* Check that the transpose is reversible */
regTestCompareValues(rp, 1, success, 0.0); /* 16 */
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 17 */
pixDisplayWithTitle(pix1, 0, 600, NULL, rp->display);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
l_pdfSetDateAndVersion(FALSE);
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
regTestCheckFile(rp, "/tmp/lept/boxa/show.pdf"); /* 18 */
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return regTestCleanup(rp);
}
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);
}
main(int argc,
char **argv)
{
l_int32 success, display;
l_float32 scalefact;
L_BMF *bmf, *bmftop;
FILE *fp;
L_KERNEL *kel, *kelx, *kely;
PIX *pixs, *pixg, *pixt, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8;
PIXA *pixa;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* ----------------- Test on 8 bpp grayscale ---------------------*/
pixa = pixaCreate(5);
bmf = bmfCreate("./fonts", 6);
bmftop = bmfCreate("./fonts", 10);
pixs = pixRead("lucasta-47.jpg");
pixg = pixScale(pixs, 0.4, 0.4); /* 8 bpp grayscale */
pix1 = pixConvertTo32(pixg); /* 32 bpp rgb */
AddTextAndSave(pixa, pix1, 1, bmf, textstr[0], L_ADD_BELOW, 0xff000000);
pix2 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_RGB);
AddTextAndSave(pixa, pix2, 0, bmf, textstr[1], L_ADD_BELOW, 0x00ff0000);
pix3 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_BGR);
AddTextAndSave(pixa, pix3, 0, bmf, textstr[2], L_ADD_BELOW, 0x0000ff00);
pix4 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_VRGB);
AddTextAndSave(pixa, pix4, 0, bmf, textstr[3], L_ADD_BELOW, 0x00ff0000);
pix5 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_VBGR);
AddTextAndSave(pixa, pix5, 0, bmf, textstr[4], L_ADD_BELOW, 0x0000ff00);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop,
"Regression test for subpixel scaling: gray",
0xff00ff00, L_ADD_ABOVE, NULL);
pixWrite("/tmp/sub0.jpg", pixd, IFF_JFIF_JPEG);
regTestCheckFile(fp, argv, "/tmp/sub0.jpg", 0, &success);
pixDisplayWithTitle(pixd, 50, 50, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
/* ----------------- Test on 32 bpp rgb ---------------------*/
pixa = pixaCreate(5);
pixs = pixRead("fish24.jpg");
pix1 = pixScale(pixs, 0.4, 0.4);
AddTextAndSave(pixa, pix1, 1, bmf, textstr[0], L_ADD_BELOW, 0xff000000);
pix2 = pixConvertToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_RGB);
AddTextAndSave(pixa, pix2, 0, bmf, textstr[1], L_ADD_BELOW, 0x00ff0000);
pix3 = pixConvertToSubpixelRGB(pixs, 0.4, 0.35, L_SUBPIXEL_ORDER_BGR);
AddTextAndSave(pixa, pix3, 0, bmf, textstr[2], L_ADD_BELOW, 0x0000ff00);
pix4 = pixConvertToSubpixelRGB(pixs, 0.4, 0.45, L_SUBPIXEL_ORDER_VRGB);
AddTextAndSave(pixa, pix4, 0, bmf, textstr[3], L_ADD_BELOW, 0x00ff0000);
pix5 = pixConvertToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_VBGR);
AddTextAndSave(pixa, pix5, 0, bmf, textstr[4], L_ADD_BELOW, 0x0000ff00);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop,
"Regression test for subpixel scaling: color",
0xff00ff00, L_ADD_ABOVE, NULL);
pixWrite("/tmp/sub1.jpg", pixd, IFF_JFIF_JPEG);
regTestCheckFile(fp, argv, "/tmp/sub1.jpg", 1, &success);
pixDisplayWithTitle(pixd, 50, 350, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
bmfDestroy(&bmf);
bmfDestroy(&bmftop);
/* --------------- Test on images that are initially 1 bpp ------------*/
/* For these, it is better to apply a lowpass filter before scaling */
/* Normal scaling of 8 bpp grayscale */
scalefact = 800. / 2320.;
pixs = pixRead("patent.png"); /* sharp, 300 ppi, 1 bpp image */
pix1 = pixConvertTo8(pixs, FALSE); /* use 8 bpp input */
pix2 = pixScale(pix1, scalefact, scalefact);
pixWrite("/tmp/sub2.png", pix2, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/sub2.png", 2, &success);
/* Subpixel scaling; bad because there is very little aliasing. */
pix3 = pixConvertToSubpixelRGB(pix1, scalefact, scalefact,
L_SUBPIXEL_ORDER_RGB);
pixWrite("/tmp/sub3.png", pix3, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/sub3.png", 3, &success);
/* Get same (bad) result doing subpixel rendering on RGB input */
pix4 = pixConvertTo32(pixs);
pix5 = pixConvertToSubpixelRGB(pix4, scalefact, scalefact,
L_SUBPIXEL_ORDER_RGB);
regTestComparePix(fp, argv, pix3, pix5, 0, &success);
pixWrite("/tmp/sub4.png", pix5, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/sub4.png", 4, &success);
/* Now apply a small lowpass filter before scaling. */
makeGaussianKernelSep(2, 2, 1.0, 1.0, &kelx, &kely);
startTimer();
pix6 = pixConvolveSep(pix1, kelx, kely, 8, 1); /* normalized */
fprintf(stderr, "Time sep: %7.3f\n", stopTimer());
pixWrite("/tmp/sub5.png", pix6, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/sub5.png", 5, &success);
/* Get same lowpass result with non-separated convolution */
kel = makeGaussianKernel(2, 2, 1.0, 1.0);
startTimer();
pix7 = pixConvolve(pix1, kel, 8, 1); /* normalized */
fprintf(stderr, "Time non-sep: %7.3f\n", stopTimer());
regTestComparePix(fp, argv, pix6, pix7, 1, &success);
/* Now do the subpixel scaling on this slightly blurred image */
pix8 = pixConvertToSubpixelRGB(pix6, scalefact, scalefact,
L_SUBPIXEL_ORDER_RGB);
pixWrite("/tmp/sub6.png", pix8, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/sub6.png", 6, &success);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
l_int32 main(int argc,
char **argv)
{
l_int32 delx, dely, etransx, etransy, w, h, area1, area2;
l_int32 *stab, *ctab;
l_float32 cx1, cy1, cx2, cy2, score, fract;
PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Test of pixBestCorrelation() --------------- */
pix0 = pixRead("harmoniam100-11.png");
pix1 = pixConvertTo1(pix0, 160);
pixGetDimensions(pix1, &w, &h, NULL);
/* Now make a smaller image, translated by (-32, -12)
* Except for the resizing, this is equivalent to
* pix2 = pixTranslate(NULL, pix1, -32, -12, L_BRING_IN_WHITE); */
pix2 = pixCreate(w - 10, h, 1);
pixRasterop(pix2, 0, 0, w, h, PIX_SRC, pix1, 32, 12);
/* Get the number of FG pixels and the centroid locations */
stab = makePixelSumTab8();
ctab = makePixelCentroidTab8();
pixCountPixels(pix1, &area1, stab);
pixCountPixels(pix2, &area2, stab);
pixCentroid(pix1, ctab, stab, &cx1, &cy1);
pixCentroid(pix2, ctab, stab, &cx2, &cy2);
etransx = lept_roundftoi(cx1 - cx2);
etransy = lept_roundftoi(cy1 - cy2);
fprintf(stderr, "delta cx = %d, delta cy = %d\n",
etransx, etransy);
/* Get the best correlation, searching around the translation
* where the centroids coincide */
pixBestCorrelation(pix1, pix2, area1, area2, etransx, etransy,
4, stab, &delx, &dely, &score, 5);
fprintf(stderr, "delx = %d, dely = %d, score = %7.4f\n",
delx, dely, score);
regTestCompareValues(rp, 32, delx, 0); /* 0 */
regTestCompareValues(rp, 12, dely, 0); /* 1 */
lept_mv("/tmp/lept/correl_5.png", "regout", NULL, NULL);
regTestCheckFile(rp, "/tmp/regout/correl_5.png"); /* 2 */
lept_free(stab);
lept_free(ctab);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------ Test of pixCompareWithTranslation() ------------ */
/* Now use the pyramid to get the result. Do a translation
* to remove pixels at the bottom from pix2, so that the
* centroids are initially far apart. */
pix1 = pixRead("harmoniam-11.tif");
pix2 = pixTranslate(NULL, pix1, -45, 25, L_BRING_IN_WHITE);
l_pdfSetDateAndVersion(0);
pixCompareWithTranslation(pix1, pix2, 160, &delx, &dely, &score, 1);
pixDestroy(&pix1);
pixDestroy(&pix2);
fprintf(stderr, "delx = %d, dely = %d\n", delx, dely);
regTestCompareValues(rp, 45, delx, 0); /* 3 */
regTestCompareValues(rp, -25, dely, 0); /* 4 */
lept_mv("/tmp/lept/correl.pdf", "regout", NULL, NULL);
lept_mv("/tmp/lept/compare.pdf", "regout", NULL, NULL);
regTestCheckFile(rp, "/tmp/regout/compare.pdf"); /* 5 */
regTestCheckFile(rp, "/tmp/regout/correl.pdf"); /* 6 */
/* ------------ Test of pixGetPerceptualDiff() --------------- */
pix0 = pixRead("greencover.jpg");
pix1 = pixRead("redcover.jpg"); /* pre-scaled to the same size */
/* Apply directly to the color images */
pixGetPerceptualDiff(pix0, pix1, 1, 3, 20, &fract, &pix2, &pix3);
fprintf(stderr, "Fraction of color pixels = %f\n", fract);
regTestCompareValues(rp, 0.061252, fract, 0.01); /* 7 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 8 */
regTestWritePixAndCheck(rp, pix3, IFF_TIFF_G4); /* 9 */
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Apply to grayscale images */
pix2 = pixConvertTo8(pix0, 0);
pix3 = pixConvertTo8(pix1, 0);
pixGetPerceptualDiff(pix2, pix3, 1, 3, 20, &fract, &pix4, &pix5);
fprintf(stderr, "Fraction of grayscale pixels = %f\n", fract);
regTestCompareValues(rp, 0.046928, fract, 0.0002); /* 10 */
regTestWritePixAndCheck(rp, pix4, IFF_JFIF_JPEG); /* 11 */
regTestWritePixAndCheck(rp, pix5, IFF_TIFF_G4); /* 12 */
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char buf[256];
size_t nbytes;
l_int32 i, w, h, success, display;
l_int32 format, bps, spp, iscmap, format2, w2, h2, bps2, spp2, iscmap2;
l_uint8 *data;
l_uint32 *data32, *data32r;
BOX *box;
FILE *fp;
PIX *pixs, *pixt, *pixt2, *pixd;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Test basic serialization/deserialization */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
/* Serialize to memory */
pixSerializeToMemory(pixs, &data32, &nbytes);
/* Just for fun, write and read back from file */
arrayWrite("/tmp/array", "w", data32, nbytes);
data32r = (l_uint32 *)arrayRead("/tmp/array", (l_int32 *)(&nbytes));
/* Deserialize */
pixd = pixDeserializeFromMemory(data32r, nbytes);
regTestComparePix(fp, argv, pixs, pixd, i, &success);
pixDestroy(&pixd);
pixDestroy(&pixs);
FREE(data32);
FREE(data32r);
}
/* Test read/write fileio interface */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixGetDimensions(pixs, &w, &h, NULL);
box = boxCreate(0, 0, L_MIN(150, w), L_MIN(150, h));
pixt = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
snprintf(buf, sizeof(buf), "/tmp/pixs.%d", i);
pixWrite(buf, pixt, IFF_SPIX);
regTestCheckFile(fp, argv, buf, i, &success);
pixt2 = pixRead(buf);
regTestComparePix(fp, argv, pixt, pixt2, nfiles + i, &success);
pixDestroy(&pixs);
pixDestroy(&pixt);
pixDestroy(&pixt2);
}
/* Test read header. Note that for rgb input, spp = 3,
* but for 32 bpp spix, we set spp = 4. */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixWriteMem(&data, &nbytes, pixs, IFF_SPIX);
pixReadHeader(filename[i], &format, &w, &h, &bps, &spp, &iscmap);
pixReadHeaderMem(data, nbytes, &format2, &w2, &h2, &bps2,
&spp2, &iscmap2);
if (format2 != 16 || w != w2 || h != h2 || bps != bps2 ||
iscmap != iscmap2) {
if (fp)
fprintf(fp, "Failure comparing data");
else
fprintf(stderr, "Failure comparing data");
success = FALSE;
}
pixDestroy(&pixs);
FREE(data);
}
#if 0
/* Do timing */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
startTimer();
pixSerializeToMemory(pixs, &data32, &nbytes);
pixd = pixDeserializeFromMemory(data32, nbytes);
fprintf(stderr, "Time for %s: %7.3f sec\n", filename[i], stopTimer());
FREE(data32);
pixDestroy(&pixs);
pixDestroy(&pixd);
}
#endif
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
main(int argc,
char **argv)
{
char fname[256];
l_int32 i, w, h, nbins, factor, success, display;
l_int32 spike;
l_uint32 *array, *marray;
FILE *fp;
NUMA *na, *nan, *nai, *narbin;
PIX *pixs, *pixt, *pixd;
PIXA *pixa;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Find the rank bin colors */
pixs = pixRead("map1.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
factor = L_MAX(1, (l_int32)sqrt((l_float64)(w * h / 20000.0)));
nbins = 10;
pixGetRankColorArray(pixs, nbins, L_SELECT_MIN, factor, &array, 2);
for (i = 0; i < nbins; i++)
fprintf(stderr, "%d: %x\n", i, array[i]);
pixd = pixDisplayColorArray(array, nbins, 200, 5, 1);
pixWrite("/tmp/rankhisto.0.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.0.png", 0, &success);
pixDisplayWithTitle(pixd, 100, 100, NULL, display);
pixDestroy(&pixd);
/* Modify the rank bin colors by mapping them such
* that the lightest color is mapped to white */
marray = (l_uint32 *)CALLOC(nbins, sizeof(l_uint32));
for (i = 0; i < nbins; i++)
pixelLinearMapToTargetColor(array[i], array[nbins - 1],
0xffffff00, &marray[i]);
pixd = pixDisplayColorArray(marray, nbins, 200, 5, 1);
pixWrite("/tmp/rankhisto.1.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.1.png", 1, &success);
pixDisplayWithTitle(pixd, 100, 600, NULL, display);
pixDestroy(&pixd);
FREE(marray);
/* Save the histogram plots */
#ifndef _WIN32
sleep(2); /* give gnuplot time to write out the files */
#else
Sleep(2000);
#endif /* _WIN32 */
pixa = PixSavePlots1();
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/rankhisto.2.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.2.png", 2, &success);
pixDisplayWithTitle(pixd, 100, 600, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
/* Map to the lightest bin; then do TRC adjustment */
pixt = pixLinearMapToTargetColor(NULL, pixs, array[nbins - 1], 0xffffff00);
pixd = pixGammaTRC(NULL, pixt, 1.0, 0, 240);
pixWrite("/tmp/rankhisto.3.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.3.png", 3, &success);
pixDisplayWithTitle(pixd, 600, 100, NULL, display);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Now test the edge cases for the histogram and rank LUT,
* where all the histo data is piled up at one place.
* We only require that the result be sensible. */
for (i = 0; i < 3; i++) {
if (i == 0)
spike = 0;
else if (i == 1)
spike = 50;
else
spike = 99;
na = numaMakeConstant(0, 100);
numaReplaceNumber(na, spike, 200.0);
nan = numaNormalizeHistogram(na, 1.0);
numaDiscretizeRankAndIntensity(nan, 10, &narbin, &nai, NULL, NULL);
snprintf(fname, sizeof(fname), "/tmp/rtnan%d", i + 1);
gplotSimple1(nan, GPLOT_PNG, fname, "Normalized Histogram");
snprintf(fname, sizeof(fname), "/tmp/rtnai%d", i + 1);
gplotSimple1(nai, GPLOT_PNG, fname, "Intensity vs. rank bin");
snprintf(fname, sizeof(fname), "/tmp/rtnarbin%d", i + 1);
gplotSimple1(narbin, GPLOT_PNG, fname, "LUT: rank bin vs. Intensity");
numaDestroy(&na);
numaDestroy(&nan);
numaDestroy(&narbin);
numaDestroy(&nai);
}
#ifndef _WIN32
sleep(2); /* give gnuplot time to write out the files */
#else
Sleep(2000);
#endif /* _WIN32 */
pixa = PixSavePlots2();
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/rankhisto.4.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.4.png", 4, &success);
pixDisplayWithTitle(pixd, 500, 600, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
pixDestroy(&pixs);
FREE(array);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
main(int argc,
char **argv)
{
l_int32 h;
l_float32 scalefactor;
BOX *box;
BOXA *boxa1, *boxa2;
BOXAA *baa;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmdir("segtest");
lept_mkdir("segtest");
baa = boxaaCreate(5);
/* Image region input. */
pix1 = pixRead("wet-day.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/0.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/0.jpg"); /* 0 */
box = boxCreate(105, 161, 620, 872); /* image region */
boxa1 = boxaCreate(1);
boxaAddBox(boxa1, box, L_INSERT);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Compute image region at w = 2 * WIDTH */
pix1 = pixRead("candelabrum-11.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pix3 = pixConvertTo1(pix2, 100);
pix4 = pixExpandBinaryPower2(pix3, 2); /* w = 2 * WIDTH */
pix5 = pixGenHalftoneMask(pix4, NULL, NULL, 1);
pix6 = pixMorphSequence(pix5, "c20.1 + c1.20", 0);
pix7 = pixMaskConnComp(pix6, 8, &boxa1);
pix8 = pixReduceBinary2(pix7, NULL); /* back to w = WIDTH */
pix9 = pixBackgroundNormSimple(pix2, pix8, NULL);
pixWrite("/tmp/segtest/1.jpg", pix9, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/1.jpg"); /* 1 */
boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5); /* back to w = WIDTH */
boxaaAddBoxa(baa, boxa2, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pix9);
boxaDestroy(&boxa1);
/* Use mask to find image region */
pix1 = pixRead("lion-page.00016.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/2.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/2.jpg"); /* 2 */
pix3 = pixRead("lion-mask.00016.tif");
pix4 = pixScaleToSize(pix3, WIDTH, 0);
boxa1 = pixConnComp(pix4, NULL, 8);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Compute image region at full res */
pix1 = pixRead("rabi.png");
scalefactor = (l_float32)WIDTH / (l_float32)pixGetWidth(pix1);
pix2 = pixScaleToGray(pix1, scalefactor);
pixWrite("/tmp/segtest/3.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/3.jpg"); /* 3 */
pix3 = pixGenHalftoneMask(pix1, NULL, NULL, 0);
pix4 = pixMorphSequence(pix3, "c20.1 + c1.20", 0);
boxa1 = pixConnComp(pix4, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, scalefactor, scalefactor);
boxaaAddBoxa(baa, boxa2, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
boxaDestroy(&boxa1);
/* Page with no image regions */
pix1 = pixRead("lucasta-47.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
boxa1 = boxaCreate(1);
pixWrite("/tmp/segtest/4.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/4.jpg"); /* 4 */
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Page that is all image */
pix1 = pixRead("map1.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/5.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/5.jpg"); /* 5 */
h = pixGetHeight(pix2);
box = boxCreate(0, 0, WIDTH, h);
boxa1 = boxaCreate(1);
boxaAddBox(boxa1, box, L_INSERT);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Save the boxaa file */
boxaaWrite("/tmp/segtest/seg.baa", baa);
regTestCheckFile(rp, "/tmp/segtest/seg.baa"); /* 6 */
/* Do the conversion */
l_pdfSetDateAndVersion(FALSE);
convertSegmentedFilesToPdf("/tmp/segtest", ".jpg", 100, L_G4_ENCODE,
140, baa, 75, 0.6, "Segmentation Test",
"/tmp/pdfseg.7.pdf");
regTestCheckFile(rp, "/tmp/pdfseg.7.pdf"); /* 7 */
boxaaDestroy(&baa);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char buf[256];
size_t size;
l_int32 i, w, h;
l_int32 format, bps, spp, iscmap, format2, w2, h2, bps2, spp2, iscmap2;
l_uint8 *data;
l_uint32 *data32, *data32r;
BOX *box;
PIX *pixs, *pixt, *pixt2, *pixd;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Test basic serialization/deserialization */
data32 = NULL;
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
/* Serialize to memory */
pixSerializeToMemory(pixs, &data32, &size);
/* Just for fun, write and read back from file */
l_binaryWrite("/tmp/regout/array", "w", data32, size);
data32r = (l_uint32 *)l_binaryRead("/tmp/regout/array", &size);
/* Deserialize */
pixd = pixDeserializeFromMemory(data32r, size);
regTestComparePix(rp, pixs, pixd); /* i */
pixDestroy(&pixd);
pixDestroy(&pixs);
lept_free(data32);
lept_free(data32r);
}
/* Test read/write fileio interface */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixGetDimensions(pixs, &w, &h, NULL);
box = boxCreate(0, 0, L_MIN(150, w), L_MIN(150, h));
pixt = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
snprintf(buf, sizeof(buf), "/tmp/regout/pixs.%d.spix", rp->index + 1);
pixWrite(buf, pixt, IFF_SPIX);
regTestCheckFile(rp, buf); /* nfiles + 2 * i */
pixt2 = pixRead(buf);
regTestComparePix(rp, pixt, pixt2); /* nfiles + 2 * i + 1 */
pixDestroy(&pixs);
pixDestroy(&pixt);
pixDestroy(&pixt2);
}
/* Test read header. Note that for rgb input, spp = 3,
* but for 32 bpp spix, we set spp = 4. */
data = NULL;
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
pixWriteMem(&data, &size, pixs, IFF_SPIX);
pixReadHeader(filename[i], &format, &w, &h, &bps, &spp, &iscmap);
pixReadHeaderMem(data, size, &format2, &w2, &h2, &bps2,
&spp2, &iscmap2);
if (format2 != IFF_SPIX || w != w2 || h != h2 || bps != bps2 ||
iscmap != iscmap2) {
if (rp->fp)
fprintf(rp->fp, "Failure comparing data");
else
fprintf(stderr, "Failure comparing data");
}
pixDestroy(&pixs);
lept_free(data);
}
#if 0
/* Do timing */
for (i = 0; i < nfiles; i++) {
pixs = pixRead(filename[i]);
startTimer();
pixSerializeToMemory(pixs, &data32, &size);
pixd = pixDeserializeFromMemory(data32, size);
fprintf(stderr, "Time for %s: %7.3f sec\n", filename[i], stopTimer());
lept_free(data32);
pixDestroy(&pixs);
pixDestroy(&pixd);
}
#endif
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, n, w, h;
BOXA *boxa;
NUMA *naindex, *naw, *nah, *naw_med, *nah_med;
PIX *pixs, *pixt;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate arrays of word widths and heights */
pixs = pixRead("feyn.tif");
pixGetWordBoxesInTextlines(pixs, 1, 6, 6, 500, 50, &boxa, &naindex);
n = boxaGetCount(boxa);
naw = numaCreate(0);
nah = numaCreate(0);
for (i = 0; i < n; i++) {
boxaGetBoxGeometry(boxa, i, NULL, NULL, &w, &h);
numaAddNumber(naw, w);
numaAddNumber(nah, h);
}
boxaDestroy(&boxa);
numaDestroy(&naindex);
/* Make the rank bin arrays of median values, with 10 bins */
lept_rmfile("/tmp/lept/regout/w_10bin.png"); /* remove existing ones */
lept_rmfile("/tmp/lept/regout/h_10bin.png");
lept_rmfile("/tmp/lept/regout/w_30bin.png");
lept_rmfile("/tmp/lept/regout/h_30bin.png");
numaGetRankBinValues(naw, 10, NULL, &naw_med);
numaGetRankBinValues(nah, 10, NULL, &nah_med);
gplotSimple1(naw_med, GPLOT_PNG, "/tmp/lept/regout/w_10bin",
"width vs rank bins (10)");
gplotSimple1(nah_med, GPLOT_PNG, "/tmp/lept/regout/h_10bin",
"height vs rank bins (10)");
numaDestroy(&naw_med);
numaDestroy(&nah_med);
/* Make the rank bin arrays of median values, with 30 bins */
numaGetRankBinValues(naw, 30, NULL, &naw_med);
numaGetRankBinValues(nah, 30, NULL, &nah_med);
gplotSimple1(naw_med, GPLOT_PNG, "/tmp/lept/regout/w_30bin",
"width vs rank bins (30)");
gplotSimple1(nah_med, GPLOT_PNG, "/tmp/lept/regout/h_30bin",
"height vs rank bins (30)");
numaDestroy(&naw_med);
numaDestroy(&nah_med);
/* Save as golden files, or check against them */
regTestCheckFile(rp, "/tmp/lept/regout/w_10bin.png"); /* 0 */
regTestCheckFile(rp, "/tmp/lept/regout/h_10bin.png"); /* 1 */
regTestCheckFile(rp, "/tmp/lept/regout/w_30bin.png"); /* 2 */
regTestCheckFile(rp, "/tmp/lept/regout/h_30bin.png"); /* 3 */
/* Display results for debugging */
pixt = pixRead("/tmp/lept/regout/w_10bin.png");
pixDisplayWithTitle(pixt, 0, 0, NULL, rp->display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/lept/regout/h_10bin.png");
pixDisplayWithTitle(pixt, 650, 0, NULL, rp->display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/lept/regout/w_30bin.png");
pixDisplayWithTitle(pixt, 0, 550, NULL, rp->display);
pixDestroy(&pixt);
pixt = pixRead("/tmp/lept/regout/h_30bin.png");
pixDisplayWithTitle(pixt, 650, 550, NULL, rp->display);
pixDestroy(&pixt);
pixDestroy(&pixs);
numaDestroy(&naw);
numaDestroy(&nah);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char outname[256];
l_int32 loc, display, success;
L_BMF *bmf, *bmftop;
FILE *fp;
PIX *pixs, *pixt, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8;
PIXA *pixa;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
bmf = bmfCreate("./fonts", 6);
bmftop = bmfCreate("./fonts", 10);
pixs = pixRead("lucasta-47.jpg");
pix1 = pixScale(pixs, 0.4, 0.4); /* 8 bpp grayscale */
pix2 = pixConvertTo32(pix1); /* 32 bpp rgb */
pix3 = pixThresholdOn8bpp(pix1, 12, 1); /* 8 bpp cmapped */
pix4 = pixThresholdTo4bpp(pix1, 10, 1); /* 4 bpp cmapped */
pix5 = pixThresholdTo4bpp(pix1, 10, 0); /* 4 bpp not cmapped */
pix6 = pixThresholdTo2bpp(pix1, 3, 1); /* 2 bpp cmapped */
pix7 = pixThresholdTo2bpp(pix1, 3, 0); /* 2 bpp not cmapped */
pix8 = pixThresholdToBinary(pix1, 160); /* 1 bpp */
for (loc = 1; loc < 5; loc++) {
pixa = pixaCreate(0);
AddTextAndSave(pixa, pix1, bmf, textstr[0], loc, 190);
AddTextAndSave(pixa, pix2, bmf, textstr[1], loc, 0xff000000);
AddTextAndSave(pixa, pix3, bmf, textstr[2], loc, 0x00ff0000);
AddTextAndSave(pixa, pix4, bmf, textstr[3], loc, 0x0000ff00);
AddTextAndSave(pixa, pix5, bmf, textstr[4], loc, 11);
AddTextAndSave(pixa, pix6, bmf, textstr[5], loc, 0xff000000);
AddTextAndSave(pixa, pix7, bmf, textstr[6], loc, 2);
AddTextAndSave(pixa, pix8, bmf, textstr[7], loc, 1);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop, topstr[loc - 1],
0xff00ff00, L_ADD_ABOVE, NULL);
snprintf(outname, 240, "/tmp/writetext.%d.png", loc - 1);
pixWrite(outname, pixd, IFF_PNG);
regTestCheckFile(fp, argv, outname, loc - 1, &success);
pixDisplayWithTitle(pixd, 50 * loc, 50, NULL, display);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixaDestroy(&pixa);
}
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
bmfDestroy(&bmf);
bmfDestroy(&bmftop);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc,
char **argv)
{
char textstr[256];
l_int32 w, h, d, i;
l_uint32 srcval, dstval;
l_float32 scalefact, sat, fract;
L_BMF *bmf8;
L_KERNEL *kel;
NUMA *na;
PIX *pix, *pixs, *pixs1, *pixs2, *pixd;
PIX *pixt0, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa, *pixaf;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pix = pixRead(filein);
pixGetDimensions(pix, &w, &h, &d);
if (d != 32)
return ERROR_INT("file not 32 bpp", argv[0], 1);
scalefact = (l_float32)WIDTH / (l_float32)w;
pixs = pixScale(pix, scalefact, scalefact);
w = pixGetWidth(pixs);
pixaf = pixaCreate(5);
/* TRC: vary gamma */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixGammaTRC(NULL, pixs, 0.3 + 0.15 * i, 0, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 32);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixt1, 0, 100, "TRC Gamma", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* TRC: vary black point */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixGammaTRC(NULL, pixs, 1.0, 5 * i, 255);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixt1, 300, 100, "TRC", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary hue */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixModifyHue(NULL, pixs, 0.01 + 0.05 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixt1, 600, 100, "Hue", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary saturation */
pixa = pixaCreate(20);
na = numaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixModifySaturation(NULL, pixs, -0.9 + 0.1 * i);
pixMeasureSaturation(pixt0, 1, &sat);
pixaAddPix(pixa, pixt0, L_INSERT);
numaAddNumber(na, sat);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
gplotSimple1(na, GPLOT_PNG, "/tmp/regout/enhance.7", "Average Saturation");
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixt1, 900, 100, "Saturation", rp->display);
numaDestroy(&na);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary contrast */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixContrastTRC(NULL, pixs, 0.1 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixt1, 0, 400, "Contrast", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Vary sharpening */
pixa = pixaCreate(20);
for (i = 0; i < 20; i++) {
pixt0 = pixUnsharpMasking(pixs, 3, 0.01 + 0.15 * i);
pixaAddPix(pixa, pixt0, L_INSERT);
}
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, w, 5, 0, 10, 2);
pixSaveTiled(pixt1, pixaf, 1.0, 1, 20, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixt1, 300, 400, "Sharp", rp->display);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* Hue constant mapping to lighter background */
pixa = pixaCreate(11);
bmf8 = bmfCreate("fonts", 8);
pixt0 = pixRead("candelabrum-11.jpg");
composeRGBPixel(230, 185, 144, &srcval); /* select typical bg pixel */
for (i = 0; i <= 10; i++) {
fract = 0.10 * i;
pixelFractionalShift(230, 185, 144, fract, &dstval);
pixt1 = pixLinearMapToTargetColor(NULL, pixt0, srcval, dstval);
snprintf(textstr, 50, "Fract = %5.1f", fract);
pixt2 = pixAddSingleTextblock(pixt1, bmf8, textstr, 0xff000000,
L_ADD_BELOW, NULL);
pixSaveTiledOutline(pixt2, pixa, 1.0, (i % 4 == 0) ? 1 : 0, 30, 2, 32);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
pixDestroy(&pixt0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixd, 600, 400, "Constant hue", rp->display);
bmfDestroy(&bmf8);
pixaDestroy(&pixa);
pixDestroy(&pixd);
/* Delayed testing of saturation plot */
regTestCheckFile(rp, "/tmp/regout/enhance.7.png"); /* 7 */
/* Display results */
pixd = pixaDisplay(pixaf, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd, 100, 100, "All", rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixaf);
pixDestroy(&pix);
pixDestroy(&pixs);
/* -----------------------------------------------*
* Test global color transforms *
* -----------------------------------------------*/
/* Make identical cmap and rgb images */
pix = pixRead("wet-day.jpg");
pixs1 = pixOctreeColorQuant(pix, 200, 0);
pixs2 = pixRemoveColormap(pixs1, REMOVE_CMAP_TO_FULL_COLOR);
regTestComparePix(rp, pixs1, pixs2); /* 9 */
/* Make a diagonal color transform matrix */
kel = kernelCreate(3, 3);
kernelSetElement(kel, 0, 0, 0.7);
kernelSetElement(kel, 1, 1, 0.4);
kernelSetElement(kel, 2, 2, 1.3);
/* Apply to both cmap and rgb images. */
pixt1 = pixMultMatrixColor(pixs1, kel);
pixt2 = pixMultMatrixColor(pixs2, kel);
regTestComparePix(rp, pixt1, pixt2); /* 10 */
kernelDestroy(&kel);
/* Apply the same transform in the simpler interface */
pixt3 = pixMultConstantColor(pixs1, 0.7, 0.4, 1.3);
pixt4 = pixMultConstantColor(pixs2, 0.7, 0.4, 1.3);
regTestComparePix(rp, pixt3, pixt4); /* 11 */
regTestComparePix(rp, pixt1, pixt3); /* 12 */
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 13 */
pixDestroy(&pix);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
l_int32 ret, i, n, similar, x1, y1, val1, val2, val3, val4;
l_float32 minave, minave2, maxave, fract;
NUMA *na1, *na2, *na3, *na4, *na5, *na6;
NUMAA *naa;
PIX *pixs, *pix1, *pix2, *pix3, *pix4;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn.tif");
pix1 = pixScaleToGray6(pixs);
pixDisplayWithTitle(pix1, 100, 600, NULL, rp->display);
/* Find averages of min and max along about 120 horizontal lines */
fprintf(stderr, "Ignore the following 12 error messages:\n");
na1 = numaCreate(0);
na3 = numaCreate(0);
for (y1 = 40; y1 < 575; y1 += 5) {
ret = pixMinMaxNearLine(pix1, 20, y1, 400, y1, 5, L_SCAN_BOTH,
NULL, NULL, &minave, &maxave);
if (!ret) {
numaAddNumber(na1, (l_int32)minave);
numaAddNumber(na3, (l_int32)maxave);
if (rp->display)
fprintf(stderr, "y = %d: minave = %d, maxave = %d\n",
y1, (l_int32)minave, (l_int32)maxave);
}
}
/* Find averages along about 120 vertical lines. We've rotated
* the image by 90 degrees, so the results should be nearly
* identical to the first set. Also generate a single-sided
* scan (L_SCAN_NEGATIVE) for comparison with the double-sided scans. */
pix2 = pixRotateOrth(pix1, 3);
pixDisplayWithTitle(pix2, 600, 600, NULL, rp->display);
na2 = numaCreate(0);
na4 = numaCreate(0);
na5 = numaCreate(0);
for (x1 = 40; x1 < 575; x1 += 5) {
ret = pixMinMaxNearLine(pix2, x1, 20, x1, 400, 5, L_SCAN_BOTH,
NULL, NULL, &minave, &maxave);
pixMinMaxNearLine(pix2, x1, 20, x1, 400, 5, L_SCAN_NEGATIVE,
NULL, NULL, &minave2, NULL);
if (!ret) {
numaAddNumber(na2, (l_int32)minave);
numaAddNumber(na4, (l_int32)maxave);
numaAddNumber(na5, (l_int32)minave2);
if (rp->display)
fprintf(stderr,
"x = %d: minave = %d, minave2 = %d, maxave = %d\n",
x1, (l_int32)minave, (l_int32)minave2, (l_int32)maxave);
}
}
numaSimilar(na1, na2, 3.0, &similar); /* should be TRUE */
regTestCompareValues(rp, similar, 1, 0); /* 0 */
numaSimilar(na3, na4, 1.0, &similar); /* should be TRUE */
regTestCompareValues(rp, similar, 1, 0); /* 1 */
numaWrite("/tmp/lept/regout/na1.na", na1);
numaWrite("/tmp/lept/regout/na2.na", na2);
numaWrite("/tmp/lept/regout/na3.na", na3);
numaWrite("/tmp/lept/regout/na4.na", na4);
numaWrite("/tmp/lept/regout/na5.na", na5);
regTestCheckFile(rp, "/tmp/lept/regout/na1.na"); /* 2 */
regTestCheckFile(rp, "/tmp/lept/regout/na2.na"); /* 3 */
regTestCheckFile(rp, "/tmp/lept/regout/na3.na"); /* 4 */
regTestCheckFile(rp, "/tmp/lept/regout/na4.na"); /* 5 */
regTestCheckFile(rp, "/tmp/lept/regout/na5.na"); /* 6 */
/* Plot the average minimums for the 3 cases */
naa = numaaCreate(3);
numaaAddNuma(naa, na1, L_INSERT); /* portrait, double-sided */
numaaAddNuma(naa, na2, L_INSERT); /* landscape, double-sided */
numaaAddNuma(naa, na5, L_INSERT); /* landscape, single-sided */
gplotSimpleN(naa, GPLOT_PNG, "/tmp/lept/regout/nearline",
"Average minimums along lines");
#if 0
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
#endif
pix3 = pixRead("/tmp/lept/regout/nearline.png");
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix3, 100, 100, NULL, rp->display);
if (rp->display) {
n = numaGetCount(na3);
for (i = 0; i < n; i++) {
numaGetIValue(na1, i, &val1);
numaGetIValue(na2, i, &val2);
numaGetIValue(na3, i, &val3);
numaGetIValue(na4, i, &val4);
fprintf(stderr, "val1 = %d, val2 = %d, diff = %d; "
"val3 = %d, val4 = %d, diff = %d\n",
val1, val2, L_ABS(val1 - val2),
val3, val4, L_ABS(val3 - val4));
}
}
numaaDestroy(&naa);
numaDestroy(&na3);
numaDestroy(&na4);
/* Plot minima along a single line, with different distances */
pixMinMaxNearLine(pix1, 20, 200, 400, 200, 2, L_SCAN_BOTH,
&na1, NULL, NULL, NULL);
pixMinMaxNearLine(pix1, 20, 200, 400, 200, 5, L_SCAN_BOTH,
&na2, NULL, NULL, NULL);
pixMinMaxNearLine(pix1, 20, 200, 400, 200, 15, L_SCAN_BOTH,
&na3, NULL, NULL, NULL);
numaWrite("/tmp/lept/regout/na6.na", na1);
regTestCheckFile(rp, "/tmp/lept/regout/na6.na"); /* 8 */
n = numaGetCount(na1);
fract = 100.0 / n;
na4 = numaTransform(na1, 0.0, fract);
na5 = numaTransform(na2, 0.0, fract);
na6 = numaTransform(na3, 0.0, fract);
numaDestroy(&na1);
numaDestroy(&na2);
numaDestroy(&na3);
na1 = numaUniformSampling(na4, 100);
na2 = numaUniformSampling(na5, 100);
na3 = numaUniformSampling(na6, 100);
naa = numaaCreate(3);
numaaAddNuma(naa, na1, L_INSERT);
numaaAddNuma(naa, na2, L_INSERT);
numaaAddNuma(naa, na3, L_INSERT);
gplotSimpleN(naa, GPLOT_PNG, "/tmp/lept/regout/nearline2",
"Min along line");
pix4 = pixRead("/tmp/lept/regout/nearline2.png");
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 9 */
pixDisplayWithTitle(pix4, 800, 100, NULL, rp->display);
numaaDestroy(&naa);
numaDestroy(&na4);
numaDestroy(&na5);
numaDestroy(&na6);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
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);
}
main(int argc,
char **argv)
{
l_int32 w, h, success, display;
l_float32 factor, scale;
BOX *box;
FILE *fp, *fp1;
PIX *pixs, *pixt;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
factor = 0.95;
/* Uncompressed PS with scaling but centered on the page */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
scale = L_MIN(factor * 2550 / w, factor * 3300 / h);
fp1 = fopen("/tmp/psio0.ps", "wb+");
pixWriteStreamPS(fp1, pixs, NULL, 300, scale);
fclose(fp1);
regTestCheckFile(fp, argv, "/tmp/psio0.ps", 0, &success);
pixDestroy(&pixs);
/* Uncompressed PS with scaling, with LL corner at (1500, 1500) mils */
pixs = pixRead("weasel4.11c.png");
pixGetDimensions(pixs, &w, &h, NULL);
scale = L_MIN(factor * 2550 / w, factor * 3300 / h);
box = boxCreate(1500, 1500, (l_int32)(1000 * scale * w / 300),
(l_int32)(1000 * scale * h / 300));
fp1 = fopen("/tmp/psio1.ps", "wb+");
pixWriteStreamPS(fp1, pixs, box, 300, 1.0);
fclose(fp1);
regTestCheckFile(fp, argv, "/tmp/psio1.ps", 1, &success);
boxDestroy(&box);
pixDestroy(&pixs);
/* DCT compressed PS with LL corner at (300, 1000) pixels */
pixs = pixRead("marge.jpg");
pixt = pixConvertTo32(pixs);
pixWrite("/tmp/psio2.jpg", pixt, IFF_JFIF_JPEG);
convertJpegToPS("/tmp/psio2.jpg", "/tmp/psio3.ps",
"w", 300, 1000, 0, 4.0, 1, 1);
regTestCheckFile(fp, argv, "/tmp/psio2.jpg", 2, &success);
regTestCheckFile(fp, argv, "/tmp/psio3.ps", 3, &success);
pixDestroy(&pixt);
pixDestroy(&pixs);
/* For each page, apply tiff g4 image first; then jpeg or png over it */
convertTiffG4ToPS("feyn.tif", "/tmp/psio4.ps",
"w", 0, 0, 0, 1.0, 1, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/psio4.ps",
"a", 500, 100, 300, 2.0, 1, 0);
convertFlateToPS("weasel4.11c.png", "/tmp/psio4.ps",
"a", 300, 400, 300, 6.0, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/psio4.ps",
"a", 100, 800, 300, 1.5, 1, 1);
convertTiffG4ToPS("feyn.tif", "/tmp/psio4.ps",
"a", 0, 0, 0, 1.0, 2, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/psio4.ps",
"a", 1000, 700, 300, 2.0, 2, 0);
convertJpegToPS("marge.jpg", "/tmp/psio4.ps",
"a", 100, 200, 300, 2.0, 2, 1);
convertTiffG4ToPS("feyn.tif", "/tmp/psio4.ps",
"a", 0, 0, 0, 1.0, 3, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/psio4.ps",
"a", 200, 200, 300, 2.0, 3, 0);
convertJpegToPS("marge.jpg", "/tmp/psio4.ps",
"a", 200, 900, 300, 2.0, 3, 1);
regTestCheckFile(fp, argv, "/tmp/psio4.ps", 4, &success);
/* Now apply jpeg first; then paint through a g4 mask.
* For gv, the first image with a b.b. determines the
* window size for the canvas, so we put down the largest
* image first. If we had rendered a small image first,
* gv and evince will not show the entire page. However, after
* conversion to pdf, everything works fine, regardless of the
* order in which images are placed into the PS. That is
* because the pdf interpreter is robust to bad hints, ignoring
* the page hints and computing the bounding box from the
* set of images rendered on the page. */
pixs = pixRead("wyom.jpg");
pixt = pixScaleToSize(pixs, 2528, 3300);
pixWrite("/tmp/psio5.jpg", pixt, IFF_JFIF_JPEG);
pixDestroy(&pixs);
pixDestroy(&pixt);
convertJpegToPS("/tmp/psio5.jpg", "/tmp/psio5.ps",
"w", 0, 0, 0, 1.0, 1, 0);
convertFlateToPS("weasel8.240c.png", "/tmp/psio5.ps",
"a", 100, 100, 300, 5.0, 1, 0);
convertFlateToPS("weasel8.149g.png", "/tmp/psio5.ps",
"a", 200, 300, 300, 5.0, 1, 0);
convertFlateToPS("weasel4.11c.png", "/tmp/psio5.ps",
"a", 300, 500, 300, 5.0, 1, 0);
convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps",
"a", 0, 0, 0, 1.0, 1, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 500, 100, 300, 2.0, 2, 0);
convertFlateToPS("weasel4.11c.png", "/tmp/psio5.ps",
"a", 300, 400, 300, 6.0, 2, 0);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 100, 800, 300, 1.5, 2, 0);
convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps",
"a", 0, 0, 0, 1.0, 2, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 500, 100, 300, 2.0, 3, 0);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 100, 800, 300, 2.0, 3, 0);
convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps",
"a", 0, 0, 0, 1.0, 3, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 1000, 700, 300, 2.0, 4, 0);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 100, 200, 300, 2.0, 4, 0);
convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps",
"a", 0, 0, 0, 1.0, 4, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 200, 200, 300, 2.0, 5, 0);
convertJpegToPS("marge.jpg", "/tmp/psio5.ps",
"a", 200, 900, 300, 2.0, 5, 0);
convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps",
"a", 0, 0, 0, 1.0, 5, 1, 1);
regTestCheckFile(fp, argv, "/tmp/psio5.ps", 5, &success);
/* Generation using segmentation masks */
convertSegmentedPagesToPS(".", "lion-page", ".", "lion-mask",
10, 0, 100, 2.0, 0.8, 190, "/tmp/psio6.ps");
regTestCheckFile(fp, argv, "/tmp/psio6.ps", 6, &success);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, w, h;
l_float32 factor, scale;
BOX *box;
FILE *fp1;
PIX *pixs, *pixt;
PIXA *pixa;
SARRAY *sa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
factor = 0.95;
/* Uncompressed PS with scaling but centered on the page */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
scale = L_MIN(factor * 2550 / w, factor * 3300 / h);
fp1 = lept_fopen("/tmp/regout/psio0.ps", "wb+");
pixWriteStreamPS(fp1, pixs, NULL, 300, scale);
lept_fclose(fp1);
regTestCheckFile(rp, "/tmp/regout/psio0.ps"); /* 0 */
pixDestroy(&pixs);
/* Uncompressed PS with scaling, with LL corner at (1500, 1500) mils */
pixs = pixRead("weasel4.11c.png");
pixGetDimensions(pixs, &w, &h, NULL);
scale = L_MIN(factor * 2550 / w, factor * 3300 / h);
box = boxCreate(1500, 1500, (l_int32)(1000 * scale * w / 300),
(l_int32)(1000 * scale * h / 300));
fp1 = lept_fopen("/tmp/regout/psio1.ps", "wb+");
pixWriteStreamPS(fp1, pixs, box, 300, 1.0);
lept_fclose(fp1);
regTestCheckFile(rp, "/tmp/regout/psio1.ps"); /* 1 */
boxDestroy(&box);
pixDestroy(&pixs);
/* DCT compressed PS with LL corner at (300, 1000) pixels */
pixs = pixRead("marge.jpg");
pixt = pixConvertTo32(pixs);
pixWrite("/tmp/regout/psio2.jpg", pixt, IFF_JFIF_JPEG);
convertJpegToPS("/tmp/regout/psio2.jpg", "/tmp/regout/psio3.ps",
"w", 300, 1000, 0, 4.0, 1, 1);
regTestCheckFile(rp, "/tmp/regout/psio2.jpg"); /* 2 */
regTestCheckFile(rp, "/tmp/regout/psio3.ps"); /* 3 */
pixDestroy(&pixt);
pixDestroy(&pixs);
/* For each page, apply tiff g4 image first; then jpeg or png over it */
convertG4ToPS("feyn.tif", "/tmp/regout/psio4.ps", "w",
0, 0, 0, 1.0, 1, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps",
"a", 500, 100, 300, 2.0, 1, 0);
convertFlateToPS("weasel4.11c.png", "/tmp/regout/psio4.ps",
"a", 300, 400, 300, 6.0, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps",
"a", 100, 800, 300, 1.5, 1, 1);
convertG4ToPS("feyn.tif", "/tmp/regout/psio4.ps",
"a", 0, 0, 0, 1.0, 2, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps",
"a", 1000, 700, 300, 2.0, 2, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps",
"a", 100, 200, 300, 2.0, 2, 1);
convertG4ToPS("feyn.tif", "/tmp/regout/psio4.ps",
"a", 0, 0, 0, 1.0, 3, 1, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps",
"a", 200, 200, 300, 2.0, 3, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps",
"a", 200, 900, 300, 2.0, 3, 1);
regTestCheckFile(rp, "/tmp/regout/psio4.ps"); /* 4 */
/* Now apply jpeg first; then paint through a g4 mask.
* For gv, the first image with a b.b. determines the
* window size for the canvas, so we put down the largest
* image first. If we had rendered a small image first,
* gv and evince will not show the entire page. However, after
* conversion to pdf, everything works fine, regardless of the
* order in which images are placed into the PS. That is
* because the pdf interpreter is robust to bad hints, ignoring
* the page hints and computing the bounding box from the
* set of images rendered on the page.
*
* Concatenate several pages, with colormapped png, color
* jpeg and tiffg4 images (with the g4 image acting as a mask
* that we're painting black through. If the text layer
* is painted first, the following images occlude it; otherwise,
* the images remain in the background of the text. */
pixs = pixRead("wyom.jpg");
pixt = pixScaleToSize(pixs, 2528, 3300);
pixWrite("/tmp/regout/psio5.jpg", pixt, IFF_JFIF_JPEG);
pixDestroy(&pixs);
pixDestroy(&pixt);
convertJpegToPS("/tmp/regout/psio5.jpg", "/tmp/regout/psio5.ps",
"w", 0, 0, 300, 1.0, 1, 0);
convertFlateToPS("weasel8.240c.png", "/tmp/regout/psio5.ps",
"a", 100, 100, 300, 5.0, 1, 0);
convertFlateToPS("weasel8.149g.png", "/tmp/regout/psio5.ps",
"a", 200, 300, 300, 5.0, 1, 0);
convertFlateToPS("weasel4.11c.png", "/tmp/regout/psio5.ps",
"a", 300, 500, 300, 5.0, 1, 0);
convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps",
"a", 0, 0, 0, 1.0, 1, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 500, 100, 300, 2.0, 2, 0);
convertFlateToPS("weasel4.11c.png", "/tmp/regout/psio5.ps",
"a", 300, 400, 300, 6.0, 2, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 100, 800, 300, 1.5, 2, 0);
convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps",
"a", 0, 0, 0, 1.0, 2, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 500, 100, 300, 2.0, 3, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 100, 800, 300, 2.0, 3, 0);
convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps",
"a", 0, 0, 0, 1.0, 3, 1, 1);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 700, 700, 300, 2.0, 4, 0);
convertFlateToPS("weasel8.149g.png", "/tmp/regout/psio5.ps",
"a", 400, 400, 300, 5.0, 4, 0);
convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps",
"a", 0, 0, 0, 1.0, 4, 1, 0);
convertFlateToPS("weasel8.240c.png", "/tmp/regout/psio5.ps",
"a", 100, 220, 300, 5.0, 4, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 100, 200, 300, 2.0, 4, 1);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 200, 200, 300, 1.5, 5, 0);
convertFlateToPS("weasel8.240c.png", "/tmp/regout/psio5.ps",
"a", 140, 80, 300, 7.0, 5, 0);
convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps",
"a", 0, 0, 0, 1.0, 5, 1, 0);
convertFlateToPS("weasel8.149g.png", "/tmp/regout/psio5.ps",
"a", 280, 310, 300, 5.0, 4, 0);
convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps",
"a", 200, 900, 300, 2.0, 5, 1);
regTestCheckFile(rp, "/tmp/regout/psio5.ps"); /* 5 */
/* Generation using segmentation masks */
convertSegmentedPagesToPS(".", "lion-page", 10, ".", "lion-mask", 10,
0, 100, 2.0, 0.8, 190, "/tmp/regout/psio6.ps");
regTestCheckFile(rp, "/tmp/regout/psio6.ps"); /* 6 */
/* PS generation for embeddding */
convertJpegToPSEmbed("tetons.jpg", "/tmp/regout/psio7.ps");
regTestCheckFile(rp, "/tmp/regout/psio7.ps"); /* 7 */
convertG4ToPSEmbed("feyn-fract.tif", "/tmp/regout/psio8.ps");
regTestCheckFile(rp, "/tmp/regout/psio8.ps"); /* 8 */
convertFlateToPSEmbed("weasel8.240c.png", "/tmp/regout/psio9.ps");
regTestCheckFile(rp, "/tmp/regout/psio9.ps"); /* 9 */
/* Writing compressed from a pixa */
sa = sarrayCreate(0);
for (i = 0; i < 11; i++)
sarrayAddString(sa, WeaselNames[i], L_COPY);
pixa = pixaReadFilesSA(sa);
pixaWriteCompressedToPS(pixa, "/tmp/regout/psio10.ps", 0, 3);
regTestCheckFile(rp, "/tmp/regout/psio10.ps"); /* 10 */
pixaDestroy(&pixa);
sarrayDestroy(&sa);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
char buf[512];
l_int32 delx, dely, etransx, etransy, w, h, area1, area2;
l_int32 *stab, *ctab;
l_float32 cx1, cy1, cx2, cy2, score;
PIX *pix0, *pix1, *pix2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Test of pixBestCorrelation() --------------- */
pix0 = pixRead("harmoniam100-11.png");
pix1 = pixConvertTo1(pix0, 160);
pixGetDimensions(pix1, &w, &h, NULL);
/* Now make a smaller image, translated by (-32, -12)
* Except for the resizing, this is equivalent to
* pix2 = pixTranslate(NULL, pix1, -32, -12, L_BRING_IN_WHITE); */
pix2 = pixCreate(w - 10, h, 1);
pixRasterop(pix2, 0, 0, w, h, PIX_SRC, pix1, 32, 12);
/* Get the number of FG pixels and the centroid locations */
stab = makePixelSumTab8();
ctab = makePixelCentroidTab8();
pixCountPixels(pix1, &area1, stab);
pixCountPixels(pix2, &area2, stab);
pixCentroid(pix1, ctab, stab, &cx1, &cy1);
pixCentroid(pix2, ctab, stab, &cx2, &cy2);
etransx = lept_roundftoi(cx1 - cx2);
etransy = lept_roundftoi(cy1 - cy2);
fprintf(stderr, "delta cx = %d, delta cy = %d\n",
etransx, etransy);
/* Get the best correlation, searching around the translation
* where the centroids coincide */
pixBestCorrelation(pix1, pix2, area1, area2, etransx, etransy,
4, stab, &delx, &dely, &score, 5);
fprintf(stderr, "delx = %d, dely = %d, score = %7.4f\n",
delx, dely, score);
regTestCompareValues(rp, 32, delx, 0); /* 0 */
regTestCompareValues(rp, 12, dely, 0); /* 1 */
regTestCheckFile(rp, "/tmp/junkcorrel_5.png"); /* 2 */
lept_rm(NULL, "junkcorrel_5.png");
FREE(stab);
FREE(ctab);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------ Test of pixCompareWithTranslation() ------------ */
/* Now use the pyramid to get the result. Do a translation
* to remove pixels at the bottom from pix2, so that the
* centroids are initially far apart. */
pix1 = pixRead("harmoniam-11.tif");
pix2 = pixTranslate(NULL, pix1, -45, 25, L_BRING_IN_WHITE);
l_pdfSetDateAndVersion(0);
pixCompareWithTranslation(pix1, pix2, 160, &delx, &dely, &score, 1);
pixDestroy(&pix1);
pixDestroy(&pix2);
fprintf(stderr, "delx = %d, dely = %d\n", delx, dely);
regTestCompareValues(rp, 45, delx, 0); /* 3 */
regTestCompareValues(rp, -25, dely, 0); /* 4 */
regTestCheckFile(rp, "/tmp/junkcmp.pdf"); /* 5 */
regTestCheckFile(rp, "/tmp/junkcorrel.pdf"); /* 6 */
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, n;
l_float32 pi, angle, val;
BOX *box;
BOXA *boxa, *boxa1, *boxa2;
NUMA *na1, *na2;
PIX *pix, *pix1, *pix2;
PIXA *pixa1, *pixa2, *pixa3, *pixa4;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmfile("/tmp/regout/insert3.ba");
lept_rmfile("/tmp/regout/insert4.ba");
lept_rmfile("/tmp/regout/insert6.pa");
lept_rmfile("/tmp/regout/insert7.pa");
lept_rmfile("/tmp/regout/insert9.pa");
lept_rmfile("/tmp/regout/insert10.pa");
/* ----------------- Test numa operations -------------------- */
pi = 3.1415926535;
na1 = numaCreate(500);
for (i = 0; i < 500; i++) {
angle = 0.02293 * i * pi;
val = (l_float32)sin(angle);
numaAddNumber(na1, val);
}
numaWrite("/tmp/regout/insert0.na", na1);
na2 = numaCopy(na1);
n = numaGetCount(na2);
for (i = 0; i < n; i++) {
numaGetFValue(na2, i, &val);
numaRemoveNumber(na2, i);
numaInsertNumber(na2, i, val);
}
numaWrite("/tmp/regout/insert1.na", na2);
regTestCheckFile(rp, "/tmp/regout/insert0.na"); /* 0 */
regTestCheckFile(rp, "/tmp/regout/insert1.na"); /* 1 */
regTestCompareFiles(rp, 0, 1); /* 2 */
numaDestroy(&na1);
numaDestroy(&na2);
/* ----------------- Test boxa operations -------------------- */
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa1 = pixConnComp(pix2, NULL, 8);
boxaWrite("/tmp/regout/insert3.ba", boxa1);
boxa2 = boxaCopy(boxa1, L_COPY);
n = boxaGetCount(boxa2);
for (i = 0; i < n; i++) {
boxaRemoveBoxAndSave(boxa2, i, &box);
boxaInsertBox(boxa2, i, box);
}
boxaWrite("/tmp/regout/insert4.ba", boxa2);
regTestCheckFile(rp, "/tmp/regout/insert3.ba"); /* 3 */
regTestCheckFile(rp, "/tmp/regout/insert4.ba"); /* 4 */
regTestCompareFiles(rp, 3, 4); /* 5 */
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* ----------------- Test pixa operations -------------------- */
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa = pixConnComp(pix2, &pixa1, 8);
boxaDestroy(&boxa);
pixaWrite("/tmp/regout/insert6.pa", pixa1);
regTestCheckFile(rp, "/tmp/regout/insert6.pa"); /* 6 */
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Remove and insert each one */
pixa2 = pixaCopy(pixa1, L_COPY);
n = pixaGetCount(pixa2);
for (i = 0; i < n; i++) {
pixaRemovePixAndSave(pixa2, i, &pix, &box);
pixaInsertPix(pixa2, i, pix, box);
}
pixaWrite("/tmp/regout/insert7.pa", pixa2);
regTestCheckFile(rp, "/tmp/regout/insert7.pa"); /* 7 */
regTestCompareFiles(rp, 6, 7); /* 8 */
/* Move the last to the beginning; do it n times */
pixa3 = pixaCopy(pixa2, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa3, n - 1, L_CLONE);
box = pixaGetBox(pixa3, n - 1, L_CLONE);
pixaInsertPix(pixa3, 0, pix, box);
pixaRemovePix(pixa3, n);
}
pixaWrite("/tmp/regout/insert9.pa", pixa3);
regTestCheckFile(rp, "/tmp/regout/insert9.pa"); /* 9 */
/* Move the first one to the end; do it n times */
pixa4 = pixaCopy(pixa3, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa4, 0, L_CLONE);
box = pixaGetBox(pixa4, 0, L_CLONE);
pixaInsertPix(pixa4, n, pix, box); /* make sure insert works at end */
pixaRemovePix(pixa4, 0);
}
pixaWrite("/tmp/regout/insert10.pa", pixa4);
regTestCheckFile(rp, "/tmp/regout/insert10.pa"); /* 10 */
regTestCompareFiles(rp, 9, 10); /* 11 */
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixaDestroy(&pixa4);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
char *str;
l_int32 i, j, same, ok;
l_float32 sum, avediff, rmsdiff;
L_KERNEL *kel1, *kel2, *kel3, *kel4, *kelx, *kely;
BOX *box;
PIX *pix, *pixs, *pixb, *pixg, *pixr, *pixd, *pixp, *pixt;
PIX *pixt1, *pixt2, *pixt3;
PIXA *pixa;
SARRAY *sa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Test creating from a string */
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = kernelDisplayInPix(kel1, 41, 2);
pixWrite("/tmp/pixkern.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/pixkern.png"); /* 0 */
pixSaveTiled(pixd, pixa, 1, 1, 20, 8);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test read/write for kernel. Note that both get
* compared to the same golden file, which is
* overwritten with a copy of /tmp/kern2.kel */
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
kernelWrite("/tmp/kern1.kel", kel1);
regTestCheckFile(rp, "/tmp/kern1.kel"); /* 1 */
kel2 = kernelRead("/tmp/kern1.kel");
kernelWrite("/tmp/kern2.kel", kel2);
regTestCheckFile(rp, "/tmp/kern2.kel"); /* 2 */
regTestCompareFiles(rp, 1, 2); /* 3 */
kernelDestroy(&kel1);
kernelDestroy(&kel2);
/* Test creating from a file */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"# small 3x3 kernel", L_COPY);
sarrayAddString(sa, (char *)"3 5", L_COPY);
sarrayAddString(sa, (char *)"1 2", L_COPY);
sarrayAddString(sa, (char *)"20.5 50 80 50 20", L_COPY);
sarrayAddString(sa, (char *)"82. 120 180 120 80", L_COPY);
sarrayAddString(sa, (char *)"22.1 50 80 50 20", L_COPY);
str = sarrayToString(sa, 1);
l_binaryWrite("/tmp/kernfile.kel", "w", str, strlen(str));
kel2 = kernelCreateFromFile("/tmp/kernfile.kel");
pixd = kernelDisplayInPix(kel2, 41, 2);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/ker1.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker1.png"); /* 4 */
pixDestroy(&pixd);
sarrayDestroy(&sa);
lept_free(str);
kernelDestroy(&kel2);
/* Test creating from a pix */
pixt = pixCreate(5, 3, 8);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 0, 50);
pixSetPixel(pixt, 2, 0, 80);
pixSetPixel(pixt, 3, 0, 50);
pixSetPixel(pixt, 4, 0, 20);
pixSetPixel(pixt, 0, 1, 80);
pixSetPixel(pixt, 1, 1, 120);
pixSetPixel(pixt, 2, 1, 180);
pixSetPixel(pixt, 3, 1, 120);
pixSetPixel(pixt, 4, 1, 80);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 2, 50);
pixSetPixel(pixt, 2, 2, 80);
pixSetPixel(pixt, 3, 2, 50);
pixSetPixel(pixt, 4, 2, 20);
kel3 = kernelCreateFromPix(pixt, 1, 2);
pixd = kernelDisplayInPix(kel3, 41, 2);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker2.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker2.png"); /* 5 */
pixDestroy(&pixd);
pixDestroy(&pixt);
kernelDestroy(&kel3);
/* Test convolution with kel1 */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 3, COLOR_GREEN);
pixSaveTiled(pixg, pixa, 1, 1, 20, 0);
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = pixConvolve(pixg, kel1, 8, 1);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker3.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker3.png"); /* 6 */
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test convolution with flat rectangular kel; also test
* block convolution with tiling. */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 3, COLOR_GREEN);
kel2 = makeFlatKernel(11, 11, 5, 5);
pixd = pixConvolve(pixg, kel2, 8, 1);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/ker4.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker4.png"); /* 7 */
pixt = pixBlockconv(pixg, 5, 5);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker5.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker5.png"); /* 8 */
if (rp->display)
pixCompareGray(pixd, pixt, L_COMPARE_ABS_DIFF, GPLOT_X11, NULL,
NULL, NULL, NULL);
pixt2 = pixBlockconvTiled(pixg, 5, 5, 3, 6);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker5a.png", pixt2, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker5a.png"); /* 9 */
pixDestroy(&pixt2);
ok = TRUE;
for (i = 1; i <= 7; i++) {
for (j = 1; j <= 7; j++) {
if (i == 1 && j == 1) continue;
pixt2 = pixBlockconvTiled(pixg, 5, 5, j, i);
pixEqual(pixt2, pixd, &same);
if (!same) {
fprintf(stderr," Error for nx = %d, ny = %d\n", j, i);
ok = FALSE;
}
pixDestroy(&pixt2);
}
}
if (ok)
fprintf(stderr, "OK: Tiled results identical to pixConvolve()\n");
else
fprintf(stderr, "ERROR: Tiled results not identical to pixConvolve()\n");
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixDestroy(&pixt);
kernelDestroy(&kel2);
/* Do another flat rectangular test; this time with white at edge.
* About 1% of the pixels near the image edge differ by 1 between
* the pixConvolve() and pixBlockconv(). For what it's worth,
* pixConvolve() gives the more accurate result; namely, 255 for
* pixels at the edge. */
pix = pixRead("pageseg1.tif");
box = boxCreate(100, 100, 2260, 3160);
pixb = pixClipRectangle(pix, box, NULL);
pixs = pixScaleToGray4(pixb);
kel3 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt = pixConvolve(pixs, kel3, 8, 1);
fprintf(stderr, "Generic convolution time: %5.3f sec\n", stopTimer());
pixSaveTiled(pixt, pixa, 1, 1, 20, 0);
pixWrite("/tmp/conv1.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/conv1.png"); /* 10 */
startTimer();
pixt2 = pixBlockconv(pixs, 3, 3);
fprintf(stderr, "Flat block convolution time: %5.3f sec\n", stopTimer());
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/conv2.png", pixt2, IFF_PNG); /* ditto */
regTestCheckFile(rp, "/tmp/conv2.png"); /* 11 */
pixCompareGray(pixt, pixt2, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&avediff, &rmsdiff, NULL);
#ifndef _WIN32
sleep(1); /* give gnuplot time to write out the file */
#else
Sleep(1000);
#endif /* _WIN32 */
pixp = pixRead("/tmp/grayroot.png");
pixSaveTiled(pixp, pixa, 1, 0, 20, 0);
pixWrite("/tmp/conv3.png", pixp, IFF_PNG);
regTestCheckFile(rp, "/tmp/conv3.png"); /* 12 */
fprintf(stderr, "Ave diff = %6.4f, RMS diff = %6.4f\n", avediff, rmsdiff);
if (avediff <= 0.01)
fprintf(stderr, "OK: avediff = %6.4f <= 0.01\n", avediff);
else
fprintf(stderr, "Bad?: avediff = %6.4f > 0.01\n", avediff);
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDestroy(&pixp);
pixDestroy(&pix);
pixDestroy(&pixb);
boxDestroy(&box);
kernelDestroy(&kel3);
/* Do yet another set of flat rectangular tests, this time
* on an RGB image */
pixs = pixRead("test24.jpg");
kel4 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt1 = pixConvolveRGB(pixs, kel4);
fprintf(stderr, "Time 7x7 non-separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv4.jpg", pixt1, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv4.jpg"); /* 13 */
kelx = makeFlatKernel(1, 7, 0, 3);
kely = makeFlatKernel(7, 1, 3, 0);
startTimer();
pixt2 = pixConvolveRGBSep(pixs, kelx, kely);
fprintf(stderr, "Time 7x1,1x7 separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv5.jpg", pixt2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv5.jpg"); /* 14 */
startTimer();
pixt3 = pixBlockconv(pixs, 3, 3);
fprintf(stderr, "Time 7x7 blockconv: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv6.jpg", pixt3, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv6.jpg"); /* 15 */
regTestComparePix(rp, pixt1, pixt2); /* 16 */
regTestCompareSimilarPix(rp, pixt2, pixt3, 15, 0.0005, 0); /* 17 */
pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
kernelDestroy(&kel4);
kernelDestroy(&kelx);
kernelDestroy(&kely);
/* Test generation and convolution with gaussian kernel */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
kel1 = makeGaussianKernel(5, 5, 3.0, 5.0);
kernelGetSum(kel1, &sum);
fprintf(stderr, "Sum for gaussian kernel = %f\n", sum);
kernelWrite("/tmp/gauss.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 1);
pixt2 = pixConvolve(pixs, kel1, 16, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker6.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker6.png"); /* 18 */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixt = kernelDisplayInPix(kel1, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kel1);
pixDestroy(&pixs);
/* Test generation and convolution with separable gaussian kernel */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
makeGaussianKernelSep(5, 5, 3.0, 5.0, &kelx, &kely);
kernelGetSum(kelx, &sum);
fprintf(stderr, "Sum for x gaussian kernel = %f\n", sum);
kernelGetSum(kely, &sum);
fprintf(stderr, "Sum for y gaussian kernel = %f\n", sum);
kernelWrite("/tmp/gauss.kelx", kelx);
kernelWrite("/tmp/gauss.kely", kely);
pixt = pixConvolveSep(pixs, kelx, kely, 8, 1);
pixt2 = pixConvolveSep(pixs, kelx, kely, 16, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker7.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker7.png"); /* 19 */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixt = kernelDisplayInPix(kelx, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kelx);
kernelDestroy(&kely);
pixDestroy(&pixs);
/* Test generation and convolution with diff of gaussians kernel */
/* pixt = pixRead("marge.jpg");
pixs = pixConvertRGBToLuminance(pixt);
pixDestroy(&pixt); */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
kel1 = makeDoGKernel(7, 7, 1.5, 2.7);
kernelGetSum(kel1, &sum);
fprintf(stderr, "Sum for DoG kernel = %f\n", sum);
kernelWrite("/tmp/dog.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 0);
/* pixInvert(pixt, pixt); */
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker8.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker8.png"); /* 20 */
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kel1, 20, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kel1);
pixDestroy(&pixs);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixWrite("/tmp/kernel.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
regTestCleanup(rp);
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, j, w, h, display, success;
l_int32 minsum[5] = { 2, 40, 50, 50, 70};
l_int32 skipdist[5] = { 5, 5, 10, 10, 30};
l_int32 delta[5] = { 2, 10, 10, 25, 40};
l_int32 maxbg[5] = {10, 15, 10, 20, 40};
BOX *box1, *box2, *box3, *box4;
BOXA *boxa;
FILE *fp;
PIX *pixs, *pixc, *pixt, *pixd, *pix32;
PIXA *pixas, *pixad;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Generate and save 1 bpp masks */
pixas = pixaCreate(0);
pixs = pixCreate(300, 250, 1);
pixSetAll(pixs);
box1 = boxCreate(50, 0, 140, 25);
box2 = boxCreate(120, 100, 100, 25);
box3 = boxCreate(75, 170, 80, 20);
box4 = boxCreate(150, 80, 25, 70);
pixClearInRect(pixs, box1);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box2);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box3);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
pixClearInRect(pixs, box4);
pixaAddPix(pixas, pixs, L_COPY);
pixt = pixRotateOrth(pixs, 1);
pixaAddPix(pixas, pixt, L_INSERT);
boxDestroy(&box1);
boxDestroy(&box2);
boxDestroy(&box3);
boxDestroy(&box4);
pixDestroy(&pixs);
/* Do 5 splittings on each of the 8 masks */
pixad = pixaCreate(0);
for (j = 0; j < 8; j++) {
pixt = pixaGetPix(pixas, j, L_CLONE);
pixGetDimensions(pixt, &w, &h, NULL);
pix32 = pixCreate(w, h, 32);
pixSetAll(pix32);
pixPaintThroughMask(pix32, pixt, 0, 0, 0xc0c0c000);
pixSaveTiled(pix32, pixad, 1, 1, 30, 32);
for (i = 0; i < 5; i++) {
pixc = pixCopy(NULL, pix32);
boxa = pixSplitComponentIntoBoxa(pixt, NULL, minsum[i], skipdist[i],
delta[i], maxbg[i], 0, 1);
/* boxaWriteStream(stderr, boxa); */
pixd = pixBlendBoxaRandom(pixc, boxa, 0.4);
pixRenderBoxaArb(pixd, boxa, 2, 255, 0, 0);
pixSaveTiled(pixd, pixad, 1, 0, 30, 32);
pixDestroy(&pixd);
pixDestroy(&pixc);
boxaDestroy(&boxa);
}
pixDestroy(&pixt);
pixDestroy(&pix32);
}
/* Display results */
pixd = pixaDisplay(pixad, 0, 0);
pixWrite("/tmp/split.0.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/split.0.png", 0, &success);
pixDisplayWithTitle(pixd, 100, 100, NULL, display);
pixDestroy(&pixd);
pixaDestroy(&pixad);
/* Put the 8 masks all together, and split 5 ways */
pixad = pixaCreate(0);
pixs = pixaDisplayOnLattice(pixas, 325, 325);
pixGetDimensions(pixs, &w, &h, NULL);
pix32 = pixCreate(w, h, 32);
pixSetAll(pix32);
pixPaintThroughMask(pix32, pixs, 0, 0, 0xc0c0c000);
pixSaveTiled(pix32, pixad, 1, 1, 30, 32);
for (i = 0; i < 5; i++) {
pixc = pixCopy(NULL, pix32);
boxa = pixSplitIntoBoxa(pixs, minsum[i], skipdist[i],
delta[i], maxbg[i], 0, 1);
/* boxaWriteStream(stderr, boxa); */
pixd = pixBlendBoxaRandom(pixc, boxa, 0.4);
pixRenderBoxaArb(pixd, boxa, 2, 255, 0, 0);
pixSaveTiled(pixd, pixad, 1, 0, 30, 32);
pixDestroy(&pixd);
pixDestroy(&pixc);
boxaDestroy(&boxa);
}
pixDestroy(&pix32);
pixDestroy(&pixs);
/* Display results */
pixd = pixaDisplay(pixad, 0, 0);
pixWrite("/tmp/split.1.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/split.1.png", 1, &success);
pixDisplayWithTitle(pixd, 600, 100, NULL, display);
pixDestroy(&pixd);
pixaDestroy(&pixad);
pixaDestroy(&pixas);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc,
char **argv)
{
l_uint8 *data;
l_int32 w, h, n1, n2, n, i, minval, maxval;
l_int32 ncolors, rval, gval, bval, equal;
l_int32 *rmap, *gmap, *bmap;
l_uint32 color;
l_float32 gamma;
BOX *box;
FILE *fp;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixb, *pixg, *pixc, *pixd;
PIX *pixg2, *pixcs1, *pixcs2, *pixd1, *pixd2;
PIXA *pixa, *pixa2, *pixa3;
PIXCMAP *cmap, *cmap2;
RGBA_QUAD *cta;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------------------ (1) ----------------------------*/
/* Blend with a white background */
pix1 = pixRead("books_logo.png");
pixDisplayWithTitle(pix1, 100, 0, NULL, rp->display);
pix2 = pixAlphaBlendUniform(pix1, 0xffffff00);
pixDisplayWithTitle(pix2, 100, 150, NULL, rp->display);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
/* Generate an alpha layer based on the white background */
pix3 = pixSetAlphaOverWhite(pix2);
pixSetSpp(pix3, 3);
pixWrite("/tmp/alphaops.2.png", pix3, IFF_PNG); /* without alpha */
regTestCheckFile(rp, "/tmp/alphaops.2.png"); /* 2 */
pixSetSpp(pix3, 4);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3, with alpha */
pixDisplayWithTitle(pix3, 100, 300, NULL, rp->display);
/* Render on a light yellow background */
pix4 = pixAlphaBlendUniform(pix3, 0xffffe000);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 100, 450, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* ------------------------ (2) ----------------------------*/
lept_rmdir("alpha");
lept_mkdir("alpha");
/* Make the transparency (alpha) layer.
* pixs is the mask. We turn it into a transparency (alpha)
* layer by converting to 8 bpp. A small convolution fuzzes
* the mask edges so that you don't see the pixels. */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
pixg = pixConvert1To8(NULL, pixs, 0, 255);
pixg2 = pixBlockconvGray(pixg, NULL, 1, 1);
regTestWritePixAndCheck(rp, pixg2, IFF_JFIF_JPEG); /* 5 */
pixDisplayWithTitle(pixg2, 0, 0, "alpha", rp->display);
/* Make the viewable image.
* pixc is the image that we see where the alpha layer is
* opaque -- i.e., greater than 0. Scale it to the same
* size as the mask. To visualize what this will look like
* when displayed over a black background, create the black
* background image, pixb, and do the blending with pixcs1
* explicitly using the alpha layer pixg2. */
pixc = pixRead("tetons.jpg");
pixcs1 = pixScaleToSize(pixc, w, h);
regTestWritePixAndCheck(rp, pixcs1, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixcs1, 300, 0, "viewable", rp->display);
pixb = pixCreateTemplate(pixcs1); /* black */
pixd1 = pixBlendWithGrayMask(pixb, pixcs1, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd1, IFF_JFIF_JPEG); /* 7 */
pixDisplayWithTitle(pixd1, 600, 0, "alpha-blended 1", rp->display);
/* Embed the alpha layer pixg2 into the color image pixc.
* Write it out as is. Then clean pixcs1 (to 0) under the fully
* transparent part of the alpha layer, and write that result
* out as well. */
pixSetRGBComponent(pixcs1, pixg2, L_ALPHA_CHANNEL);
pixWrite("/tmp/alpha/pixcs1.png", pixcs1, IFF_PNG);
pixcs2 = pixSetUnderTransparency(pixcs1, 0, 0);
pixWrite("/tmp/alpha/pixcs2.png", pixcs2, IFF_PNG);
/* What will this look like over a black background?
* Do the blending explicitly and display. It should
* look identical to the blended result pixd1 before cleaning. */
pixd2 = pixBlendWithGrayMask(pixb, pixcs2, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd2, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd2, 0, 400, "alpha blended 2", rp->display);
/* Read the two images back, ignoring the transparency layer.
* The uncleaned image will come back identical to pixcs1.
* However, the cleaned image will be black wherever
* the alpha layer was fully transparent. It will
* look the same when viewed through the alpha layer,
* but have much better compression. */
pix1 = pixRead("/tmp/alpha/pixcs1.png"); /* just pixcs1 */
pix2 = pixRead("/tmp/alpha/pixcs2.png"); /* cleaned under transparent */
n1 = nbytesInFile("/tmp/alpha/pixcs1.png");
n2 = nbytesInFile("/tmp/alpha/pixcs2.png");
fprintf(stderr, " Original: %d bytes\n Cleaned: %d bytes\n", n1, n2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 9 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 10 */
pixDisplayWithTitle(pix1, 300, 400, "without alpha", rp->display);
pixDisplayWithTitle(pix2, 600, 400, "cleaned under transparent",
rp->display);
pixa = pixaCreate(0);
pixSaveTiled(pixg2, pixa, 1.0, 1, 20, 32);
pixSaveTiled(pixcs1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pix1, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pixd1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pixd2, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pix2, pixa, 1.0, 1, 20, 0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 200, 200, "composite", rp->display);
pixWrite("/tmp/alpha/alpha.png", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixg);
pixDestroy(&pixg2);
pixDestroy(&pixc);
pixDestroy(&pixcs1);
pixDestroy(&pixcs2);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------------------ (3) ----------------------------*/
color = 0xffffa000;
gamma = 1.0;
minval = 0;
maxval = 200;
box = boxCreate(0, 85, 600, 100);
pixa = pixaCreate(6);
pix1 = pixRead("blend-green1.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green2.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green3.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-orange.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-yellow.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-red.png");
pixaAddPix(pixa, pix1, L_INSERT);
n = pixaGetCount(pixa);
pixa2 = pixaCreate(n);
pixa3 = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 1);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 12, 14, ... 22 */
pixDisplayWithTitle(pix2, 150 * i, 0, NULL, rp->display);
pixaAddPix(pixa2, pix2, L_INSERT);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 2);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 13, 15, ... 23 */
pixDisplayWithTitle(pix2, 150 * i, 200, NULL, rp->display);
pixaAddPix(pixa3, pix2, L_INSERT);
pixDestroy(&pix1);
}
if (rp->display) {
pixaConvertToPdf(pixa2, 0, 0.75, L_FLATE_ENCODE, 0, "blend 1 test",
"/tmp/alpha/blending1.pdf");
pixaConvertToPdf(pixa3, 0, 0.75, L_FLATE_ENCODE, 0, "blend 2 test",
"/tmp/alpha/blending2.pdf");
}
pixaDestroy(&pixa);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
boxDestroy(&box);
/* ------------------------ (4) ----------------------------*/
/* Use one image as the alpha component for a second image */
pix1 = pixRead("test24.jpg");
pix2 = pixRead("marge.jpg");
pix3 = pixScale(pix2, 1.9, 2.2);
pix4 = pixConvertTo8(pix3, 0);
pixSetRGBComponent(pix1, pix4, L_ALPHA_CHANNEL);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 24 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
/* Set the alpha value in a colormap to bval */
pix5 = pixOctreeColorQuant(pix1, 128, 0);
cmap = pixGetColormap(pix5);
pixcmapToArrays(cmap, &rmap, &gmap, &bmap, NULL);
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
cta = (RGBA_QUAD *)cmap->array;
cta[i].alpha = bval;
}
/* Test binary serialization/deserialization of colormap with alpha */
pixcmapSerializeToMemory(cmap, 4, &ncolors, &data);
cmap2 = pixcmapDeserializeFromMemory(data, 4, ncolors);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 25 */
pixcmapDestroy(&cmap2);
lept_free(data);
/* Test ascii serialization/deserialization of colormap with alpha */
fp = fopenWriteStream("/tmp/alpha/cmap.4", "w");
pixcmapWriteStream(fp, cmap);
fclose(fp);
fp = fopenReadStream("/tmp/alpha/cmap.4");
cmap2 = pixcmapReadStream(fp);
fclose(fp);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 26 */
pixcmapDestroy(&cmap2);
/* Test r/w for cmapped pix with non-opaque alpha */
pixDisplayWithTitle(pix5, 900, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 27 */
pixWrite("/tmp/alpha/fourcomp.png", pix5, IFF_PNG);
pix6 = pixRead("/tmp/alpha/fourcomp.png");
regTestComparePix(rp, pix5, pix6); /* 28 */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
lept_free(rmap);
lept_free(gmap);
lept_free(bmap);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
l_int32 i, n;
l_float32 a, b, c;
L_DEWARP *dew, *dew2;
DPIX *dpix1, *dpix2, *dpix3;
FPIX *fpix1, *fpix2, *fpix3;
NUMA *nax, *nafit;
PIX *pixs, *pixn, *pixg, *pixb, *pixt1, *pixt2;
PIX *pixs2, *pixn2, *pixg2, *pixb2;
PTA *pta, *ptad;
PTAA *ptaa1, *ptaa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("1555-7.jpg");
/* Normalize for varying background and binarize */
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
pixDestroy(&pixn);
pixDestroy(&pixg);
regTestWritePixAndCheck(rp, pixb, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixb, 0, 0, "binarized input", rp->display);
/* Get the textline centers */
ptaa1 = pixGetTextlineCenters(pixb, 0);
pixt1 = pixCreateTemplate(pixs);
pixt2 = pixDisplayPtaa(pixt1, ptaa1);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixt2, 0, 500, "textline centers", rp->display);
pixDestroy(&pixt1);
/* Remove short lines */
ptaa2 = ptaaRemoveShortLines(pixb, ptaa1, 0.8, 0);
/* Fit to quadratic */
n = ptaaGetCount(ptaa2);
for (i = 0; i < n; i++) {
pta = ptaaGetPta(ptaa2, i, L_CLONE);
ptaGetArrays(pta, &nax, NULL);
ptaGetQuadraticLSF(pta, &a, &b, &c, &nafit);
ptad = ptaCreateFromNuma(nax, nafit);
pixDisplayPta(pixt2, pixt2, ptad);
ptaDestroy(&pta);
ptaDestroy(&ptad);
numaDestroy(&nax);
numaDestroy(&nafit);
}
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixt2, 300, 500, "fitted lines superimposed",
rp->display);
ptaaDestroy(&ptaa1);
ptaaDestroy(&ptaa2);
pixDestroy(&pixt2);
/* Run with only vertical disparity correction */
if ((dew = dewarpCreate(pixb, 7, 30, 15, 0)) == NULL)
return ERROR_INT("\n\n\n FAILURE !!! \n\n\n", rp->testname, 1);
dewarpBuildModel(dew, 0);
dewarpApplyDisparity(dew, pixb, 0);
regTestWritePixAndCheck(rp, dew->pixd, IFF_PNG); /* 3 */
pixDisplayWithTitle(dew->pixd, 400, 0, "fixed for vert disparity",
rp->display);
dewarpDestroy(&dew);
/* Run with both vertical and horizontal disparity correction */
if ((dew = dewarpCreate(pixb, 7, 30, 15, 1)) == NULL)
return ERROR_INT("\n\n\n FAILURE !!! \n\n\n", rp->testname, 1);
dewarpBuildModel(dew, 0);
dewarpApplyDisparity(dew, pixb, 0);
regTestWritePixAndCheck(rp, dew->pixd, IFF_PNG); /* 4 */
pixDisplayWithTitle(dew->pixd, 800, 0, "fixed for both disparities",
rp->display);
/* Read another image, normalize background and binarize */
pixs2 = pixRead("1555-3.jpg");
pixn2 = pixBackgroundNormSimple(pixs2, NULL, NULL);
pixg2 = pixConvertRGBToGray(pixn2, 0.5, 0.3, 0.2);
pixb2 = pixThresholdToBinary(pixg2, 130);
pixDestroy(&pixn2);
pixDestroy(&pixg2);
regTestWritePixAndCheck(rp, pixb, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixb, 0, 400, "binarized input (2)", rp->display);
/* Minimize and re-apply previous disparity to this image */
dewarpMinimize(dew);
dewarpApplyDisparity(dew, pixb2, 0);
regTestWritePixAndCheck(rp, dew->pixd, IFF_PNG); /* 6 */
pixDisplayWithTitle(dew->pixd, 400, 400, "fixed (2) for both disparities",
rp->display);
/* Write and read back minimized dewarp struct */
dewarpWrite("/tmp/dewarp.7.dew", dew);
regTestCheckFile(rp, "/tmp/dewarp.7.dew"); /* 7 */
dew2 = dewarpRead("/tmp/dewarp.7.dew");
dewarpWrite("/tmp/dewarp.8.dew", dew2);
regTestCheckFile(rp, "/tmp/dewarp.8.dew"); /* 8 */
regTestCompareFiles(rp, 7, 8); /* 9 */
/* Apply dew2 to pixb2 */
dewarpApplyDisparity(dew2, pixb2, 0);
regTestWritePixAndCheck(rp, dew2->pixd, IFF_PNG); /* 10 */
pixDisplayWithTitle(dew->pixd, 800, 400, "fixed (3) for both disparities",
rp->display);
/* Minimize, repopulate disparity arrays, and apply again */
dewarpMinimize(dew2);
dewarpApplyDisparity(dew2, pixb2, 0);
regTestWritePixAndCheck(rp, dew2->pixd, IFF_PNG); /* 11 */
regTestCompareFiles(rp, 10, 11); /* 12 */
pixDisplayWithTitle(dew->pixd, 900, 400, "fixed (4) for both disparities",
rp->display);
/* Test a few of the fpix functions */
fpix1 = fpixClone(dew->sampvdispar);
fpixWrite("/tmp/sampv.13.fpix", fpix1);
regTestCheckFile(rp, "/tmp/sampv.13.fpix"); /* 13 */
fpix2 = fpixRead("/tmp/sampv.13.fpix");
fpixWrite("/tmp/sampv.14.fpix", fpix2);
regTestCheckFile(rp, "/tmp/sampv.14.fpix"); /* 14 */
regTestCompareFiles(rp, 13, 14); /* 15 */
fpix3 = fpixScaleByInteger(fpix2, 30);
pixt1 = fpixRenderContours(fpix3, -2., 2.0, 0.2);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 16 */
pixDisplayWithTitle(pixt1, 0, 800, "v. disparity contours", rp->display);
fpixDestroy(&fpix1);
fpixDestroy(&fpix2);
fpixDestroy(&fpix3);
pixDestroy(&pixt1);
/* Test a few of the dpix functions */
dpix1 = fpixConvertToDPix(dew->sampvdispar);
dpixWrite("/tmp/sampv.17.dpix", dpix1);
regTestCheckFile(rp, "/tmp/sampv.17.dpix"); /* 17 */
dpix2 = dpixRead("/tmp/sampv.17.dpix");
dpixWrite("/tmp/sampv.18.dpix", dpix2);
regTestCheckFile(rp, "/tmp/sampv.18.dpix"); /* 18 */
regTestCompareFiles(rp, 17, 18); /* 19 */
dpix3 = dpixScaleByInteger(dpix2, 30);
fpix3 = dpixConvertToFPix(dpix3);
pixt1 = fpixRenderContours(fpix3, -2., 2.0, 0.2);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 20 */
pixDisplayWithTitle(pixt1, 400, 800, "v. disparity contours", rp->display);
regTestCompareFiles(rp, 16, 20); /* 21 */
dpixDestroy(&dpix1);
dpixDestroy(&dpix2);
dpixDestroy(&dpix3);
fpixDestroy(&fpix3);
pixDestroy(&pixt1);
dewarpDestroy(&dew);
dewarpDestroy(&dew2);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixs2);
pixDestroy(&pixb2);
regTestCleanup(rp);
return 0;
}
