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;
}
l_int32 main(int argc,
char **argv)
{
l_float32 dist, distr, distg, distb;
NUMA *na1, *na2;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Test earthmover distance: extreme DC */
fprintf(stderr, "Test earthmover distance\n");
na1 = numaMakeConstant(0, 201);
na2 = numaMakeConstant(0, 201);
numaSetValue(na1, 0, 100);
numaSetValue(na2, 200, 100);
numaEarthMoverDistance(na1, na2, &dist);
regTestCompareValues(rp, 200.0, dist, 0.0001); /* 0 */
numaDestroy(&na1);
numaDestroy(&na2);
/* Test connected component labelling */
fprintf(stderr, "Test c.c. labelling\n");
pix1 = pixRead("feyn-fract.tif");
pix2 = pixConnCompTransform(pix1, 8, 8);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
pixDisplayWithTitle(pix2, 0, 0, NULL, rp->display);
pix3 = pixConnCompTransform(pix1, 8, 16);
pix4 = pixConvert16To8(pix3, L_LS_BYTE);
regTestCompareSimilarPix(rp, pix2, pix4, 3, 0.001, 0); /* 2 */
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Test connected component area labelling */
fprintf(stderr, "Test c.c. area labelling\n");
pix2 = pixConnCompAreaTransform(pix1, 8);
pix3 = pixConvert16To8(pix2, L_CLIP_TO_255);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
pixDisplayWithTitle(pix3, 0, 350, NULL, rp->display);
pixMultConstantGray(pix2, 0.3);
pix4 = pixConvert16To8(pix2, L_LS_BYTE);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 0, 700, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Test color transform: 4-fold symmetry */
fprintf(stderr, "Test color transform: 4-fold symmetry\n");
pix1 = pixRead("form1.tif");
pix2 = pixRotateOrth(pix1, 1);
pix3 = pixRotateOrth(pix1, 2);
pix4 = pixRotateOrth(pix1, 3);
pix5 = pixLocToColorTransform(pix1);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 5 */
pix6 = pixLocToColorTransform(pix2);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 6 */
FindEMD(pix5, pix6, &distr, &distg, &distb);
regTestCompareValues(rp, 0.12, distr, 0.01); /* 7 */
regTestCompareValues(rp, 0.00, distg, 0.01); /* 8 */
regTestCompareValues(rp, 0.00, distb, 0.01); /* 9 */
fprintf(stderr, "90 deg rotation: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix6);
pix6 = pixLocToColorTransform(pix3);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 10 */
FindEMD(pix5, pix6, &distr, &distg, &distb);
regTestCompareValues(rp, 0.12, distr, 0.01); /* 11 */
regTestCompareValues(rp, 0.09, distg, 0.01); /* 12 */
regTestCompareValues(rp, 0.00, distb, 0.01); /* 13 */
fprintf(stderr, "180 deg rotation: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix6);
pix6 = pixLocToColorTransform(pix4);
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 14 */
FindEMD(pix5, pix6, &distr, &distg, &distb);
regTestCompareValues(rp, 0.00, distr, 0.01); /* 15 */
regTestCompareValues(rp, 0.09, distg, 0.01); /* 16 */
regTestCompareValues(rp, 0.00, distb, 0.01); /* 17 */
fprintf(stderr, "270 deg rotation: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
/* Test color transform: same form with translation */
fprintf(stderr, "Test color transform with translation\n");
pix1 = pixRead("form1.tif");
pix2 = pixLocToColorTransform(pix1);
pixDisplayWithTitle(pix2, 0, 0, NULL, rp->display);
pixTranslate(pix1, pix1, 10, 10, L_BRING_IN_WHITE);
pix3 = pixLocToColorTransform(pix1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 18 */
pixDisplayWithTitle(pix3, 470, 0, NULL, rp->display);
FindEMD(pix2, pix3, &distr, &distg, &distb);
regTestCompareValues(rp, 1.76, distr, 0.01); /* 19 */
regTestCompareValues(rp, 2.65, distg, 0.01); /* 20 */
regTestCompareValues(rp, 2.03, distb, 0.01); /* 21 */
fprintf(stderr, "Translation dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Test color transform: same form with small rotation */
fprintf(stderr, "Test color transform with small rotation\n");
pix1 = pixRead("form1.tif");
pix2 = pixLocToColorTransform(pix1);
pixRotateShearCenterIP(pix1, 0.1, L_BRING_IN_WHITE);
pix3 = pixLocToColorTransform(pix1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 22 */
pixDisplayWithTitle(pix3, 880, 0, NULL, rp->display);
FindEMD(pix2, pix3, &distr, &distg, &distb);
regTestCompareValues(rp, 1.50, distr, 0.01); /* 23 */
regTestCompareValues(rp, 1.71, distg, 0.01); /* 24 */
regTestCompareValues(rp, 1.42, distb, 0.01); /* 25 */
fprintf(stderr, "Rotation dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Test color transform: 2 different forms */
fprintf(stderr, "Test color transform (2 forms)\n");
pix1 = pixRead("form1.tif");
pix2 = pixLocToColorTransform(pix1);
pixDisplayWithTitle(pix2, 0, 600, NULL, rp->display);
pix3 = pixRead("form2.tif");
pix4 = pixLocToColorTransform(pix3);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 25 */
pixDisplayWithTitle(pix4, 470, 600, NULL, rp->display);
FindEMD(pix2, pix4, &distr, &distg, &distb);
regTestCompareValues(rp, 6.10, distr, 0.02); /* 27 */
regTestCompareValues(rp, 11.13, distg, 0.01); /* 28 */
regTestCompareValues(rp, 10.53, distb, 0.01); /* 29 */
fprintf(stderr, "Different forms: dist (r,g,b) = (%5.2f, %5.2f, %5.2f)\n",
distr, distg, distb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
#if HAVE_FMEMOPEN
char psname[256];
#endif /* HAVE_FMEMOPEN */
char *tempname;
l_uint8 *data;
l_int32 i, d, n, success, failure, same;
l_int32 w, h, bps, spp;
size_t size, nbytes;
PIX *pix1, *pix2, *pix4, *pix8, *pix16, *pix32;
PIX *pix, *pixt, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
#if !HAVE_LIBJPEG
fprintf(stderr, "Omitting libjpeg tests in ioformats_reg\n");
#endif /* !HAVE_LIBJPEG */
#if !HAVE_LIBTIFF
fprintf(stderr, "Omitting libtiff tests in ioformats_reg\n");
#endif /* !HAVE_LIBTIFF */
#if !HAVE_LIBPNG || !HAVE_LIBZ
fprintf(stderr, "Omitting libpng tests in ioformats_reg\n");
#endif /* !HAVE_LIBPNG || !HAVE_LIBZ */
if (regTestSetup(argc, argv, &rp))
return 1;
/* --------- Part 1: Test all lossless formats for r/w to file ---------*/
failure = FALSE;
success = TRUE;
fprintf(stderr, "Test bmp 1 bpp file:\n");
if (ioFormatTest(BMP_FILE)) success = FALSE;
#if HAVE_LIBTIFF
fprintf(stderr, "\nTest other 1 bpp file:\n");
if (ioFormatTest(FILE_1BPP)) success = FALSE;
#endif /* HAVE_LIBTIFF */
#if HAVE_LIBPNG
fprintf(stderr, "\nTest 2 bpp file:\n");
if (ioFormatTest(FILE_2BPP)) success = FALSE;
fprintf(stderr, "\nTest 2 bpp file with cmap:\n");
if (ioFormatTest(FILE_2BPP_C)) success = FALSE;
fprintf(stderr, "\nTest 4 bpp file:\n");
if (ioFormatTest(FILE_4BPP)) success = FALSE;
fprintf(stderr, "\nTest 4 bpp file with cmap:\n");
if (ioFormatTest(FILE_4BPP_C)) success = FALSE;
fprintf(stderr, "\nTest 8 bpp grayscale file with cmap:\n");
if (ioFormatTest(FILE_8BPP_1)) success = FALSE;
fprintf(stderr, "\nTest 8 bpp color file with cmap:\n");
if (ioFormatTest(FILE_8BPP_2)) success = FALSE;
#endif /* HAVE_LIBPNG */
#if HAVE_LIBJPEG
fprintf(stderr, "\nTest 8 bpp file without cmap:\n");
if (ioFormatTest(FILE_8BPP_3)) success = FALSE;
#endif /* HAVE_LIBJPEG */
#if HAVE_LIBTIFF
fprintf(stderr, "\nTest 16 bpp file:\n");
if (ioFormatTest(FILE_16BPP)) success = FALSE;
#endif /* HAVE_LIBTIFF */
#if HAVE_LIBJPEG
fprintf(stderr, "\nTest 32 bpp file:\n");
if (ioFormatTest(FILE_32BPP)) success = FALSE;
#endif /* HAVE_LIBJPEG */
if (success)
fprintf(stderr,
"\n ********** Success on all i/o format tests *********\n");
else
fprintf(stderr,
"\n ******* Failure on at least one i/o format test ******\n");
if (!success) failure = TRUE;
/* ------------------ Part 2: Test tiff r/w to file ------------------- */
#if !HAVE_LIBTIFF
goto part6;
#endif /* !HAVE_LIBTIFF */
fprintf(stderr, "\nTest tiff r/w and format extraction\n");
pixa = pixaCreate(6);
pix1 = pixRead(BMP_FILE);
pix2 = pixConvert1To2(NULL, pix1, 3, 0);
pix4 = pixConvert1To4(NULL, pix1, 15, 0);
pix16 = pixRead(FILE_16BPP);
fprintf(stderr, "Input format: %d\n", pixGetInputFormat(pix16));
pix8 = pixConvert16To8(pix16, 1);
pix32 = pixRead(FILE_32BPP);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixaAddPix(pixa, pix4, L_INSERT);
pixaAddPix(pixa, pix8, L_INSERT);
pixaAddPix(pixa, pix16, L_INSERT);
pixaAddPix(pixa, pix32, L_INSERT);
n = pixaGetCount(pixa);
success = TRUE;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
d = pixGetDepth(pix);
fprintf(stderr, "%d bpp\n", d);
if (i == 0) { /* 1 bpp */
pixWrite("/tmp/junkg3.tif", pix, IFF_TIFF_G3);
pixWrite("/tmp/junkg4.tif", pix, IFF_TIFF_G4);
pixWrite("/tmp/junkrle.tif", pix, IFF_TIFF_RLE);
pixWrite("/tmp/junkpb.tif", pix, IFF_TIFF_PACKBITS);
if (testcomp("/tmp/junkg3.tif", pix, IFF_TIFF_G3)) success = FALSE;
if (testcomp("/tmp/junkg4.tif", pix, IFF_TIFF_G4)) success = FALSE;
if (testcomp("/tmp/junkrle.tif", pix, IFF_TIFF_RLE))
success = FALSE;
if (testcomp("/tmp/junkpb.tif", pix, IFF_TIFF_PACKBITS))
success = FALSE;
}
pixWrite("/tmp/junklzw.tif", pix, IFF_TIFF_LZW);
pixWrite("/tmp/junkzip.tif", pix, IFF_TIFF_ZIP);
pixWrite("/tmp/junknon.tif", pix, IFF_TIFF);
if (testcomp("/tmp/junklzw.tif", pix, IFF_TIFF_LZW)) success = FALSE;
if (testcomp("/tmp/junkzip.tif", pix, IFF_TIFF_ZIP)) success = FALSE;
if (testcomp("/tmp/junknon.tif", pix, IFF_TIFF)) success = FALSE;
pixDestroy(&pix);
}
if (success)
fprintf(stderr,
"\n ********** Success on tiff r/w to file *********\n\n");
else
fprintf(stderr,
"\n ******* Failure on at least one tiff r/w to file ******\n\n");
if (!success) failure = TRUE;
/* ------------------ Part 3: Test tiff r/w to memory ----------------- */
success = TRUE;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
d = pixGetDepth(pix);
fprintf(stderr, "%d bpp\n", d);
if (i == 0) { /* 1 bpp */
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_G3);
nbytes = nbytesInFile("/tmp/junkg3.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_G3)) success = FALSE;
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_G4);
nbytes = nbytesInFile("/tmp/junkg4.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_G4)) success = FALSE;
readHeaderMemTiff(data, size, 0, &w, &h, &bps, &spp,
NULL, NULL, NULL);
fprintf(stderr, "(w,h,bps,spp) = (%d,%d,%d,%d)\n", w, h, bps, spp);
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_RLE);
nbytes = nbytesInFile("/tmp/junkrle.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_RLE)) success = FALSE;
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_PACKBITS);
nbytes = nbytesInFile("/tmp/junkpb.tif");
fprintf(stderr, "nbytes = %ld, size = %ld\n", nbytes, size);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_PACKBITS)) success = FALSE;
lept_free(data);
}
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_LZW);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_LZW)) success = FALSE;
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF_ZIP);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF_ZIP)) success = FALSE;
readHeaderMemTiff(data, size, 0, &w, &h, &bps, &spp, NULL, NULL, NULL);
fprintf(stderr, "(w,h,bps,spp) = (%d,%d,%d,%d)\n", w, h, bps, spp);
lept_free(data);
pixWriteMemTiff(&data, &size, pix, IFF_TIFF);
pixt = pixReadMemTiff(data, size, 0);
if (testcomp_mem(pix, &pixt, i, IFF_TIFF)) success = FALSE;
lept_free(data);
pixDestroy(&pix);
}
if (success)
fprintf(stderr,
"\n ********** Success on tiff r/w to memory *********\n\n");
else
fprintf(stderr,
"\n ******* Failure on at least one tiff r/w to memory ******\n\n");
if (!success) failure = TRUE;
/* ---------------- Part 4: Test non-tiff r/w to memory ---------------- */
#if HAVE_FMEMOPEN
pixDisplayWrite(NULL, -1);
success = TRUE;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
d = pixGetDepth(pix);
sprintf(psname, "/tmp/junkps.%d", d);
fprintf(stderr, "%d bpp\n", d);
if (d != 16) {
if (test_writemem(pix, IFF_PNG, NULL)) success = FALSE;
if (test_writemem(pix, IFF_BMP, NULL)) success = FALSE;
}
if (test_writemem(pix, IFF_PNM, NULL)) success = FALSE;
if (test_writemem(pix, IFF_PS, psname)) success = FALSE;
if (d == 8 || d == 32)
if (test_writemem(pix, IFF_JFIF_JPEG, NULL)) success = FALSE;
pixDestroy(&pix);
}
if (success)
fprintf(stderr,
"\n ********** Success on non-tiff r/w to memory *********\n\n");
else
fprintf(stderr,
"\n **** Failure on at least one non-tiff r/w to memory *****\n\n");
if (!success) failure = TRUE;
#else
fprintf(stderr,
"\n ***** Non-tiff r/w to memory not enabled *****\n\n");
#endif /* HAVE_FMEMOPEN */
pixaDestroy(&pixa);
/* ------------ Part 5: Test multipage tiff r/w to memory ------------ */
/* Make a multipage tiff file, and read it back into memory */
success = TRUE;
pix = pixRead("feyn.tif");
pixa = pixaSplitPix(pix, 3, 3, 0, 0);
for (i = 0; i < 9; i++) {
pixt = pixaGetPix(pixa, i, L_CLONE);
if (i == 0)
pixWriteTiff("/tmp/junktiffmpage.tif", pixt, IFF_TIFF_G4, "w");
else
pixWriteTiff("/tmp/junktiffmpage.tif", pixt, IFF_TIFF_G4, "a");
pixDestroy(&pixt);
}
data = l_binaryRead("/tmp/junktiffmpage.tif", &nbytes);
pixaDestroy(&pixa);
/* Read the individual pages from memory to a pix */
pixa = pixaCreate(9);
for (i = 0; i < 9; i++) {
pixt = pixReadMemTiff(data, nbytes, i);
pixaAddPix(pixa, pixt, L_INSERT);
}
lept_free(data);
/* Un-tile the pix in the pixa back to the original image */
pixt = pixaDisplayUnsplit(pixa, 3, 3, 0, 0);
pixaDestroy(&pixa);
/* Clip to foreground to remove any extra rows or columns */
pixClipToForeground(pix, &pix1, NULL);
pixClipToForeground(pixt, &pix2, NULL);
pixEqual(pix1, pix2, &same);
if (same)
fprintf(stderr,
"\n ******* Success on tiff multipage read from memory ******\n\n");
else
fprintf(stderr,
"\n ******* Failure on tiff multipage read from memory ******\n\n");
if (!same) failure = TRUE;
pixDestroy(&pix);
pixDestroy(&pixt);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------ Part 6: Test 24 bpp writing ------------ */
#if !HAVE_LIBTIFF
part6:
#endif /* !HAVE_LIBTIFF */
#if !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF
goto finish;
#endif /* !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF */
/* Generate a 24 bpp (not 32 bpp !!) rgb pix and write it out */
success = TRUE;
pix = pixRead("marge.jpg");
pixt = make_24_bpp_pix(pix);
pixWrite("/tmp/junk24.png", pixt, IFF_PNG);
pixWrite("/tmp/junk24.jpg", pixt, IFF_JFIF_JPEG);
pixWrite("/tmp/junk24.tif", pixt, IFF_TIFF);
pixd = pixRead("/tmp/junk24.png");
pixEqual(pix, pixd, &same);
if (!same) success = FALSE;
pixDestroy(&pixd);
pixd = pixRead("/tmp/junk24.jpg");
regTestCompareSimilarPix(rp, pix, pixd, 10, 0.0002, 0);
pixDestroy(&pixd);
pixd = pixRead("/tmp/junk24.tif");
pixEqual(pix, pixd, &same);
if (!same) success = FALSE;
pixDestroy(&pixd);
if (success)
fprintf(stderr,
"\n ******* Success on 24 bpp rgb writing *******\n\n");
else
fprintf(stderr,
"\n ******* Failure on 24 bpp rgb writing *******\n\n");
if (!success) failure = TRUE;
pixDestroy(&pix);
pixDestroy(&pixt);
/* -------------- Part 7: Read header information -------------- */
success = TRUE;
if (get_header_data(FILE_1BPP, IFF_TIFF_G4)) success = FALSE;
if (get_header_data(FILE_2BPP, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_2BPP_C, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_4BPP, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_4BPP_C, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_8BPP_1, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_8BPP_2, IFF_PNG)) success = FALSE;
if (get_header_data(FILE_8BPP_3, IFF_JFIF_JPEG)) success = FALSE;
if (get_header_data(FILE_16BPP, IFF_TIFF_ZIP)) success = FALSE;
if (get_header_data(FILE_32BPP, IFF_JFIF_JPEG)) success = FALSE;
#if HAVE_FMEMOPEN
pix = pixRead(FILE_8BPP_1);
tempname = genTempFilename((const char *)"/tmp", (const char *)".pnm",
1, 1);
pixWrite(tempname, pix, IFF_PNM);
if (get_header_data(tempname, IFF_PNM)) success = FALSE;
pixDestroy(&pix);
lept_free(tempname);
#endif /* HAVE_FMEMOPEN */
pix = pixRead(FILE_1BPP);
tempname = genTempFilename((const char *)"/tmp", (const char *)".tif",
1, 1);
pixWrite(tempname, pix, IFF_TIFF_G3);
if (get_header_data(tempname, IFF_TIFF_G3)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_G4);
if (get_header_data(tempname, IFF_TIFF_G4)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_PACKBITS);
if (get_header_data(tempname, IFF_TIFF_PACKBITS)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_RLE);
if (get_header_data(tempname, IFF_TIFF_RLE)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_LZW);
if (get_header_data(tempname, IFF_TIFF_LZW)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF_ZIP);
if (get_header_data(tempname, IFF_TIFF_ZIP)) success = FALSE;
pixWrite(tempname, pix, IFF_TIFF);
if (get_header_data(tempname, IFF_TIFF)) success = FALSE;
pixDestroy(&pix);
lept_free(tempname);
if (success)
fprintf(stderr,
"\n ******* Success on reading headers *******\n\n");
else
fprintf(stderr,
"\n ******* Failure on reading headers *******\n\n");
if (!success) failure = TRUE;
#if !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF
finish:
#endif /* !HAVE_LIBPNG || !HAVE_LIBJPEG || !HAVE_LIBTIFF */
if (!failure)
fprintf(stderr,
" ******* Success on all tests *******\n\n");
else
fprintf(stderr,
" ******* Failure on at least one test *******\n\n");
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_float32 sum, sumx, sumy, diff;
L_DEWARP *dew;
L_DEWARPA *dewa;
FPIX *fpixs, *fpixs2, *fpixs3, *fpixs4, *fpixg, *fpixd;
FPIX *fpix1, *fpix2, *fpixt1, *fpixt2;
DPIX *dpix, *dpix2;
L_KERNEL *kel, *kelx, *kely;
PIX *pixs, *pixs2, *pixs3, *pixt, *pixd, *pixg, *pixb, *pixn;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXA *pixa;
PTA *ptas, *ptad;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Gaussian kernel */
kel = makeGaussianKernel(5, 5, 3.0, 4.0);
kernelGetSum(kel, &sum);
if (rp->display) fprintf(stderr, "Sum for 2d gaussian kernel = %f\n", sum);
pixt = kernelDisplayInPix(kel, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 0 */
pixSaveTiled(pixt, pixa, 1, 1, 20, 8);
pixDestroy(&pixt);
/* Separable gaussian kernel */
makeGaussianKernelSep(5, 5, 3.0, 4.0, &kelx, &kely);
kernelGetSum(kelx, &sumx);
if (rp->display) fprintf(stderr, "Sum for x gaussian kernel = %f\n", sumx);
kernelGetSum(kely, &sumy);
if (rp->display) fprintf(stderr, "Sum for y gaussian kernel = %f\n", sumy);
if (rp->display) fprintf(stderr, "Sum for x * y gaussian kernel = %f\n",
sumx * sumy);
pixt = kernelDisplayInPix(kelx, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 1 */
pixSaveTiled(pixt, pixa, 1, 0, 20, 8);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixSaveTiled(pixt, pixa, 1, 0, 20, 8);
pixDestroy(&pixt);
/* Use pixRasterop() to generate source image */
pixs = pixRead("test8.jpg");
pixs2 = pixRead("karen8.jpg");
pixRasterop(pixs, 150, 125, 150, 100, PIX_SRC, pixs2, 75, 100);
regTestWritePixAndCheck(rp, pixs, IFF_JFIF_JPEG); /* 3 */
/* Convolution directly with pix */
pixt1 = pixConvolve(pixs, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 4 */
pixSaveTiled(pixt1, pixa, 1, 1, 20, 8);
pixt2 = pixConvolveSep(pixs, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 5 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 8);
/* Convolution indirectly with fpix, using fpixRasterop()
* to generate the source image. */
fpixs = pixConvertToFPix(pixs, 3);
fpixs2 = pixConvertToFPix(pixs2, 3);
fpixRasterop(fpixs, 150, 125, 150, 100, fpixs2, 75, 100);
fpixt1 = fpixConvolve(fpixs, kel, 1);
pixt3 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 6 */
pixSaveTiled(pixt3, pixa, 1, 1, 20, 8);
fpixt2 = fpixConvolveSep(fpixs, kelx, kely, 1);
pixt4 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 7 */
pixSaveTiled(pixt4, pixa, 1, 0, 20, 8);
pixDestroy(&pixs2);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
/* Comparison of results */
pixCompareGray(pixt1, pixt2, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and pixConvolveSep: %f\n",
diff);
pixCompareGray(pixt3, pixt4, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of fpixConvolve and fpixConvolveSep: %f\n",
diff);
pixCompareGray(pixt1, pixt3, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and fpixConvolve: %f\n", diff);
pixCompareGray(pixt2, pixt4, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolveSep and fpixConvolveSep: %f\n",
diff);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Test arithmetic operations; add in a fraction rotated by 180 */
pixs3 = pixRotate180(NULL, pixs);
regTestWritePixAndCheck(rp, pixs3, IFF_JFIF_JPEG); /* 8 */
pixSaveTiled(pixs3, pixa, 1, 1, 20, 8);
fpixs3 = pixConvertToFPix(pixs3, 3);
fpixd = fpixLinearCombination(NULL, fpixs, fpixs3, 20.0, 5.0);
fpixAddMultConstant(fpixd, 0.0, 23.174); /* multiply up in magnitude */
pixd = fpixDisplayMaxDynamicRange(fpixd); /* bring back to 8 bpp */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixSaveTiled(pixd, pixa, 1, 0, 20, 8);
pixDestroy(&pixs3);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixd);
pixDestroy(&pixd);
pixDestroy(&pixs);
fpixDestroy(&fpixs);
/* Save the comparison graph; gnuplot should have made it by now! */
#ifndef _WIN32
sleep(2);
#else
Sleep(2000);
#endif /* _WIN32 */
pixt5 = pixRead("/tmp/grayroot.png");
regTestWritePixAndCheck(rp, pixt5, IFF_PNG); /* 10 */
pixSaveTiled(pixt5, pixa, 1, 1, 20, 8);
pixDestroy(&pixt5);
/* Display results */
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test some more convolutions, with sampled output. First on pix */
pixa = pixaCreate(0);
pixs = pixRead("1555-7.jpg");
pixg = pixConvertTo8(pixs, 0);
l_setConvolveSampling(5, 5);
pixt1 = pixConvolve(pixg, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 12 */
pixSaveTiled(pixt1, pixa, 1, 1, 20, 32);
pixt2 = pixConvolveSep(pixg, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 13 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
pixt3 = pixConvolveRGB(pixs, kel);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 14 */
pixSaveTiled(pixt3, pixa, 1, 0, 20, 32);
pixt4 = pixConvolveRGBSep(pixs, kelx, kely);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 15 */
pixSaveTiled(pixt4, pixa, 1, 0, 20, 32);
/* Then on fpix */
fpixg = pixConvertToFPix(pixg, 1);
fpixt1 = fpixConvolve(fpixg, kel, 1);
pixt5 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt5, IFF_JFIF_JPEG); /* 16 */
pixSaveTiled(pixt5, pixa, 1, 1, 20, 32);
fpixt2 = fpixConvolveSep(fpixg, kelx, kely, 1);
pixt6 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt6, IFF_JFIF_JPEG); /* 17 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
regTestCompareSimilarPix(rp, pixt1, pixt5, 2, 0.00, 0); /* 18 */
regTestCompareSimilarPix(rp, pixt2, pixt6, 2, 0.00, 0); /* 19 */
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixg);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 20 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test extension (continued and slope).
* First, build a smooth vertical disparity array;
* then extend and show the contours. */
pixs = pixRead("cat-35.jpg");
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
dewa = dewarpaCreate(1, 30, 1, 15, 0);
dew = dewarpCreate(pixb, 35);
dewarpaInsertDewarp(dewa, dew);
dewarpBuildModel(dew, NULL);
dewarpPopulateFullRes(dew, NULL);
fpixs = dew->fullvdispar;
fpixs2 = fpixAddContinuedBorder(fpixs, 200, 200, 100, 300);
fpixs3 = fpixAddSlopeBorder(fpixs, 200, 200, 100, 300);
dpix = fpixConvertToDPix(fpixs3);
fpixs4 = dpixConvertToFPix(dpix);
pixt1 = fpixRenderContours(fpixs, 2.0, 0.2);
pixt2 = fpixRenderContours(fpixs2, 2.0, 0.2);
pixt3 = fpixRenderContours(fpixs3, 2.0, 0.2);
pixt4 = fpixRenderContours(fpixs4, 2.0, 0.2);
pixt5 = pixRead("karen8.jpg");
dpix2 = pixConvertToDPix(pixt5, 1);
pixt6 = dpixConvertToPix(dpix2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 21 */
pixDisplayWithTitle(pixt1, 0, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 22 */
pixDisplayWithTitle(pixt2, 470, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 23 */
pixDisplayWithTitle(pixt3, 1035, 100, NULL, rp->display);
regTestComparePix(rp, pixt3, pixt4); /* 24 */
regTestComparePix(rp, pixt5, pixt6); /* 25 */
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixs4);
dpixDestroy(&dpix);
dpixDestroy(&dpix2);
/* Test affine and projective transforms on fpix */
fpixWrite("/tmp/fpix1.fp", dew->fullvdispar);
fpix1 = fpixRead("/tmp/fpix1.fp");
pixt1 = fpixAutoRenderContours(fpix1, 40);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 26 */
pixDisplayWithTitle(pixt1, 0, 500, NULL, rp->display);
pixDestroy(&pixt1);
MakePtasAffine(1, &ptas, &ptad);
fpix2 = fpixAffinePta(fpix1, ptad, ptas, 200, 0.0);
pixt2 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 27 */
pixDisplayWithTitle(pixt2, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pixt2);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
MakePtas(1, &ptas, &ptad);
fpix2 = fpixProjectivePta(fpix1, ptad, ptas, 200, 0.0);
pixt3 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 28 */
pixDisplayWithTitle(pixt3, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pixt3);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
fpixDestroy(&fpix1);
dewarpaDestroy(&dewa);
kernelDestroy(&kel);
kernelDestroy(&kelx);
kernelDestroy(&kely);
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_float32 sum, sumx, sumy, diff;
FPIX *fpixs, *fpixs2, *fpixs3, *fpixt1, *fpixt2, *fpixg, *fpixd;
L_KERNEL *kel, *kelx, *kely;
PIX *pixs, *pixs2, *pixs3, *pixt, *pixd, *pixg;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Gaussian kernel */
kel = makeGaussianKernel(5, 5, 3.0, 4.0);
kernelGetSum(kel, &sum);
if (rp->display) fprintf(stderr, "Sum for 2d gaussian kernel = %f\n", sum);
pixt = kernelDisplayInPix(kel, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 0 */
pixSaveTiled(pixt, pixa, 1, 1, 20, 8);
pixDestroy(&pixt);
/* Separable gaussian kernel */
makeGaussianKernelSep(5, 5, 3.0, 4.0, &kelx, &kely);
kernelGetSum(kelx, &sumx);
if (rp->display) fprintf(stderr, "Sum for x gaussian kernel = %f\n", sumx);
kernelGetSum(kely, &sumy);
if (rp->display) fprintf(stderr, "Sum for y gaussian kernel = %f\n", sumy);
if (rp->display) fprintf(stderr, "Sum for x * y gaussian kernel = %f\n",
sumx * sumy);
pixt = kernelDisplayInPix(kelx, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 1 */
pixSaveTiled(pixt, pixa, 1, 0, 20, 8);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixSaveTiled(pixt, pixa, 1, 0, 20, 8);
pixDestroy(&pixt);
/* Use pixRasterop() to generate source image */
pixs = pixRead("test8.jpg");
pixs2 = pixRead("karen8.jpg");
pixRasterop(pixs, 150, 125, 150, 100, PIX_SRC, pixs2, 75, 100);
regTestWritePixAndCheck(rp, pixs, IFF_JFIF_JPEG); /* 3 */
/* Convolution directly with pix */
pixt1 = pixConvolve(pixs, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 4 */
pixSaveTiled(pixt1, pixa, 1, 1, 20, 8);
pixt2 = pixConvolveSep(pixs, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 5 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 8);
/* Convolution indirectly with fpix, using fpixRasterop()
* to generate the source image. */
fpixs = pixConvertToFPix(pixs, 3);
fpixs2 = pixConvertToFPix(pixs2, 3);
fpixRasterop(fpixs, 150, 125, 150, 100, fpixs2, 75, 100);
fpixt1 = fpixConvolve(fpixs, kel, 1);
pixt3 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 6 */
pixSaveTiled(pixt3, pixa, 1, 1, 20, 8);
fpixt2 = fpixConvolveSep(fpixs, kelx, kely, 1);
pixt4 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 7 */
pixSaveTiled(pixt4, pixa, 1, 0, 20, 8);
pixDestroy(&pixs2);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
/* Comparison of results */
pixCompareGray(pixt1, pixt2, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and pixConvolveSep: %f\n",
diff);
pixCompareGray(pixt3, pixt4, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of fpixConvolve and fpixConvolveSep: %f\n",
diff);
pixCompareGray(pixt1, pixt3, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and fpixConvolve: %f\n", diff);
pixCompareGray(pixt2, pixt4, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolveSep and fpixConvolveSep: %f\n",
diff);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Test arithmetic operations; add in a fraction rotated by 180 */
pixs3 = pixRotate180(NULL, pixs);
regTestWritePixAndCheck(rp, pixs3, IFF_JFIF_JPEG); /* 8 */
pixSaveTiled(pixs3, pixa, 1, 1, 20, 8);
fpixs3 = pixConvertToFPix(pixs3, 3);
fpixd = fpixLinearCombination(NULL, fpixs, fpixs3, 20.0, 5.0);
fpixAddMultConstant(fpixd, 0.0, 23.174); /* multiply up in magnitude */
pixd = fpixDisplayMaxDynamicRange(fpixd); /* bring back to 8 bpp */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixSaveTiled(pixd, pixa, 1, 0, 20, 8);
pixDestroy(&pixs3);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixd);
pixDestroy(&pixd);
pixDestroy(&pixs);
fpixDestroy(&fpixs);
/* Save the comparison graph; gnuplot should have made it by now! */
#ifndef _WIN32
sleep(2);
#else
Sleep(2000);
#endif /* _WIN32 */
pixt5 = pixRead("/tmp/grayroot.png");
regTestWritePixAndCheck(rp, pixt5, IFF_PNG); /* 10 */
pixSaveTiled(pixt5, pixa, 1, 1, 20, 8);
pixDestroy(&pixt5);
/* Display results */
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test some more convolutions, with sampled output. First on pix */
pixa = pixaCreate(0);
pixs = pixRead("1555-7.jpg");
pixg = pixConvertTo8(pixs, 0);
l_setConvolveSampling(5, 5);
pixt1 = pixConvolve(pixg, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 12 */
pixSaveTiled(pixt1, pixa, 1, 1, 20, 32);
pixt2 = pixConvolveSep(pixg, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 13 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
pixt3 = pixConvolveRGB(pixs, kel);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 14 */
pixSaveTiled(pixt3, pixa, 1, 0, 20, 32);
pixt4 = pixConvolveRGBSep(pixs, kelx, kely);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 15 */
pixSaveTiled(pixt4, pixa, 1, 0, 20, 32);
/* Then on fpix */
fpixg = pixConvertToFPix(pixg, 1);
fpixt1 = fpixConvolve(fpixg, kel, 1);
pixt5 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt5, IFF_JFIF_JPEG); /* 16 */
pixSaveTiled(pixt5, pixa, 1, 1, 20, 32);
fpixt2 = fpixConvolveSep(fpixg, kelx, kely, 1);
pixt6 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt6, IFF_JFIF_JPEG); /* 17 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
regTestCompareSimilarPix(rp, pixt1, pixt5, 2, 0.00, 0); /* 18 */
regTestCompareSimilarPix(rp, pixt2, pixt6, 2, 0.00, 0); /* 19 */
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixg);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 20 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
regTestCleanup(rp);
pixDestroy(&pixs);
pixDestroy(&pixg);
kernelDestroy(&kel);
kernelDestroy(&kelx);
kernelDestroy(&kely);
return 0;
}
