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_int32 i, w, h, same;
char filename[][64] = {BINARY_IMAGE,
TWO_BPP_IMAGE_NO_CMAP, TWO_BPP_IMAGE_CMAP,
FOUR_BPP_IMAGE_NO_CMAP, FOUR_BPP_IMAGE_CMAP,
EIGHT_BPP_IMAGE_NO_CMAP, EIGHT_BPP_IMAGE_CMAP,
RGB_IMAGE};
BOX *box;
PIX *pix, *pixs, *pixt, *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixd;
static char mainName[] = "expand_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: expand_reg", mainName, 1));
pixDisplayWrite(NULL, -1);
for (i = 0; i < 8; i++) {
pixs = pixRead(filename[i]);
pixt = pixExpandReplicate(pixs, 2);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixExpandReplicate(pixs, 3);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
if (i == 4) {
pixt = pixScale(pixs, 3.0, 3.0);
pixWrite("/tmp/junkpixt.png", pixt, IFF_PNG);
pixDestroy(&pixt);
}
pixDestroy(&pixs);
}
pix = pixRead("test1.png");
pixGetDimensions(pix, &w, &h, NULL);
for (i = 1; i <= 15; i++) {
box = boxCreate(13 * i, 13 * i, w - 13 * i, h - 13 * i);
pixs = pixClipRectangle(pix, box, NULL);
pixt = pixExpandReplicate(pixs, 3);
pixDisplayWrite(pixt, 1);
boxDestroy(&box);
pixDestroy(&pixt);
pixDestroy(&pixs);
}
pixDestroy(&pix);
pixs = pixRead("speckle.png");
/* Test 2x expansion of 1 bpp */
pixt = pixExpandBinaryPower2(pixs, 2);
pixDisplayWrite(pixt, 1);
pixd = pixReduceRankBinary2(pixt, 4, NULL);
pixEqual(pixs, pixd, &same);
if (!same)
fprintf(stderr, "Error in 2x 1bpp expansion\n");
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Test 2x expansion of 2 bpp */
pixt1 = pixConvert1To2(NULL, pixs, 3, 0);
pixt2 = pixExpandReplicate(pixt1, 2);
pixDisplayWrite(pixt2, 1);
pixt3 = pixConvertTo8(pixt2, FALSE);
pixt4 = pixThresholdToBinary(pixt3, 250);
pixd = pixReduceRankBinary2(pixt4, 4, NULL);
pixEqual(pixs, pixd, &same);
if (!same)
fprintf(stderr, "Error in 2x 2bpp expansion\n");
pixt5 = pixExpandBinaryPower2(pixd, 2);
pixDisplayWrite(pixt5, 1);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixd);
/* Test 4x expansion of 4 bpp */
pixt1 = pixConvert1To4(NULL, pixs, 15, 0);
pixt2 = pixExpandReplicate(pixt1, 4);
pixDisplayWrite(pixt2, 2);
pixt3 = pixConvertTo8(pixt2, FALSE);
pixt4 = pixThresholdToBinary(pixt3, 250);
pixDisplayWrite(pixt4, 2);
pixd = pixReduceRankBinaryCascade(pixt4, 4, 4, 0, 0);
pixEqual(pixs, pixd, &same);
if (!same)
fprintf(stderr, "Error in 4x 4bpp expansion\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixd);
/* Test 8x expansion of 8 bpp */
pixt1 = pixConvertTo8(pixs, FALSE);
pixt2 = pixExpandReplicate(pixt1, 8);
pixDisplayWrite(pixt2, 4);
pixt3 = pixThresholdToBinary(pixt2, 250);
pixDisplayWrite(pixt3, 4);
pixd = pixReduceRankBinaryCascade(pixt3, 4, 4, 4, 0);
pixEqual(pixs, pixd, &same);
if (!same)
fprintf(stderr, "Error in 4x 4bpp expansion\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}