main(int argc, char **argv) { PIX *pixs, *pixg1, *pixg2; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; /* Use for input two different images */ pixs = pixRead("projectionstats.jpg"); pixg1 = pixConvertTo8(pixs, 0); pixDestroy(&pixs); pixs = pixRead("feyn.tif"); pixg2 = pixScaleToGray4(pixs); pixDestroy(&pixs); TestProjection(rp, pixg1); TestProjection(rp, pixg2); pixDestroy(&pixg1); pixDestroy(&pixg2); regTestCleanup(rp); return 0; }
/*! * pixDisplayWithTitle() * * Input: pix (1, 2, 4, 8, 16, 32 bpp) * x, y (location of display frame) * title (<optional> on frame; can be NULL); * dispflag (1 to write, else disabled) * Return: 0 if OK; 1 on error * * Notes: * (1) See notes for pixDisplay(). * (2) This displays the image if dispflag == 1. */ l_int32 pixDisplayWithTitle(PIX *pixs, l_int32 x, l_int32 y, const char *title, l_int32 dispflag) { char *tempname; char buffer[L_BUF_SIZE]; static l_int32 index = 0; /* caution: not .so or thread safe */ l_int32 w, h, d, spp, maxheight, opaque, threeviews, ignore; l_float32 ratw, rath, ratmin; PIX *pix0, *pix1, *pix2; PIXCMAP *cmap; #ifndef _WIN32 l_int32 wt, ht; #else char *pathname; char fullpath[_MAX_PATH]; #endif /* _WIN32 */ PROCNAME("pixDisplayWithTitle"); if (dispflag != 1) return 0; if (!pixs) return ERROR_INT("pixs not defined", procName, 1); if (var_DISPLAY_PROG != L_DISPLAY_WITH_XZGV && var_DISPLAY_PROG != L_DISPLAY_WITH_XLI && var_DISPLAY_PROG != L_DISPLAY_WITH_XV && var_DISPLAY_PROG != L_DISPLAY_WITH_IV && var_DISPLAY_PROG != L_DISPLAY_WITH_OPEN) { return ERROR_INT("no program chosen for display", procName, 1); } /* Display with three views if either spp = 4 or if colormapped * and the alpha component is not fully opaque */ opaque = TRUE; if ((cmap = pixGetColormap(pixs)) != NULL) pixcmapIsOpaque(cmap, &opaque); spp = pixGetSpp(pixs); threeviews = (spp == 4 || !opaque) ? TRUE : FALSE; /* If colormapped and not opaque, remove the colormap to RGBA */ if (!opaque) pix0 = pixRemoveColormap(pixs, REMOVE_CMAP_WITH_ALPHA); else pix0 = pixClone(pixs); /* Scale if necessary; this will also remove a colormap */ pixGetDimensions(pix0, &w, &h, &d); maxheight = (threeviews) ? MAX_DISPLAY_HEIGHT / 3 : MAX_DISPLAY_HEIGHT; if (w <= MAX_DISPLAY_WIDTH && h <= maxheight) { if (d == 16) /* take MSB */ pix1 = pixConvert16To8(pix0, 1); else pix1 = pixClone(pix0); } else { ratw = (l_float32)MAX_DISPLAY_WIDTH / (l_float32)w; rath = (l_float32)maxheight / (l_float32)h; ratmin = L_MIN(ratw, rath); if (ratmin < 0.125 && d == 1) pix1 = pixScaleToGray8(pix0); else if (ratmin < 0.25 && d == 1) pix1 = pixScaleToGray4(pix0); else if (ratmin < 0.33 && d == 1) pix1 = pixScaleToGray3(pix0); else if (ratmin < 0.5 && d == 1) pix1 = pixScaleToGray2(pix0); else pix1 = pixScale(pix0, ratmin, ratmin); } pixDestroy(&pix0); if (!pix1) return ERROR_INT("pix1 not made", procName, 1); /* Generate the three views if required */ if (threeviews) pix2 = pixDisplayLayersRGBA(pix1, 0xffffff00, 0); else pix2 = pixClone(pix1); if (index == 0) { lept_rmdir("disp"); lept_mkdir("disp"); } index++; if (pixGetDepth(pix2) < 8 || (w < MAX_SIZE_FOR_PNG && h < MAX_SIZE_FOR_PNG)) { snprintf(buffer, L_BUF_SIZE, "/tmp/disp/write.%03d.png", index); pixWrite(buffer, pix2, IFF_PNG); } else { snprintf(buffer, L_BUF_SIZE, "/tmp/disp/write.%03d.jpg", index); pixWrite(buffer, pix2, IFF_JFIF_JPEG); } tempname = stringNew(buffer); #ifndef _WIN32 /* Unix */ if (var_DISPLAY_PROG == L_DISPLAY_WITH_XZGV) { /* no way to display title */ pixGetDimensions(pix2, &wt, &ht, NULL); snprintf(buffer, L_BUF_SIZE, "xzgv --geometry %dx%d+%d+%d %s &", wt + 10, ht + 10, x, y, tempname); } else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XLI) { if (title) { snprintf(buffer, L_BUF_SIZE, "xli -dispgamma 1.0 -quiet -geometry +%d+%d -title \"%s\" %s &", x, y, title, tempname); } else { snprintf(buffer, L_BUF_SIZE, "xli -dispgamma 1.0 -quiet -geometry +%d+%d %s &", x, y, tempname); } } else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XV) { if (title) { snprintf(buffer, L_BUF_SIZE, "xv -quit -geometry +%d+%d -name \"%s\" %s &", x, y, title, tempname); } else { snprintf(buffer, L_BUF_SIZE, "xv -quit -geometry +%d+%d %s &", x, y, tempname); } } else if (var_DISPLAY_PROG == L_DISPLAY_WITH_OPEN) { snprintf(buffer, L_BUF_SIZE, "open %s &", tempname); } ignore = system(buffer); #else /* _WIN32 */ /* Windows: L_DISPLAY_WITH_IV */ pathname = genPathname(tempname, NULL); _fullpath(fullpath, pathname, sizeof(fullpath)); if (title) { snprintf(buffer, L_BUF_SIZE, "i_view32.exe \"%s\" /pos=(%d,%d) /title=\"%s\"", fullpath, x, y, title); } else { snprintf(buffer, L_BUF_SIZE, "i_view32.exe \"%s\" /pos=(%d,%d)", fullpath, x, y); } ignore = system(buffer); FREE(pathname); #endif /* _WIN32 */ pixDestroy(&pix1); pixDestroy(&pix2); FREE(tempname); return 0; }
int main(int argc, char **argv) { l_int32 i, j, sindex, wb, hb, ws, hs, delx, dely, x, y, y0; PIX *pixs, *pixb, *pix1, *pix2; PIXA *pixa; PIXCMAP *cmap; setLeptDebugOK(1); lept_mkdir("lept/blend"); pixa = pixaCreate(0); pixs = pixRead("rabi.png"); /* blendee */ pixb = pixRead("weasel4.11c.png"); /* blender */ /* Fade the blender */ pixcmapShiftIntensity(pixGetColormap(pixb), FADE_FRACTION); /* Downscale the input */ wb = pixGetWidth(pixb); hb = pixGetHeight(pixb); pix1 = pixScaleToGray4(pixs); /* Threshold to 5 levels, 4 bpp */ ws = pixGetWidth(pix1); hs = pixGetHeight(pix1); pix2 = pixThresholdTo4bpp(pix1, 5, 1); pixaAddPix(pixa, pix2, L_COPY); pixaAddPix(pixa, pixb, L_COPY); cmap = pixGetColormap(pix2); pixcmapWriteStream(stderr, cmap); /* Overwrite the white pixels (at sindex in pix2) */ pixcmapGetIndex(cmap, 255, 255, 255, &sindex); /* Blend the weasel 20 times */ delx = ws / NX; dely = hs / NY; for (i = 0; i < NY; i++) { y = 20 + i * dely; if (y >= hs + hb) continue; for (j = 0; j < NX; j++) { x = 30 + j * delx; y0 = y; if (j & 1) { y0 = y + dely / 2; if (y0 >= hs + hb) continue; } if (x >= ws + wb) continue; pixBlendCmap(pix2, pixb, x, y0, sindex); } } pixaAddPix(pixa, pix2, L_COPY); cmap = pixGetColormap(pix2); pixcmapWriteStream(stderr, cmap); fprintf(stderr, "Writing to: /tmp/lept/blend/blendcmap.pdf\n"); pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, "cmap-blendtest", "/tmp/lept/blend/blendcmap.pdf"); pixDestroy(&pixs); pixDestroy(&pixb); pixDestroy(&pix1); pixDestroy(&pix2); pixaDestroy(&pixa); return 0; }
/*! * pixDisplayWithTitle() * * Input: pix (1, 2, 4, 8, 16, 32 bpp) * x, y (location of display frame) * title (<optional> on frame; can be NULL); * dispflag (1 to write, else disabled) * Return: 0 if OK; 1 on error * * Notes: * (1) See notes for pixDisplay(). * (2) This displays the image if dispflag == 1. */ l_int32 pixDisplayWithTitle(PIX *pixs, l_int32 x, l_int32 y, const char *title, l_int32 dispflag) { char *tempname; char buffer[L_BUF_SIZE]; static l_int32 index = 0; /* caution: not .so or thread safe */ l_int32 w, h, d, ignore; l_float32 ratw, rath, ratmin; PIX *pixt; #ifndef _WIN32 l_int32 wt, ht; #else char *pathname; char fullpath[_MAX_PATH]; #endif /* _WIN32 */ PROCNAME("pixDisplayWithTitle"); if (dispflag != 1) return 0; if (!pixs) return ERROR_INT("pixs not defined", procName, 1); if (var_DISPLAY_PROG != L_DISPLAY_WITH_XV && var_DISPLAY_PROG != L_DISPLAY_WITH_XLI && var_DISPLAY_PROG != L_DISPLAY_WITH_XZGV && var_DISPLAY_PROG != L_DISPLAY_WITH_IV) return ERROR_INT("no program chosen for display", procName, 1); pixGetDimensions(pixs, &w, &h, &d); if (w <= MAX_DISPLAY_WIDTH && h <= MAX_DISPLAY_HEIGHT) { if (d == 16) /* take MSB */ pixt = pixConvert16To8(pixs, 1); else pixt = pixClone(pixs); } else { ratw = (l_float32)MAX_DISPLAY_WIDTH / (l_float32)w; rath = (l_float32)MAX_DISPLAY_HEIGHT / (l_float32)h; ratmin = L_MIN(ratw, rath); if (ratmin < 0.125 && d == 1) pixt = pixScaleToGray8(pixs); else if (ratmin < 0.25 && d == 1) pixt = pixScaleToGray4(pixs); else if (ratmin < 0.33 && d == 1) pixt = pixScaleToGray3(pixs); else if (ratmin < 0.5 && d == 1) pixt = pixScaleToGray2(pixs); else pixt = pixScale(pixs, ratmin, ratmin); if (!pixt) return ERROR_INT("pixt not made", procName, 1); } if (index == 0) { lept_rmdir("display"); lept_mkdir("display"); } index++; if (pixGetDepth(pixt) < 8 || (w < MAX_SIZE_FOR_PNG && h < MAX_SIZE_FOR_PNG)) { snprintf(buffer, L_BUF_SIZE, "/tmp/display/write.%03d.png", index); pixWrite(buffer, pixt, IFF_PNG); } else { snprintf(buffer, L_BUF_SIZE, "/tmp/display/write.%03d.jpg", index); pixWrite(buffer, pixt, IFF_JFIF_JPEG); } tempname = stringNew(buffer); #ifndef _WIN32 /* Unix */ if (var_DISPLAY_PROG == L_DISPLAY_WITH_XV) { if (title) snprintf(buffer, L_BUF_SIZE, "xv -quit -geometry +%d+%d -name \"%s\" %s &", x, y, title, tempname); else snprintf(buffer, L_BUF_SIZE, "xv -quit -geometry +%d+%d %s &", x, y, tempname); } else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XLI) { if (title) snprintf(buffer, L_BUF_SIZE, "xli -dispgamma 1.0 -quiet -geometry +%d+%d -title \"%s\" %s &", x, y, title, tempname); else snprintf(buffer, L_BUF_SIZE, "xli -dispgamma 1.0 -quiet -geometry +%d+%d %s &", x, y, tempname); } else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XZGV) { /* no way to display title */ pixGetDimensions(pixt, &wt, &ht, NULL); snprintf(buffer, L_BUF_SIZE, "xzgv --geometry %dx%d+%d+%d %s &", wt + 10, ht + 10, x, y, tempname); } ignore = system(buffer); #else /* _WIN32 */ /* Windows: L_DISPLAY_WITH_IV */ pathname = genPathname(tempname, NULL); _fullpath(fullpath, pathname, sizeof(fullpath)); if (title) snprintf(buffer, L_BUF_SIZE, "i_view32.exe \"%s\" /pos=(%d,%d) /title=\"%s\"", fullpath, x, y, title); else snprintf(buffer, L_BUF_SIZE, "i_view32.exe \"%s\" /pos=(%d,%d)", fullpath, x, y); ignore = system(buffer); FREE(pathname); #endif /* _WIN32 */ pixDestroy(&pixt); FREE(tempname); return 0; }
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) { const char *str; l_int32 equal, index, w, h; BOX *box; PIX *pixs, *pixd, *pixt, *pixd1, *pixd2, *pixd3; PIX *pixt0, *pixt1, *pixt2, *pixt3, *pixt4; PIXA *pixa; PIXCMAP *cmap; static char mainName[] = "grayquant_reg"; if ((pixs = pixRead("test8.jpg")) == NULL) exit(ERROR_INT("pixs not made", mainName, 1)); pixa = pixaCreate(0); pixSaveTiled(pixs, pixa, 1, 1, 20, 8); /* threshold to 1 bpp */ pixd = pixThresholdToBinary(pixs, THRESHOLD); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixWrite("/tmp/junkthr0.png", pixd, IFF_PNG); pixDestroy(&pixd); /* dither to 2 bpp, with and without colormap */ pixd = pixDitherTo2bpp(pixs, 1); pixt = pixDitherTo2bpp(pixs, 0); pixt2 = pixConvertGrayToColormap(pixt); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixSaveTiled(pixt2, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr1.png", pixd, IFF_PNG); pixWrite("/tmp/junkthr2.png", pixt, IFF_PNG); pixWrite("/tmp/junkthr3.png", pixt2, IFF_PNG); /* pixcmapWriteStream(stderr, pixGetColormap(pixd)); */ pixEqual(pixd, pixt2, &equal); if (!equal) fprintf(stderr, "Error: thr2 != thr3\n"); pixDestroy(&pixt); pixDestroy(&pixt2); pixDestroy(&pixd); /* threshold to 2 bpp, with and without colormap */ pixd = pixThresholdTo2bpp(pixs, 4, 1); pixt = pixThresholdTo2bpp(pixs, 4, 0); pixt2 = pixConvertGrayToColormap(pixt); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixSaveTiled(pixt2, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr4.png", pixd, IFF_PNG); pixWrite("/tmp/junkthr5.png", pixt2, IFF_PNG); pixEqual(pixd, pixt2, &equal); if (!equal) fprintf(stderr, "Error: thr4 != thr5\n"); pixDestroy(&pixt); pixDestroy(&pixt2); pixDestroy(&pixd); pixd = pixThresholdTo2bpp(pixs, 3, 1); pixt = pixThresholdTo2bpp(pixs, 3, 0); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr6.png", pixd, IFF_PNG); pixWrite("/tmp/junkthr7.png", pixt, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); /* threshold to 4 bpp, with and without colormap */ pixd = pixThresholdTo4bpp(pixs, 9, 1); pixt = pixThresholdTo4bpp(pixs, 9, 0); pixt2 = pixConvertGrayToColormap(pixt); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixSaveTiled(pixt2, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr8.png", pixd, IFF_PNG); pixWrite("/tmp/junkthr9.png", pixt, IFF_PNG); pixWrite("/tmp/junkthr10.png", pixt2, IFF_PNG); /* pixcmapWriteStream(stderr, pixGetColormap(pixd)); */ pixDestroy(&pixt); pixDestroy(&pixt2); pixDestroy(&pixd); /* threshold on 8 bpp, with and without colormap */ pixd = pixThresholdOn8bpp(pixs, 9, 1); pixt = pixThresholdOn8bpp(pixs, 9, 0); pixt2 = pixConvertGrayToColormap(pixt); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixSaveTiled(pixt2, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr11.png", pixd, IFF_PNG); pixWrite("/tmp/junkthr12.png", pixt2, IFF_PNG); /* pixcmapWriteStream(stderr, pixGetColormap(pixd)); */ pixEqual(pixd, pixt2, &equal); if (!equal) fprintf(stderr, "Error: thr11 != thr12\n"); pixDestroy(&pixt); pixDestroy(&pixt2); pixDestroy(&pixd); pixd1 = pixaDisplay(pixa, 0, 0); pixDisplay(pixd1, 100, 100); pixWrite("/tmp/junkpixd1.jpg", pixd1, IFF_JFIF_JPEG); pixDestroy(&pixd1); pixaDestroy(&pixa); pixa = pixaCreate(0); pixSaveTiled(pixs, pixa, 1, 1, 20, 32); /* highlight 2 bpp with colormap */ pixd = pixThresholdTo2bpp(pixs, 3, 1); cmap = pixGetColormap(pixd); pixcmapWriteStream(stderr, cmap); box = boxCreate(278, 35, 122, 50); pixSetSelectCmap(pixd, box, 2, 255, 255, 100); pixcmapWriteStream(stderr, cmap); pixDisplay(pixd, 0, 0); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixWrite("/tmp/junkthr13.png", pixd, IFF_PNG); pixDestroy(&pixd); boxDestroy(&box); /* test pixThreshold8() */ pixd = pixThreshold8(pixs, 1, 2, 1); /* cmap */ pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixWrite("/tmp/junkthr14.png", pixd, IFF_PNG); pixDisplay(pixd, 100, 0); pixDestroy(&pixd); pixd = pixThreshold8(pixs, 1, 2, 0); /* no cmap */ pixSaveTiled(pixd, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr15.png", pixd, IFF_PNG); pixDisplay(pixd, 200, 0); pixDestroy(&pixd); pixd = pixThreshold8(pixs, 2, 3, 1); /* highlight one box */ pixSaveTiled(pixd, pixa, 1, 0, 20, 0); box = boxCreate(278, 35, 122, 50); pixSetSelectCmap(pixd, box, 2, 255, 255, 100); pixWrite("/tmp/junkthr16.png", pixd, IFF_PNG); pixDisplay(pixd, 300, 0); cmap = pixGetColormap(pixd); pixcmapWriteStream(stderr, cmap); boxDestroy(&box); pixDestroy(&pixd); pixd = pixThreshold8(pixs, 2, 4, 0); /* no cmap */ pixSaveTiled(pixd, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr17.png", pixd, IFF_PNG); pixDisplay(pixd, 400, 0); pixDestroy(&pixd); pixd = pixThreshold8(pixs, 4, 6, 1); /* highlight one box */ box = boxCreate(278, 35, 122, 50); pixSetSelectCmap(pixd, box, 5, 255, 255, 100); pixSaveTiled(pixd, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr18.png", pixd, IFF_PNG); cmap = pixGetColormap(pixd); pixcmapWriteStream(stderr, cmap); boxDestroy(&box); pixDisplay(pixd, 500, 0); pixDestroy(&pixd); pixd = pixThreshold8(pixs, 4, 6, 0); /* no cmap */ pixSaveTiled(pixd, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr19.png", pixd, IFF_PNG); pixDisplay(pixd, 600, 0); pixDestroy(&pixd); /* highlight 4 bpp with 2 colormap entries */ /* Note: We use 5 levels (0-4) for gray. */ /* 5 & 6 are used for highlight color. */ pixd = pixThresholdTo4bpp(pixs, 5, 1); cmap = pixGetColormap(pixd); pixcmapGetIndex(cmap, 255, 255, 255, &index); box = boxCreate(278, 35, 122, 50); pixSetSelectCmap(pixd, box, index, 255, 255, 100); /* use 5 */ boxDestroy(&box); box = boxCreate(4, 6, 157, 33); pixSetSelectCmap(pixd, box, index, 100, 255, 255); /* use 6 */ boxDestroy(&box); pixcmapWriteStream(stderr, cmap); pixSaveTiled(pixd, pixa, 1, 1, 20, 0); pixDisplay(pixd, 700, 0); pixWrite("/tmp/junkthr20.png", pixd, IFF_PNG); pixDestroy(&pixd); /* comparison 8 bpp jpeg with 2 bpp (highlight) */ pixDestroy(&pixs); pixs = pixRead("feyn.tif"); pixt = pixScaleToGray4(pixs); pixt2 = pixReduceRankBinaryCascade(pixs, 2, 2, 0, 0); pixd = pixThresholdTo2bpp(pixt, 3, 1); box = boxCreate(175, 208, 228, 88); pixSetSelectCmap(pixd, box, 2, 255, 255, 100); pixDisplay(pixd, 100, 200); cmap = pixGetColormap(pixd); pixcmapWriteStream(stderr, cmap); pixSaveTiled(pixt, pixa, 1, 1, 20, 0); pixSaveTiled(pixt2, pixa, 1, 0, 20, 0); pixSaveTiled(pixd, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr21.jpg", pixt, IFF_JFIF_JPEG); pixWrite("/tmp/junkthr22.png", pixt2, IFF_PNG); pixWrite("/tmp/junkthr23.png", pixd, IFF_PNG); pixDestroy(&pixd); pixDestroy(&pixt2); boxDestroy(&box); /* thresholding to 4 bpp (highlight); use pixt from above */ pixd = pixThresholdTo4bpp(pixt, NLEVELS, 1); box = boxCreate(175, 208, 228, 83); pixSetSelectCmap(pixd, box, NLEVELS - 1, 255, 255, 100); boxDestroy(&box); box = boxCreate(232, 298, 110, 25); pixSetSelectCmap(pixd, box, NLEVELS - 1, 100, 255, 255); boxDestroy(&box); box = boxCreate(21, 698, 246, 82); pixSetSelectCmap(pixd, box, NLEVELS - 1, 225, 100, 255); boxDestroy(&box); pixDisplay(pixd, 500, 200); cmap = pixGetColormap(pixd); pixcmapWriteStream(stderr, cmap); pixt2 = pixReduceRankBinaryCascade(pixs, 2, 2, 0, 0); pixSaveTiled(pixt2, pixa, 1, 1, 20, 0); pixSaveTiled(pixd, pixa, 1, 0, 20, 0); pixWrite("/tmp/junkthr24.png", pixt2, IFF_PNG); pixWrite("/tmp/junkthr25.png", pixd, IFF_PNG); pixDestroy(&pixt2); pixDestroy(&pixd); /* Thresholding to 4 bpp at 2, 3, 4, 5 and 6 levels */ box = boxCreate(25, 202, 136, 37); pixt1 = pixClipRectangle(pixt, box, NULL); pixt2 = pixScale(pixt1, 6., 6.); pixGetDimensions(pixt2, &w, &h, NULL); pixSaveTiled(pixt2, pixa, 1, 1, 20, 0); pixDisplay(pixt2, 0, 0); pixWrite("/tmp/junk-8.jpg", pixt2, IFF_JFIF_JPEG); pixd = pixCreate(w, 6 * h, 8); pixRasterop(pixd, 0, 0, w, h, PIX_SRC, pixt2, 0, 0); pixt3 = pixThresholdTo4bpp(pixt2, 6, 1); pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE); pixRasterop(pixd, 0, h, w, h, PIX_SRC, pixt4, 0, 0); pixSaveTiled(pixt3, pixa, 1, 0, 20, 0); pixDisplay(pixt3, 0, 100); pixWrite("/tmp/junk-4-6.png", pixt3, IFF_PNG); pixDestroy(&pixt3); pixDestroy(&pixt4); pixt3 = pixThresholdTo4bpp(pixt2, 5, 1); pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE); pixRasterop(pixd, 0, 2 * h, w, h, PIX_SRC, pixt4, 0, 0); pixSaveTiled(pixt3, pixa, 1, 0, 20, 0); pixDisplay(pixt3, 0, 200); pixWrite("/tmp/junk-4-5.png", pixt3, IFF_PNG); pixDestroy(&pixt3); pixDestroy(&pixt4); pixt3 = pixThresholdTo4bpp(pixt2, 4, 1); pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE); pixRasterop(pixd, 0, 3 * h, w, h, PIX_SRC, pixt4, 0, 0); pixSaveTiled(pixt3, pixa, 1, 0, 20, 0); pixDisplay(pixt3, 0, 300); pixWrite("/tmp/junk-4-4.png", pixt3, IFF_PNG); pixDestroy(&pixt3); pixDestroy(&pixt4); pixt3 = pixThresholdTo4bpp(pixt2, 3, 1); pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE); pixRasterop(pixd, 0, 4 * h, w, h, PIX_SRC, pixt4, 0, 0); pixSaveTiled(pixt3, pixa, 1, 1, 20, 0); pixDisplay(pixt3, 0, 400); pixWrite("/tmp/junk-4-3.png", pixt3, IFF_PNG); pixDestroy(&pixt3); pixDestroy(&pixt4); pixt3 = pixThresholdTo4bpp(pixt2, 2, 1); pixt4 = pixRemoveColormap(pixt3, REMOVE_CMAP_TO_GRAYSCALE); pixRasterop(pixd, 0, 5 * h, w, h, PIX_SRC, pixt4, 0, 0); pixDisplay(pixt3, 0, 500); pixSaveTiled(pixt3, pixa, 1, 0, 20, 0); pixWrite("/tmp/junk-4-2.png", pixt3, IFF_PNG); pixDestroy(&pixt3); pixDestroy(&pixt4); pixWrite("/tmp/junk-all.png", pixd, IFF_PNG); pixDestroy(&pixd); pixd2 = pixaDisplay(pixa, 0, 0); pixDisplay(pixd2, 100, 100); pixWrite("/tmp/junkpixd2.jpg", pixd2, IFF_JFIF_JPEG); pixDestroy(&pixd2); pixaDestroy(&pixa); #if 0 /* upscale 2x and threshold to 1 bpp; e.g., use test8.jpg */ startTimer(); pixd = pixScaleGray2xLIThresh(pixs, THRESHOLD); fprintf(stderr, " time for scale/dither = %7.3f sec\n", stopTimer()); pixWrite(fileout, pixd, IFF_PNG); pixDestroy(&pixd); #endif #if 0 /* upscale 4x and threshold to 1 bpp; e.g., use test8.jpg */ startTimer(); pixd = pixScaleGray4xLIThresh(pixs, THRESHOLD); fprintf(stderr, " time for scale/dither = %7.3f sec\n", stopTimer()); pixWrite(fileout, pixd, IFF_PNG); pixDestroy(&pixd); #endif boxDestroy(&box); pixDestroy(&pixt); pixDestroy(&pixt1); pixDestroy(&pixt2); pixDestroy(&pixs); /* Thresholding with fixed and arbitrary bin boundaries */ pixa = pixaCreate(0); pixs = pixRead("stampede2.jpg"); pixSaveTiled(pixs, pixa, 1, 1, 20, 8); pixt = pixThresholdTo4bpp(pixs, 5, 1); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); pixt = pixThresholdTo4bpp(pixs, 7, 1); cmap = pixGetColormap(pixt); pixcmapWriteStream(stderr, cmap); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); pixt = pixThresholdTo4bpp(pixs, 11, 1); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); pixSaveTiled(pixs, pixa, 1, 1, 20, 8); str = "45 75 115 185"; pixt = pixThresholdGrayArb(pixs, str, 8, 0, 0, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); str = "38 65 85 115 160 210"; pixt = pixThresholdGrayArb(pixs, str, 8, 0, 1, 1); cmap = pixGetColormap(pixt); pixcmapWriteStream(stderr, cmap); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); str = "38 60 75 90 110 130 155 185 208 239"; pixt = pixThresholdGrayArb(pixs, str, 8, 0, 0, 0); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); pixSaveTiled(pixs, pixa, 1, 1, 20, 8); str = "45 75 115 185"; pixt = pixThresholdGrayArb(pixs, str, 0, 1, 0, 1); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); str = "38 65 85 115 160 210"; pixt = pixThresholdGrayArb(pixs, str, 0, 1, 0, 1); cmap = pixGetColormap(pixt); pixcmapWriteStream(stderr, cmap); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); str = "38 60 75 90 110 130 155 185 208 239"; pixt = pixThresholdGrayArb(pixs, str, 4, 1, 0, 1); pixSaveTiled(pixt, pixa, 1, 0, 20, 0); pixDestroy(&pixt); pixd3 = pixaDisplay(pixa, 0, 0); pixDisplay(pixd3, 100, 100); pixWrite("/tmp/junkpixd3.jpg", pixd3, IFF_JFIF_JPEG); pixDestroy(&pixd3); pixaDestroy(&pixa); pixDestroy(&pixs); return 0; }
int main(int argc, char **argv) { l_int32 i; PIX *pixs, *pixc; PIXA *pixa; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; /* Test 1 bpp */ fprintf(stderr, "\n-------------- Testing 1 bpp ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[0]); pixc = pixScale(pixs, 0.32, 0.32); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 0 */ pixSaveTiled(pixc, pixa, 1.0, 1, SPACE, 32); pixDestroy(&pixc); pixc = pixScaleToGray3(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 1 */ PixSave32(pixa, pixc); pixc = pixScaleToGray4(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 2 */ pixSaveTiled(pixc, pixa, 1.0, 1, SPACE, 32); pixDestroy(&pixc); pixc = pixScaleToGray6(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 3 */ PixSave32(pixa, pixc); pixc = pixScaleToGray8(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 4 */ PixSave32(pixa, pixc); pixc = pixScaleToGray16(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 5 */ PixSave32(pixa, pixc); pixDestroy(&pixs); PixaSaveDisplay(pixa, rp); /* 6 */ for (i = 1; i < 10; i++) { pixa = pixaCreate(0); AddScaledImages(pixa, image[i], WIDTH); PixaSaveDisplay(pixa, rp); /* 7 - 16 */ } /* Test 2 bpp without colormap */ fprintf(stderr, "\n-------------- Testing 2 bpp without cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[1]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 2.25, 2.25); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 17 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 18 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 19 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 20 */ pixDestroy(&pixs); /* Test 2 bpp with colormap */ fprintf(stderr, "\n-------------- Testing 2 bpp with cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[2]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 2.25, 2.25); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 21 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 22 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 23 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 24 */ pixDestroy(&pixs); /* Test 4 bpp without colormap */ fprintf(stderr, "\n-------------- Testing 4 bpp without cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[3]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 1.72, 1.72); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 25 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 26 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 27 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 28 */ pixDestroy(&pixs); /* Test 4 bpp with colormap */ fprintf(stderr, "\n-------------- Testing 4 bpp with cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[4]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 1.72, 1.72); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 29 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 30 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 31 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 32 */ pixDestroy(&pixs); /* Test 8 bpp without colormap */ fprintf(stderr, "\n-------------- Testing 8 bpp without cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[5]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 1.92, 1.92); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 33 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 34 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 35 */ PixSave32(pixa, pixc); pixDestroy(&pixs); pixs = pixRead("graytext.png"); pixc = pixScaleToSize(pixs, 0, 32); /* uses fast unsharp masking */ regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 36 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 37 */ pixDestroy(&pixs); /* Test 8 bpp with colormap */ fprintf(stderr, "\n-------------- Testing 8 bpp with cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[6]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 1.92, 1.92); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 38 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 39 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 40 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 41 */ pixDestroy(&pixs); /* Test 16 bpp */ fprintf(stderr, "\n-------------- Testing 16 bpp ------------\n"); pixa = pixaCreate(0); pixs = pixRead(image[7]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 1.92, 1.92); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 42 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 43 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 44 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 45 */ pixDestroy(&pixs); /* Test 32 bpp */ fprintf(stderr, "\n-------------- Testing 32 bpp ------------\n"); pixa = pixaCreate(0); pixs = pixRead(image[8]); pixSaveTiled(pixs, pixa, 1.0, 1, SPACE, 32); pixc = pixScale(pixs, 1.42, 1.42); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 46 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 47 */ PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); /* 48 */ PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); /* 49 */ pixDestroy(&pixs); return regTestCleanup(rp); }
main(int argc, char **argv) { PIX *pixs; l_int32 d; static char mainName[] = "scaletest2"; if (argc != 2) return ERROR_INT(" Syntax: scaletest2 filein", mainName, 1); if ((pixs = pixRead(argv[1])) == NULL) return ERROR_INT("pixs not made", mainName, 1); d = pixGetDepth(pixs); #if 1 /* Integer scale-to-gray functions */ if (d == 1) { PIX *pixd; pixd = pixScaleToGray2(pixs); pixWrite("/tmp/s2g_2x", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray3(pixs); pixWrite("/tmp/s2g_3x", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray4(pixs); pixWrite("/tmp/s2g_4x", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray6(pixs); pixWrite("/tmp/s2g_6x", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray8(pixs); pixWrite("/tmp/s2g_8x", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray16(pixs); pixWrite("/tmp/s2g_16x", pixd, IFF_PNG); pixDestroy(&pixd); } #endif #if 1 /* Various non-integer scale-to-gray, compared with * with different ways of getting similar results */ if (d == 1) { PIX *pixt, *pixd; pixd = pixScaleToGray8(pixs); pixWrite("/tmp/s2g_8.png", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray(pixs, 0.124); pixWrite("/tmp/s2g_124.png", pixd, IFF_PNG); pixDestroy(&pixd); pixd = pixScaleToGray(pixs, 0.284); pixWrite("/tmp/s2g_284.png", pixd, IFF_PNG); pixDestroy(&pixd); pixt = pixScaleToGray4(pixs); pixd = pixScaleBySampling(pixt, 284./250., 284./250.); pixWrite("/tmp/s2g_284.2.png", pixd, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); pixt = pixScaleToGray4(pixs); pixd = pixScaleGrayLI(pixt, 284./250., 284./250.); pixWrite("/tmp/s2g_284.3.png", pixd, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); pixt = pixScaleBinary(pixs, 284./250., 284./250.); pixd = pixScaleToGray4(pixt); pixWrite("/tmp/s2g_284.4.png", pixd, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); pixt = pixScaleToGray4(pixs); pixd = pixScaleGrayLI(pixt, 0.49, 0.49); pixWrite("/tmp/s2g_42.png", pixd, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); pixt = pixScaleToGray4(pixs); pixd = pixScaleSmooth(pixt, 0.49, 0.49); pixWrite("/tmp/s2g_4sm.png", pixd, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); pixt = pixScaleBinary(pixs, .16/.125, .16/.125); pixd = pixScaleToGray8(pixt); pixWrite("/tmp/s2g_16.png", pixd, IFF_PNG); pixDestroy(&pixt); pixDestroy(&pixd); pixd = pixScaleToGray(pixs, .16); pixWrite("/tmp/s2g_16.2.png", pixd, IFF_PNG); pixDestroy(&pixd); } #endif #if 1 /* Antialiased (smoothed) reduction, along with sharpening */ if (d != 1) { PIX *pixt1, *pixt2; startTimer(); pixt1 = pixScaleSmooth(pixs, 0.154, 0.154); fprintf(stderr, "fast scale: %5.3f sec\n", stopTimer()); pixDisplayWithTitle(pixt1, 0, 0, "smooth scaling", DISPLAY); pixWrite("/tmp/smooth1.png", pixt1, IFF_PNG); pixt2 = pixUnsharpMasking(pixt1, 1, 0.3); pixWrite("/tmp/smooth2.png", pixt2, IFF_PNG); pixDisplayWithTitle(pixt2, 200, 0, "sharp scaling", DISPLAY); pixDestroy(&pixt1); pixDestroy(&pixt2); } #endif #if 1 /* Test a large range of scale-to-gray reductions */ if (d == 1) { l_int32 i; l_float32 scale; PIX *pixd; for (i = 2; i < 15; i++) { scale = 1. / (l_float32)i; startTimer(); pixd = pixScaleToGray(pixs, scale); fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n", scale, stopTimer()); pixDisplayWithTitle(pixd, 75 * i, 100, "scaletogray", DISPLAY); pixDestroy(&pixd); } for (i = 8; i < 14; i++) { scale = 1. / (l_float32)(2 * i); startTimer(); pixd = pixScaleToGray(pixs, scale); fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n", scale, stopTimer()); pixDisplayWithTitle(pixd, 100 * i, 600, "scaletogray", DISPLAY); pixDestroy(&pixd); } } #endif #if 1 /* Test the same range of scale-to-gray mipmap reductions */ if (d == 1) { l_int32 i; l_float32 scale; PIX *pixd; for (i = 2; i < 15; i++) { scale = 1. / (l_float32)i; startTimer(); pixd = pixScaleToGrayMipmap(pixs, scale); fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n", scale, stopTimer()); pixDisplayWithTitle(pixd, 75 * i, 100, "scale mipmap", DISPLAY); pixDestroy(&pixd); } for (i = 8; i < 12; i++) { scale = 1. / (l_float32)(2 * i); startTimer(); pixd = pixScaleToGrayMipmap(pixs, scale); fprintf(stderr, "Time for scale %7.3f: %7.3f sec\n", scale, stopTimer()); pixDisplayWithTitle(pixd, 100 * i, 600, "scale mipmap", DISPLAY); pixDestroy(&pixd); } } #endif #if 1 /* Test several methods for antialiased reduction, * along with sharpening */ if (d != 1) { PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6, *pixt7; l_float32 SCALING = 0.27; l_int32 SIZE = 7; l_int32 smooth; l_float32 FRACT = 1.0; smooth = SIZE / 2; startTimer(); pixt1 = pixScaleSmooth(pixs, SCALING, SCALING); fprintf(stderr, "fast scale: %5.3f sec\n", stopTimer()); pixDisplayWithTitle(pixt1, 0, 0, "smooth scaling", DISPLAY); pixWrite("/tmp/sm_1.png", pixt1, IFF_PNG); pixt2 = pixUnsharpMasking(pixt1, 1, 0.3); pixDisplayWithTitle(pixt2, 150, 0, "sharpened scaling", DISPLAY); startTimer(); pixt3 = pixBlockconv(pixs, smooth, smooth); pixt4 = pixScaleBySampling(pixt3, SCALING, SCALING); fprintf(stderr, "slow scale: %5.3f sec\n", stopTimer()); pixDisplayWithTitle(pixt4, 200, 200, "sampled scaling", DISPLAY); pixWrite("/tmp/sm_2.png", pixt4, IFF_PNG); startTimer(); pixt5 = pixUnsharpMasking(pixs, smooth, FRACT); pixt6 = pixBlockconv(pixt5, smooth, smooth); pixt7 = pixScaleBySampling(pixt6, SCALING, SCALING); fprintf(stderr, "very slow scale + sharp: %5.3f sec\n", stopTimer()); pixDisplayWithTitle(pixt7, 500, 200, "sampled scaling", DISPLAY); pixWrite("/tmp/sm_3.jpg", pixt7, IFF_JFIF_JPEG); pixDestroy(&pixt1); pixDestroy(&pixt2); pixDestroy(&pixt3); pixDestroy(&pixt4); pixDestroy(&pixt5); pixDestroy(&pixt6); pixDestroy(&pixt7); } #endif #if 1 /* Test the color scaling function, comparing the * special case of scaling factor 2.0 with the * general case. */ if (d == 32) { PIX *pix1, *pix2, *pixd; NUMA *nar, *nag, *nab, *naseq; GPLOT *gplot; startTimer(); pix1 = pixScaleColorLI(pixs, 2.00001, 2.0); fprintf(stderr, " Time with regular LI: %7.3f\n", stopTimer()); pixWrite("/tmp/color1.jpg", pix1, IFF_JFIF_JPEG); startTimer(); pix2 = pixScaleColorLI(pixs, 2.0, 2.0); fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer()); pixWrite("/tmp/color2.jpg", pix2, IFF_JFIF_JPEG); pixd = pixAbsDifference(pix1, pix2); pixGetColorHistogram(pixd, 1, &nar, &nag, &nab); naseq = numaMakeSequence(0., 1., 256); gplot = gplotCreate("/tmp/plot_absdiff", GPLOT_X11, "Number vs diff", "diff", "number"); gplotSetScaling(gplot, GPLOT_LOG_SCALE_Y); gplotAddPlot(gplot, naseq, nar, GPLOT_POINTS, "red"); gplotAddPlot(gplot, naseq, nag, GPLOT_POINTS, "green"); gplotAddPlot(gplot, naseq, nab, GPLOT_POINTS, "blue"); gplotMakeOutput(gplot); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pixd); numaDestroy(&naseq); numaDestroy(&nar); numaDestroy(&nag); numaDestroy(&nab); gplotDestroy(&gplot); } #endif #if 1 /* Test the gray LI scaling function, comparing the * special cases of scaling factor 2.0 and 4.0 with the * general case */ if (d == 8 || d == 32) { PIX *pixt, *pix0, *pix1, *pix2, *pixd; NUMA *nagray, *naseq; GPLOT *gplot; if (d == 8) pixt = pixClone(pixs); else pixt = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33); pix0 = pixScaleGrayLI(pixt, 0.5, 0.5); #if 1 startTimer(); pix1 = pixScaleGrayLI(pix0, 2.00001, 2.0); fprintf(stderr, " Time with regular LI 2x: %7.3f\n", stopTimer()); startTimer(); pix2 = pixScaleGrayLI(pix0, 2.0, 2.0); fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer()); #else startTimer(); pix1 = pixScaleGrayLI(pix0, 4.00001, 4.0); fprintf(stderr, " Time with regular LI 4x: %7.3f\n", stopTimer()); startTimer(); pix2 = pixScaleGrayLI(pix0, 4.0, 4.0); fprintf(stderr, " Time with 2x LI: %7.3f\n", stopTimer()); #endif pixWrite("/tmp/gray1", pix1, IFF_JFIF_JPEG); pixWrite("/tmp/gray2", pix2, IFF_JFIF_JPEG); pixd = pixAbsDifference(pix1, pix2); nagray = pixGetGrayHistogram(pixd, 1); naseq = numaMakeSequence(0., 1., 256); gplot = gplotCreate("/tmp/g_absdiff", GPLOT_X11, "Number vs diff", "diff", "number"); gplotSetScaling(gplot, GPLOT_LOG_SCALE_Y); gplotAddPlot(gplot, naseq, nagray, GPLOT_POINTS, "gray"); gplotMakeOutput(gplot); pixDestroy(&pixt); pixDestroy(&pix0); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pixd); numaDestroy(&naseq); numaDestroy(&nagray); gplotDestroy(&gplot); } #endif pixDestroy(&pixs); return 0; }
main(int argc, char **argv) { l_int32 i, j, w, h, error; l_float32 val1, val2; l_float32 val00, val10, val01, val11, valc00, valc10, valc01, valc11; PIX *pixs, *pixg, *pixt1, *pixt2, *pixt3, *pixt4, *pixt5; FPIXA *fpixam, *fpixav, *fpixarv; BOXAA *baa; static char mainName[] = "quadtreetest"; if (argc != 1) return ERROR_INT(" Syntax: quadtreetest", mainName, 1); /* Test generation of quadtree regions. */ baa = boxaaQuadtreeRegions(1000, 500, 3); boxaaWriteStream(stderr, baa); boxaaDestroy(&baa); baa = boxaaQuadtreeRegions(1001, 501, 3); boxaaWriteStream(stderr, baa); boxaaDestroy(&baa); /* Test quadtree stats generation */ #if 1 pixs = pixRead("rabi.png"); pixg = pixScaleToGray4(pixs); #else pixs = pixRead("test24.jpg"); pixg = pixConvertTo8(pixs, 0); #endif pixQuadtreeMean(pixg, 8, NULL, &fpixam); pixt1 = fpixaDisplayQuadtree(fpixam, 4); pixDisplay(pixt1, 100, 0); pixWrite("/tmp/quadtree1.png", pixt1, IFF_PNG); pixQuadtreeVariance(pixg, 8, NULL, NULL, &fpixav, &fpixarv); pixt2 = fpixaDisplayQuadtree(fpixav, 4); pixDisplay(pixt2, 100, 200); pixWrite("/tmp/quadtree2.png", pixt2, IFF_PNG); pixt3 = fpixaDisplayQuadtree(fpixarv, 4); pixDisplay(pixt3, 100, 400); pixWrite("/tmp/quadtree3.png", pixt3, IFF_PNG); /* Compare with fixed-size tiling at a resolution corresponding * to the deepest level of the quadtree above */ pixt4 = pixGetAverageTiled(pixg, 5, 6, L_MEAN_ABSVAL); pixt5 = pixExpandReplicate(pixt4, 4); pixWrite("/tmp/quadtree4.png", pixt5, IFF_PNG); pixDisplay(pixt5, 800, 0); pixDestroy(&pixt4); pixDestroy(&pixt5); pixt4 = pixGetAverageTiled(pixg, 5, 6, L_STANDARD_DEVIATION); pixt5 = pixExpandReplicate(pixt4, 4); pixWrite("/tmp/quadtree5.png", pixt5, IFF_PNG); pixDisplay(pixt5, 800, 400); /* Test quadtree parent/child access */ error = FALSE; fpixaGetFPixDimensions(fpixam, 4, &w, &h); for (i = 0; i < w; i += 2) { for (j = 0; j < h; j += 2) { quadtreeGetParent(fpixam, 4, j, i, &val1); fpixaGetPixel(fpixam, 3, j / 2, i / 2, &val2); if (val1 != val2) error = TRUE; } } if (error) fprintf(stderr, "\n======================\nError: parent access\n"); else fprintf(stderr, "\n======================\nSuccess: parent access\n"); error = FALSE; for (i = 0; i < w; i++) { for (j = 0; j < h; j++) { quadtreeGetChildren(fpixam, 4, j, i, &val00, &val10, &val01, &val11); fpixaGetPixel(fpixam, 5, 2 * j, 2 * i, &valc00); fpixaGetPixel(fpixam, 5, 2 * j + 1, 2 * i, &valc10); fpixaGetPixel(fpixam, 5, 2 * j, 2 * i + 1, &valc01); fpixaGetPixel(fpixam, 5, 2 * j + 1, 2 * i + 1, &valc11); if ((val00 != valc00) || (val10 != valc10) || (val01 != valc01) || (val11 != valc11)) error = TRUE; } } if (error) fprintf(stderr, "Error: child access\n======================\n"); else fprintf(stderr, "Success: child access\n======================\n"); pixDestroy(&pixs); pixDestroy(&pixg); pixDestroy(&pixt1); pixDestroy(&pixt2); pixDestroy(&pixt3); pixDestroy(&pixt4); pixDestroy(&pixt5); fpixaDestroy(&fpixam); fpixaDestroy(&fpixav); fpixaDestroy(&fpixarv); return 0; }
main(int argc, char **argv) { l_int32 i; PIX *pixs, *pixc, *pixd; PIXA *pixa; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; /* Test 1 bpp */ fprintf(stderr, "\n-------------- Testing 1 bpp ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[0]); pixc = pixScale(pixs, 0.32, 0.32); regTestWritePixAndCheck(rp, pixc, IFF_PNG); pixSaveTiled(pixc, pixa, 1, 1, SPACE, 32); pixDestroy(&pixc); pixc = pixScaleToGray3(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScaleToGray4(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); pixSaveTiled(pixc, pixa, 1, 1, SPACE, 32); pixDestroy(&pixc); pixc = pixScaleToGray6(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScaleToGray8(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScaleToGray16(pixs); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixDestroy(&pixs); PixaSaveDisplay(pixa, rp); for (i = 1; i < 10; i++) { pixa = pixaCreate(0); AddScaledImages(pixa, image[i], WIDTH); PixaSaveDisplay(pixa, rp); } /* Test 2 bpp without colormap */ fprintf(stderr, "\n-------------- Testing 2 bpp without cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[1]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 2.25, 2.25); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 2 bpp with colormap */ fprintf(stderr, "\n-------------- Testing 2 bpp with cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[2]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 2.25, 2.25); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 4 bpp without colormap */ fprintf(stderr, "\n-------------- Testing 4 bpp without cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[3]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 1.72, 1.72); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 4 bpp with colormap */ fprintf(stderr, "\n-------------- Testing 4 bpp with cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[4]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 1.72, 1.72); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_PNG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 8 bpp without colormap */ fprintf(stderr, "\n-------------- Testing 8 bpp without cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[5]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 1.92, 1.92); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 8 bpp with colormap */ fprintf(stderr, "\n-------------- Testing 8 bpp with cmap ----------\n"); pixa = pixaCreate(0); pixs = pixRead(image[6]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 1.92, 1.92); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 16 bpp */ fprintf(stderr, "\n-------------- Testing 16 bpp ------------\n"); pixa = pixaCreate(0); pixs = pixRead(image[7]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 1.92, 1.92); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); /* Test 32 bpp */ fprintf(stderr, "\n-------------- Testing 32 bpp ------------\n"); pixa = pixaCreate(0); pixs = pixRead(image[8]); pixSaveTiled(pixs, pixa, 1, 1, SPACE, 32); pixc = pixScale(pixs, 1.42, 1.42); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.85, 0.85); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); pixc = pixScale(pixs, 0.65, 0.65); regTestWritePixAndCheck(rp, pixc, IFF_JFIF_JPEG); PixSave32(pixa, pixc); PixaSaveDisplay(pixa, rp); pixDestroy(&pixs); return regTestCleanup(rp); }