/*! * pixSaveTiledWithText() * * Input: pixs (1, 2, 4, 8, 32 bpp) * pixa (the pix are accumulated here; as 32 bpp) * outwidth (in pixels; use 0 to disable entirely) * newrow (1 to start a new row; 0 to go on same row as previous) * space (horizontal and vertical spacing, in pixels) * linewidth (width of added outline for image; 0 for no outline) * bmf (<optional> font struct) * textstr (<optional> text string to be added) * val (color to set the text) * location (L_ADD_ABOVE, L_ADD_AT_TOP, L_ADD_AT_BOT, L_ADD_BELOW) * Return: 0 if OK, 1 on error. * * Notes: * (1) Before calling this function for the first time, use * pixaCreate() to make the @pixa that will accumulate the pix. * This is passed in each time pixSaveTiled() is called. * (2) @outwidth is the scaled width. After scaling, the image is * saved in the input pixa, along with a box that specifies * the location to place it when tiled later. Disable saving * the pix by setting @outwidth == 0. * (3) @newrow and @space specify the location of the new pix * with respect to the last one(s) that were entered. * (4) All pix are saved as 32 bpp RGB. * (5) If both @bmf and @textstr are defined, this generates a pix * with the additional text; otherwise, no text is written. * (6) The text is written before scaling, so it is properly * antialiased in the scaled pix. However, if the pix on * different calls have different widths, the size of the * text will vary. * (7) See pixSaveTiledOutline() for other implementation details. */ l_int32 pixSaveTiledWithText(PIX *pixs, PIXA *pixa, l_int32 outwidth, l_int32 newrow, l_int32 space, l_int32 linewidth, L_BMF *bmf, const char *textstr, l_uint32 val, l_int32 location) { PIX *pix1, *pix2, *pix3, *pix4; PROCNAME("pixSaveTiledWithText"); if (outwidth == 0) return 0; if (!pixs) return ERROR_INT("pixs not defined", procName, 1); if (!pixa) return ERROR_INT("pixa not defined", procName, 1); pix1 = pixConvertTo32(pixs); if (linewidth > 0) pix2 = pixAddBorder(pix1, linewidth, 0); else pix2 = pixClone(pix1); if (bmf && textstr) pix3 = pixAddSingleTextblock(pix2, bmf, textstr, val, location, NULL); else pix3 = pixClone(pix2); pix4 = pixScaleToSize(pix3, outwidth, 0); pixSaveTiled(pix4, pixa, 1.0, newrow, space, 32); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); return 0; }
int main(int argc, char **argv) { l_uint8 *data; l_int32 w, h, n1, n2, n, i, minval, maxval; l_int32 ncolors, rval, gval, bval, equal; l_int32 *rmap, *gmap, *bmap; l_uint32 color; l_float32 gamma; BOX *box; FILE *fp; PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6; PIX *pixs, *pixb, *pixg, *pixc, *pixd; PIX *pixg2, *pixcs1, *pixcs2, *pixd1, *pixd2; PIXA *pixa, *pixa2, *pixa3; PIXCMAP *cmap, *cmap2; RGBA_QUAD *cta; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; /* ------------------------ (1) ----------------------------*/ /* Blend with a white background */ pix1 = pixRead("books_logo.png"); pixDisplayWithTitle(pix1, 100, 0, NULL, rp->display); pix2 = pixAlphaBlendUniform(pix1, 0xffffff00); pixDisplayWithTitle(pix2, 100, 150, NULL, rp->display); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */ regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */ /* Generate an alpha layer based on the white background */ pix3 = pixSetAlphaOverWhite(pix2); pixSetSpp(pix3, 3); pixWrite("/tmp/alphaops.2.png", pix3, IFF_PNG); /* without alpha */ regTestCheckFile(rp, "/tmp/alphaops.2.png"); /* 2 */ pixSetSpp(pix3, 4); regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3, with alpha */ pixDisplayWithTitle(pix3, 100, 300, NULL, rp->display); /* Render on a light yellow background */ pix4 = pixAlphaBlendUniform(pix3, 0xffffe000); regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */ pixDisplayWithTitle(pix4, 100, 450, NULL, rp->display); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); /* ------------------------ (2) ----------------------------*/ lept_rmdir("alpha"); lept_mkdir("alpha"); /* Make the transparency (alpha) layer. * pixs is the mask. We turn it into a transparency (alpha) * layer by converting to 8 bpp. A small convolution fuzzes * the mask edges so that you don't see the pixels. */ pixs = pixRead("feyn-fract.tif"); pixGetDimensions(pixs, &w, &h, NULL); pixg = pixConvert1To8(NULL, pixs, 0, 255); pixg2 = pixBlockconvGray(pixg, NULL, 1, 1); regTestWritePixAndCheck(rp, pixg2, IFF_JFIF_JPEG); /* 5 */ pixDisplayWithTitle(pixg2, 0, 0, "alpha", rp->display); /* Make the viewable image. * pixc is the image that we see where the alpha layer is * opaque -- i.e., greater than 0. Scale it to the same * size as the mask. To visualize what this will look like * when displayed over a black background, create the black * background image, pixb, and do the blending with pixcs1 * explicitly using the alpha layer pixg2. */ pixc = pixRead("tetons.jpg"); pixcs1 = pixScaleToSize(pixc, w, h); regTestWritePixAndCheck(rp, pixcs1, IFF_JFIF_JPEG); /* 6 */ pixDisplayWithTitle(pixcs1, 300, 0, "viewable", rp->display); pixb = pixCreateTemplate(pixcs1); /* black */ pixd1 = pixBlendWithGrayMask(pixb, pixcs1, pixg2, 0, 0); regTestWritePixAndCheck(rp, pixd1, IFF_JFIF_JPEG); /* 7 */ pixDisplayWithTitle(pixd1, 600, 0, "alpha-blended 1", rp->display); /* Embed the alpha layer pixg2 into the color image pixc. * Write it out as is. Then clean pixcs1 (to 0) under the fully * transparent part of the alpha layer, and write that result * out as well. */ pixSetRGBComponent(pixcs1, pixg2, L_ALPHA_CHANNEL); pixWrite("/tmp/alpha/pixcs1.png", pixcs1, IFF_PNG); pixcs2 = pixSetUnderTransparency(pixcs1, 0, 0); pixWrite("/tmp/alpha/pixcs2.png", pixcs2, IFF_PNG); /* What will this look like over a black background? * Do the blending explicitly and display. It should * look identical to the blended result pixd1 before cleaning. */ pixd2 = pixBlendWithGrayMask(pixb, pixcs2, pixg2, 0, 0); regTestWritePixAndCheck(rp, pixd2, IFF_JFIF_JPEG); /* 8 */ pixDisplayWithTitle(pixd2, 0, 400, "alpha blended 2", rp->display); /* Read the two images back, ignoring the transparency layer. * The uncleaned image will come back identical to pixcs1. * However, the cleaned image will be black wherever * the alpha layer was fully transparent. It will * look the same when viewed through the alpha layer, * but have much better compression. */ pix1 = pixRead("/tmp/alpha/pixcs1.png"); /* just pixcs1 */ pix2 = pixRead("/tmp/alpha/pixcs2.png"); /* cleaned under transparent */ n1 = nbytesInFile("/tmp/alpha/pixcs1.png"); n2 = nbytesInFile("/tmp/alpha/pixcs2.png"); fprintf(stderr, " Original: %d bytes\n Cleaned: %d bytes\n", n1, n2); regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 9 */ regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 10 */ pixDisplayWithTitle(pix1, 300, 400, "without alpha", rp->display); pixDisplayWithTitle(pix2, 600, 400, "cleaned under transparent", rp->display); pixa = pixaCreate(0); pixSaveTiled(pixg2, pixa, 1.0, 1, 20, 32); pixSaveTiled(pixcs1, pixa, 1.0, 1, 20, 0); pixSaveTiled(pix1, pixa, 1.0, 0, 20, 0); pixSaveTiled(pixd1, pixa, 1.0, 1, 20, 0); pixSaveTiled(pixd2, pixa, 1.0, 0, 20, 0); pixSaveTiled(pix2, pixa, 1.0, 1, 20, 0); pixd = pixaDisplay(pixa, 0, 0); regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */ pixDisplayWithTitle(pixd, 200, 200, "composite", rp->display); pixWrite("/tmp/alpha/alpha.png", pixd, IFF_JFIF_JPEG); pixDestroy(&pixd); pixaDestroy(&pixa); pixDestroy(&pixs); pixDestroy(&pixb); pixDestroy(&pixg); pixDestroy(&pixg2); pixDestroy(&pixc); pixDestroy(&pixcs1); pixDestroy(&pixcs2); pixDestroy(&pixd); pixDestroy(&pixd1); pixDestroy(&pixd2); pixDestroy(&pix1); pixDestroy(&pix2); /* ------------------------ (3) ----------------------------*/ color = 0xffffa000; gamma = 1.0; minval = 0; maxval = 200; box = boxCreate(0, 85, 600, 100); pixa = pixaCreate(6); pix1 = pixRead("blend-green1.jpg"); pixaAddPix(pixa, pix1, L_INSERT); pix1 = pixRead("blend-green2.png"); pixaAddPix(pixa, pix1, L_INSERT); pix1 = pixRead("blend-green3.png"); pixaAddPix(pixa, pix1, L_INSERT); pix1 = pixRead("blend-orange.jpg"); pixaAddPix(pixa, pix1, L_INSERT); pix1 = pixRead("blend-yellow.jpg"); pixaAddPix(pixa, pix1, L_INSERT); pix1 = pixRead("blend-red.png"); pixaAddPix(pixa, pix1, L_INSERT); n = pixaGetCount(pixa); pixa2 = pixaCreate(n); pixa3 = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixa, i, L_CLONE); pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 1); regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 12, 14, ... 22 */ pixDisplayWithTitle(pix2, 150 * i, 0, NULL, rp->display); pixaAddPix(pixa2, pix2, L_INSERT); pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 2); regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 13, 15, ... 23 */ pixDisplayWithTitle(pix2, 150 * i, 200, NULL, rp->display); pixaAddPix(pixa3, pix2, L_INSERT); pixDestroy(&pix1); } if (rp->display) { pixaConvertToPdf(pixa2, 0, 0.75, L_FLATE_ENCODE, 0, "blend 1 test", "/tmp/alpha/blending1.pdf"); pixaConvertToPdf(pixa3, 0, 0.75, L_FLATE_ENCODE, 0, "blend 2 test", "/tmp/alpha/blending2.pdf"); } pixaDestroy(&pixa); pixaDestroy(&pixa2); pixaDestroy(&pixa3); boxDestroy(&box); /* ------------------------ (4) ----------------------------*/ /* Use one image as the alpha component for a second image */ pix1 = pixRead("test24.jpg"); pix2 = pixRead("marge.jpg"); pix3 = pixScale(pix2, 1.9, 2.2); pix4 = pixConvertTo8(pix3, 0); pixSetRGBComponent(pix1, pix4, L_ALPHA_CHANNEL); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 24 */ pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display); /* Set the alpha value in a colormap to bval */ pix5 = pixOctreeColorQuant(pix1, 128, 0); cmap = pixGetColormap(pix5); pixcmapToArrays(cmap, &rmap, &gmap, &bmap, NULL); n = pixcmapGetCount(cmap); for (i = 0; i < n; i++) { pixcmapGetColor(cmap, i, &rval, &gval, &bval); cta = (RGBA_QUAD *)cmap->array; cta[i].alpha = bval; } /* Test binary serialization/deserialization of colormap with alpha */ pixcmapSerializeToMemory(cmap, 4, &ncolors, &data); cmap2 = pixcmapDeserializeFromMemory(data, 4, ncolors); CmapEqual(cmap, cmap2, &equal); regTestCompareValues(rp, TRUE, equal, 0.0); /* 25 */ pixcmapDestroy(&cmap2); lept_free(data); /* Test ascii serialization/deserialization of colormap with alpha */ fp = fopenWriteStream("/tmp/alpha/cmap.4", "w"); pixcmapWriteStream(fp, cmap); fclose(fp); fp = fopenReadStream("/tmp/alpha/cmap.4"); cmap2 = pixcmapReadStream(fp); fclose(fp); CmapEqual(cmap, cmap2, &equal); regTestCompareValues(rp, TRUE, equal, 0.0); /* 26 */ pixcmapDestroy(&cmap2); /* Test r/w for cmapped pix with non-opaque alpha */ pixDisplayWithTitle(pix5, 900, 0, NULL, rp->display); regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 27 */ pixWrite("/tmp/alpha/fourcomp.png", pix5, IFF_PNG); pix6 = pixRead("/tmp/alpha/fourcomp.png"); regTestComparePix(rp, pix5, pix6); /* 28 */ pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); pixDestroy(&pix5); pixDestroy(&pix6); lept_free(rmap); lept_free(gmap); lept_free(bmap); return regTestCleanup(rp); }
int main(int argc, char **argv) { l_int32 w, h, x, y, i, n; l_float32 *vc; PIX *pix1, *pix2, *pix3, *pix4, *pix5; PIXA *pixas, *pixa; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; pixas = pixaCreate(11); for (i = 0; i < 10; i++) { /* this preserves any alpha */ pix1 = pixRead(fnames[i]); pix2 = pixScaleBySamplingToSize(pix1, 250, 150); pixaAddPix(pixas, pix2, L_INSERT); pixDestroy(&pix1); } /* Add a transparent grid over the rgb image */ pix1 = pixaGetPix(pixas, 8, L_COPY); pixGetDimensions(pix1, &w, &h, NULL); pix2 = pixCreate(w, h, 1); for (i = 0; i < 5; i++) { y = h * (i + 1) / 6; pixRenderLine(pix2, 0, y, w, y, 3, L_SET_PIXELS); } for (i = 0; i < 7; i++) { x = w * (i + 1) / 8; pixRenderLine(pix2, x, 0, x, h, 3, L_SET_PIXELS); } pix3 = pixConvertTo8(pix2, 0); /* 1 --> 0 ==> transparent */ pixSetRGBComponent(pix1, pix3, L_ALPHA_CHANNEL); pixaAddPix(pixas, pix1, L_INSERT); n = pixaGetCount(pixas); pixDestroy(&pix2); pixDestroy(&pix3); #if DO_ALL /* Display with and without removing alpha with white bg */ pix1 = pixaDisplayTiledInRows(pixas, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */ pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display); pixDestroy(&pix1); pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRemoveAlpha(pix1); pixaAddPix(pixa, pix2, L_INSERT); pixDestroy(&pix1); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 1 */ pixDisplayWithTitle(pix1, 200, 0, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Setting to gray */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pixSetAllGray(pix1, 170); pix2 = pixRemoveAlpha(pix1); pixaAddPix(pixa, pix2, L_INSERT); pixDestroy(&pix1); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 2 */ pixDisplayWithTitle(pix1, 400, 0, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* General scaling */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixScaleToSize(pix1, 350, 650); pix3 = pixScaleToSize(pix2, 200, 200); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 3 */ pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Scaling by sampling */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixScaleBySamplingToSize(pix1, 350, 650); pix3 = pixScaleBySamplingToSize(pix2, 200, 200); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 4 */ pixDisplayWithTitle(pix1, 800, 0, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by area mapping; no embedding */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotate(pix1, 0.25, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, 0, 0); pix3 = pixRotate(pix2, -0.35, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, 0, 0); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 5 */ pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by area mapping; with embedding */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotate(pix1, 0.25, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, 250, 150); pix3 = pixRotate(pix2, -0.35, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, 250, 150); pix4 = pixRemoveBorderToSize(pix3, 250, 150); pix5 = pixRemoveAlpha(pix4); pixaAddPix(pixa, pix5, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 6 */ pixDisplayWithTitle(pix1, 0, 400, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by 3-shear; no embedding */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotate(pix1, 0.25, L_ROTATE_SHEAR, L_BRING_IN_WHITE, 0, 0); pix3 = pixRotate(pix2, -0.35, L_ROTATE_SHEAR, L_BRING_IN_WHITE, 0, 0); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 7 */ pixDisplayWithTitle(pix1, 200, 400, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by 3-shear; with embedding */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotate(pix1, 0.25, L_ROTATE_SHEAR, L_BRING_IN_WHITE, 250, 150); pix3 = pixRotate(pix2, -0.35, L_ROTATE_SHEAR, L_BRING_IN_WHITE, 250, 150); pix4 = pixRemoveBorderToSize(pix3, 250, 150); pix5 = pixRemoveAlpha(pix4); pixaAddPix(pixa, pix5, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8 */ pixDisplayWithTitle(pix1, 400, 400, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by 2-shear about the center */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pixGetDimensions(pix1, &w, &h, NULL); pix2 = pixRotate2Shear(pix1, w / 2, h / 2, 0.25, L_BRING_IN_WHITE); pix3 = pixRotate2Shear(pix2, w / 2, h / 2, -0.35, L_BRING_IN_WHITE); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 9 */ pixDisplayWithTitle(pix1, 600, 400, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by sampling; no embedding */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotate(pix1, 0.25, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, 0, 0); pix3 = pixRotate(pix2, -0.35, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, 0, 0); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 10 */ pixDisplayWithTitle(pix1, 800, 400, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by sampling; with embedding */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotate(pix1, 0.25, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, 250, 150); pix3 = pixRotate(pix2, -0.35, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, 250, 150); pix4 = pixRemoveBorderToSize(pix3, 250, 150); pix5 = pixRemoveAlpha(pix4); pixaAddPix(pixa, pix5, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 11 */ pixDisplayWithTitle(pix1, 1000, 400, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Rotation by area mapping at corner */ pixa = pixaCreate(n); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixRotateAMCorner(pix1, 0.25, L_BRING_IN_WHITE); pix3 = pixRotateAMCorner(pix2, -0.35, L_BRING_IN_WHITE); pix4 = pixRemoveAlpha(pix3); pixaAddPix(pixa, pix4, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */ pixDisplayWithTitle(pix1, 0, 800, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); #endif #if DO_ALL /* Affine transform by interpolation */ pixa = pixaCreate(n); vc = Generate3PtTransformVector(); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixAffine(pix1, vc, L_BRING_IN_WHITE); /* pix2 = pixAffineSampled(pix1, vc, L_BRING_IN_WHITE); */ pix3 = pixRemoveAlpha(pix2); pixaAddPix(pixa, pix3, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 13 */ pixDisplayWithTitle(pix1, 200, 800, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); lept_free(vc); #endif #if DO_ALL /* Projective transform by sampling */ pixa = pixaCreate(n); vc = Generate4PtTransformVector(PROJECTIVE); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixProjectiveSampled(pix1, vc, L_BRING_IN_WHITE); pix3 = pixRemoveAlpha(pix2); pixaAddPix(pixa, pix3, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */ pixDisplayWithTitle(pix1, 400, 800, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); lept_free(vc); #endif #if DO_ALL /* Projective transform by interpolation */ pixa = pixaCreate(n); vc = Generate4PtTransformVector(PROJECTIVE); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixProjective(pix1, vc, L_BRING_IN_WHITE); pix3 = pixRemoveAlpha(pix2); pixaAddPix(pixa, pix3, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 15 */ pixDisplayWithTitle(pix1, 600, 800, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); lept_free(vc); #endif #if DO_ALL /* Bilinear transform by interpolation */ pixa = pixaCreate(n); vc = Generate4PtTransformVector(BILINEAR); for (i = 0; i < n; i++) { pix1 = pixaGetPix(pixas, i, L_COPY); pix2 = pixBilinear(pix1, vc, L_BRING_IN_WHITE); pix3 = pixRemoveAlpha(pix2); pixaAddPix(pixa, pix3, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); } pix1 = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 25, 2); regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 16 */ pixDisplayWithTitle(pix1, 800, 800, NULL, rp->display); pixDestroy(&pix1); pixaDestroy(&pixa); lept_free(vc); #endif pixaDestroy(&pixas); return regTestCleanup(rp); }
//--------------------------------------------------------------------------- //выстраивает все изображения по вертикали и записывает в файл //filename - имя файла для записи //fields - поля, которые необходимо совместить (через запятую0 //width - ширина до которой идёт ресайз изображения //height - высота до которой идёт ресайз изображения // примечание - задание width height меняет пропорцию изображения // если width = 0, height != 0 , то идёт пропорциональный ресайз всего изображения до height // если height = 0, width != 0 , то идёт пропорциональный ресайз всего изображения до width //proportion - флаг пропорционального ресайза изображения согласно заданным width и height // примечение // proportion!=0 пропорциональный ресайз // если компонент width=0 или height=0 то он игнорируется // width, height - устанавливают максимальное(!) значение // proportion=0 НЕпропорциональный ресайз // действует только при height!=0 и width!=0 //proportion - =0 если необходимо НЕпропорциональное уменьшение согласно заданным width и height //ImageFormat - файловый формат ("tiffG4", "tiffZIP", "png", "bmp", "jpg") //--------------------------------------------------------------------------- l_int32 LeptonicaProccesingDrawing::debugOutputImage(string filename, string fields, l_int32 width, l_int32 height, l_int32 proportion, string ImageFormat) { /*pixWriteMemBmp pixWriteStreamBmp pixWriteTiff pixWriteStreamTiff pixFillMapHoles */ PIX *pix, *pixM, *pixR; PIXA *pixa; l_int32 result; l_int32 format; l_int32 w, h; double dW, dH; LEP_LOG("enter"); SetNULL(3, (void**)&pix, &pixM, &pixa); try { pixa = pixaCreate(3); LEP_STR_THROW(!pixa, "Ошибка создания pixa"); vector<string> VN = split(fields, ','); for (unsigned int n = 0; n < VN.size(); n++) { pix = GetPixFromSTR(VN[n]); if (pix) pixaAddPix(pixa, pix, L_COPY); } pixM = pixaDisplayLinearly(pixa, L_VERT, 1, 0, 10, 8, NULL); LEP_STR_THROW(!pixM, "Ошибка создания совмещения pixa"); if ((proportion == 0) || (width == 0) || (height == 0) ) { pixR = pixScaleToSize(pixM, width, height); LEP_STR_THROW(!pixR, "Ошибка изменения размера"); } else { w = 0; h = 0; dW = pixM->w / (double)width; dH = pixM->h / (double)height; if (dW > dH) w = width; else h = height; pixR = pixScaleToSize(pixM, w, h); LEP_STR_THROW(!pixR, "Ошибка изменения размера"); } if (ImageFormat == "tiffG4") format = IFF_TIFF_G4; if (ImageFormat == "tiffZIP") format = IFF_TIFF_ZIP; if (ImageFormat == "png") format = IFF_PNG; if (ImageFormat == "bmp") format = IFF_BMP; if (ImageFormat == "jpg") format = IFF_JFIF_JPEG; result = pixWrite(filename.c_str(), pixR, format); LEP_STR_THROW(result != 0, "Ошибка создания совмещения pixa"); }catch (string error) { LEP_ERROR(error); }; pixDestroy(&pixM); pixaDestroy(&pixa); LEP_LOG("exit"); return 0; }
main(int argc, char **argv) { l_int32 w, h, success, display; l_float32 factor, scale; BOX *box; FILE *fp, *fp1; PIX *pixs, *pixt; if (regTestSetup(argc, argv, &fp, &display, &success, NULL)) return 1; factor = 0.95; /* Uncompressed PS with scaling but centered on the page */ pixs = pixRead("feyn-fract.tif"); pixGetDimensions(pixs, &w, &h, NULL); scale = L_MIN(factor * 2550 / w, factor * 3300 / h); fp1 = fopen("/tmp/psio0.ps", "wb+"); pixWriteStreamPS(fp1, pixs, NULL, 300, scale); fclose(fp1); regTestCheckFile(fp, argv, "/tmp/psio0.ps", 0, &success); pixDestroy(&pixs); /* Uncompressed PS with scaling, with LL corner at (1500, 1500) mils */ pixs = pixRead("weasel4.11c.png"); pixGetDimensions(pixs, &w, &h, NULL); scale = L_MIN(factor * 2550 / w, factor * 3300 / h); box = boxCreate(1500, 1500, (l_int32)(1000 * scale * w / 300), (l_int32)(1000 * scale * h / 300)); fp1 = fopen("/tmp/psio1.ps", "wb+"); pixWriteStreamPS(fp1, pixs, box, 300, 1.0); fclose(fp1); regTestCheckFile(fp, argv, "/tmp/psio1.ps", 1, &success); boxDestroy(&box); pixDestroy(&pixs); /* DCT compressed PS with LL corner at (300, 1000) pixels */ pixs = pixRead("marge.jpg"); pixt = pixConvertTo32(pixs); pixWrite("/tmp/psio2.jpg", pixt, IFF_JFIF_JPEG); convertJpegToPS("/tmp/psio2.jpg", "/tmp/psio3.ps", "w", 300, 1000, 0, 4.0, 1, 1); regTestCheckFile(fp, argv, "/tmp/psio2.jpg", 2, &success); regTestCheckFile(fp, argv, "/tmp/psio3.ps", 3, &success); pixDestroy(&pixt); pixDestroy(&pixs); /* For each page, apply tiff g4 image first; then jpeg or png over it */ convertTiffG4ToPS("feyn.tif", "/tmp/psio4.ps", "w", 0, 0, 0, 1.0, 1, 1, 0); convertJpegToPS("marge.jpg", "/tmp/psio4.ps", "a", 500, 100, 300, 2.0, 1, 0); convertFlateToPS("weasel4.11c.png", "/tmp/psio4.ps", "a", 300, 400, 300, 6.0, 1, 0); convertJpegToPS("marge.jpg", "/tmp/psio4.ps", "a", 100, 800, 300, 1.5, 1, 1); convertTiffG4ToPS("feyn.tif", "/tmp/psio4.ps", "a", 0, 0, 0, 1.0, 2, 1, 0); convertJpegToPS("marge.jpg", "/tmp/psio4.ps", "a", 1000, 700, 300, 2.0, 2, 0); convertJpegToPS("marge.jpg", "/tmp/psio4.ps", "a", 100, 200, 300, 2.0, 2, 1); convertTiffG4ToPS("feyn.tif", "/tmp/psio4.ps", "a", 0, 0, 0, 1.0, 3, 1, 0); convertJpegToPS("marge.jpg", "/tmp/psio4.ps", "a", 200, 200, 300, 2.0, 3, 0); convertJpegToPS("marge.jpg", "/tmp/psio4.ps", "a", 200, 900, 300, 2.0, 3, 1); regTestCheckFile(fp, argv, "/tmp/psio4.ps", 4, &success); /* Now apply jpeg first; then paint through a g4 mask. * For gv, the first image with a b.b. determines the * window size for the canvas, so we put down the largest * image first. If we had rendered a small image first, * gv and evince will not show the entire page. However, after * conversion to pdf, everything works fine, regardless of the * order in which images are placed into the PS. That is * because the pdf interpreter is robust to bad hints, ignoring * the page hints and computing the bounding box from the * set of images rendered on the page. */ pixs = pixRead("wyom.jpg"); pixt = pixScaleToSize(pixs, 2528, 3300); pixWrite("/tmp/psio5.jpg", pixt, IFF_JFIF_JPEG); pixDestroy(&pixs); pixDestroy(&pixt); convertJpegToPS("/tmp/psio5.jpg", "/tmp/psio5.ps", "w", 0, 0, 0, 1.0, 1, 0); convertFlateToPS("weasel8.240c.png", "/tmp/psio5.ps", "a", 100, 100, 300, 5.0, 1, 0); convertFlateToPS("weasel8.149g.png", "/tmp/psio5.ps", "a", 200, 300, 300, 5.0, 1, 0); convertFlateToPS("weasel4.11c.png", "/tmp/psio5.ps", "a", 300, 500, 300, 5.0, 1, 0); convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps", "a", 0, 0, 0, 1.0, 1, 1, 1); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 500, 100, 300, 2.0, 2, 0); convertFlateToPS("weasel4.11c.png", "/tmp/psio5.ps", "a", 300, 400, 300, 6.0, 2, 0); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 100, 800, 300, 1.5, 2, 0); convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps", "a", 0, 0, 0, 1.0, 2, 1, 1); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 500, 100, 300, 2.0, 3, 0); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 100, 800, 300, 2.0, 3, 0); convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps", "a", 0, 0, 0, 1.0, 3, 1, 1); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 1000, 700, 300, 2.0, 4, 0); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 100, 200, 300, 2.0, 4, 0); convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps", "a", 0, 0, 0, 1.0, 4, 1, 1); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 200, 200, 300, 2.0, 5, 0); convertJpegToPS("marge.jpg", "/tmp/psio5.ps", "a", 200, 900, 300, 2.0, 5, 0); convertTiffG4ToPS("feyn.tif", "/tmp/psio5.ps", "a", 0, 0, 0, 1.0, 5, 1, 1); regTestCheckFile(fp, argv, "/tmp/psio5.ps", 5, &success); /* Generation using segmentation masks */ convertSegmentedPagesToPS(".", "lion-page", ".", "lion-mask", 10, 0, 100, 2.0, 0.8, 190, "/tmp/psio6.ps"); regTestCheckFile(fp, argv, "/tmp/psio6.ps", 6, &success); regTestCleanup(argc, argv, fp, success, NULL); return 0; }
int main(int argc, char **argv) { l_int32 i, w, h; l_float32 factor, scale; BOX *box; FILE *fp1; PIX *pixs, *pixt; PIXA *pixa; SARRAY *sa; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; factor = 0.95; /* Uncompressed PS with scaling but centered on the page */ pixs = pixRead("feyn-fract.tif"); pixGetDimensions(pixs, &w, &h, NULL); scale = L_MIN(factor * 2550 / w, factor * 3300 / h); fp1 = lept_fopen("/tmp/regout/psio0.ps", "wb+"); pixWriteStreamPS(fp1, pixs, NULL, 300, scale); lept_fclose(fp1); regTestCheckFile(rp, "/tmp/regout/psio0.ps"); /* 0 */ pixDestroy(&pixs); /* Uncompressed PS with scaling, with LL corner at (1500, 1500) mils */ pixs = pixRead("weasel4.11c.png"); pixGetDimensions(pixs, &w, &h, NULL); scale = L_MIN(factor * 2550 / w, factor * 3300 / h); box = boxCreate(1500, 1500, (l_int32)(1000 * scale * w / 300), (l_int32)(1000 * scale * h / 300)); fp1 = lept_fopen("/tmp/regout/psio1.ps", "wb+"); pixWriteStreamPS(fp1, pixs, box, 300, 1.0); lept_fclose(fp1); regTestCheckFile(rp, "/tmp/regout/psio1.ps"); /* 1 */ boxDestroy(&box); pixDestroy(&pixs); /* DCT compressed PS with LL corner at (300, 1000) pixels */ pixs = pixRead("marge.jpg"); pixt = pixConvertTo32(pixs); pixWrite("/tmp/regout/psio2.jpg", pixt, IFF_JFIF_JPEG); convertJpegToPS("/tmp/regout/psio2.jpg", "/tmp/regout/psio3.ps", "w", 300, 1000, 0, 4.0, 1, 1); regTestCheckFile(rp, "/tmp/regout/psio2.jpg"); /* 2 */ regTestCheckFile(rp, "/tmp/regout/psio3.ps"); /* 3 */ pixDestroy(&pixt); pixDestroy(&pixs); /* For each page, apply tiff g4 image first; then jpeg or png over it */ convertG4ToPS("feyn.tif", "/tmp/regout/psio4.ps", "w", 0, 0, 0, 1.0, 1, 1, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps", "a", 500, 100, 300, 2.0, 1, 0); convertFlateToPS("weasel4.11c.png", "/tmp/regout/psio4.ps", "a", 300, 400, 300, 6.0, 1, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps", "a", 100, 800, 300, 1.5, 1, 1); convertG4ToPS("feyn.tif", "/tmp/regout/psio4.ps", "a", 0, 0, 0, 1.0, 2, 1, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps", "a", 1000, 700, 300, 2.0, 2, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps", "a", 100, 200, 300, 2.0, 2, 1); convertG4ToPS("feyn.tif", "/tmp/regout/psio4.ps", "a", 0, 0, 0, 1.0, 3, 1, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps", "a", 200, 200, 300, 2.0, 3, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio4.ps", "a", 200, 900, 300, 2.0, 3, 1); regTestCheckFile(rp, "/tmp/regout/psio4.ps"); /* 4 */ /* Now apply jpeg first; then paint through a g4 mask. * For gv, the first image with a b.b. determines the * window size for the canvas, so we put down the largest * image first. If we had rendered a small image first, * gv and evince will not show the entire page. However, after * conversion to pdf, everything works fine, regardless of the * order in which images are placed into the PS. That is * because the pdf interpreter is robust to bad hints, ignoring * the page hints and computing the bounding box from the * set of images rendered on the page. * * Concatenate several pages, with colormapped png, color * jpeg and tiffg4 images (with the g4 image acting as a mask * that we're painting black through. If the text layer * is painted first, the following images occlude it; otherwise, * the images remain in the background of the text. */ pixs = pixRead("wyom.jpg"); pixt = pixScaleToSize(pixs, 2528, 3300); pixWrite("/tmp/regout/psio5.jpg", pixt, IFF_JFIF_JPEG); pixDestroy(&pixs); pixDestroy(&pixt); convertJpegToPS("/tmp/regout/psio5.jpg", "/tmp/regout/psio5.ps", "w", 0, 0, 300, 1.0, 1, 0); convertFlateToPS("weasel8.240c.png", "/tmp/regout/psio5.ps", "a", 100, 100, 300, 5.0, 1, 0); convertFlateToPS("weasel8.149g.png", "/tmp/regout/psio5.ps", "a", 200, 300, 300, 5.0, 1, 0); convertFlateToPS("weasel4.11c.png", "/tmp/regout/psio5.ps", "a", 300, 500, 300, 5.0, 1, 0); convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps", "a", 0, 0, 0, 1.0, 1, 1, 1); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 500, 100, 300, 2.0, 2, 0); convertFlateToPS("weasel4.11c.png", "/tmp/regout/psio5.ps", "a", 300, 400, 300, 6.0, 2, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 100, 800, 300, 1.5, 2, 0); convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps", "a", 0, 0, 0, 1.0, 2, 1, 1); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 500, 100, 300, 2.0, 3, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 100, 800, 300, 2.0, 3, 0); convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps", "a", 0, 0, 0, 1.0, 3, 1, 1); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 700, 700, 300, 2.0, 4, 0); convertFlateToPS("weasel8.149g.png", "/tmp/regout/psio5.ps", "a", 400, 400, 300, 5.0, 4, 0); convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps", "a", 0, 0, 0, 1.0, 4, 1, 0); convertFlateToPS("weasel8.240c.png", "/tmp/regout/psio5.ps", "a", 100, 220, 300, 5.0, 4, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 100, 200, 300, 2.0, 4, 1); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 200, 200, 300, 1.5, 5, 0); convertFlateToPS("weasel8.240c.png", "/tmp/regout/psio5.ps", "a", 140, 80, 300, 7.0, 5, 0); convertG4ToPS("feyn.tif", "/tmp/regout/psio5.ps", "a", 0, 0, 0, 1.0, 5, 1, 0); convertFlateToPS("weasel8.149g.png", "/tmp/regout/psio5.ps", "a", 280, 310, 300, 5.0, 4, 0); convertJpegToPS("marge.jpg", "/tmp/regout/psio5.ps", "a", 200, 900, 300, 2.0, 5, 1); regTestCheckFile(rp, "/tmp/regout/psio5.ps"); /* 5 */ /* Generation using segmentation masks */ convertSegmentedPagesToPS(".", "lion-page", 10, ".", "lion-mask", 10, 0, 100, 2.0, 0.8, 190, "/tmp/regout/psio6.ps"); regTestCheckFile(rp, "/tmp/regout/psio6.ps"); /* 6 */ /* PS generation for embeddding */ convertJpegToPSEmbed("tetons.jpg", "/tmp/regout/psio7.ps"); regTestCheckFile(rp, "/tmp/regout/psio7.ps"); /* 7 */ convertG4ToPSEmbed("feyn-fract.tif", "/tmp/regout/psio8.ps"); regTestCheckFile(rp, "/tmp/regout/psio8.ps"); /* 8 */ convertFlateToPSEmbed("weasel8.240c.png", "/tmp/regout/psio9.ps"); regTestCheckFile(rp, "/tmp/regout/psio9.ps"); /* 9 */ /* Writing compressed from a pixa */ sa = sarrayCreate(0); for (i = 0; i < 11; i++) sarrayAddString(sa, WeaselNames[i], L_COPY); pixa = pixaReadFilesSA(sa); pixaWriteCompressedToPS(pixa, "/tmp/regout/psio10.ps", 0, 3); regTestCheckFile(rp, "/tmp/regout/psio10.ps"); /* 10 */ pixaDestroy(&pixa); sarrayDestroy(&sa); return regTestCleanup(rp); }
bool MakeIndividualGlyphs(Pix* pix, const std::vector<BoxChar*>& vbox, const int input_tiff_page) { // If checks fail, return false without exiting text2image if (!pix) { tprintf("ERROR: MakeIndividualGlyphs(): Input Pix* is nullptr\n"); return false; } else if (FLAGS_glyph_resized_size <= 0) { tprintf("ERROR: --glyph_resized_size must be positive\n"); return false; } else if (FLAGS_glyph_num_border_pixels_to_pad < 0) { tprintf("ERROR: --glyph_num_border_pixels_to_pad must be 0 or positive\n"); return false; } const int n_boxes = vbox.size(); int n_boxes_saved = 0; int current_tiff_page = 0; int y_previous = 0; static int glyph_count = 0; for (int i = 0; i < n_boxes; i++) { // Get one bounding box Box* b = vbox[i]->mutable_box(); if (!b) continue; const int x = b->x; const int y = b->y; const int w = b->w; const int h = b->h; // Check present tiff page (for multipage tiff) if (y < y_previous-pixGetHeight(pix)/10) { tprintf("ERROR: Wrap-around encountered, at i=%d\n", i); current_tiff_page++; } if (current_tiff_page < input_tiff_page) continue; else if (current_tiff_page > input_tiff_page) break; // Check box validity if (x < 0 || y < 0 || (x+w-1) >= pixGetWidth(pix) || (y+h-1) >= pixGetHeight(pix)) { tprintf("ERROR: MakeIndividualGlyphs(): Index out of range, at i=%d" " (x=%d, y=%d, w=%d, h=%d\n)", i, x, y, w, h); continue; } else if (w < FLAGS_glyph_num_border_pixels_to_pad && h < FLAGS_glyph_num_border_pixels_to_pad) { tprintf("ERROR: Input image too small to be a character, at i=%d\n", i); continue; } // Crop the boxed character Pix* pix_glyph = pixClipRectangle(pix, b, nullptr); if (!pix_glyph) { tprintf("ERROR: MakeIndividualGlyphs(): Failed to clip, at i=%d\n", i); continue; } // Resize to square Pix* pix_glyph_sq = pixScaleToSize(pix_glyph, FLAGS_glyph_resized_size, FLAGS_glyph_resized_size); if (!pix_glyph_sq) { tprintf("ERROR: MakeIndividualGlyphs(): Failed to resize, at i=%d\n", i); continue; } // Zero-pad Pix* pix_glyph_sq_pad = pixAddBorder(pix_glyph_sq, FLAGS_glyph_num_border_pixels_to_pad, 0); if (!pix_glyph_sq_pad) { tprintf("ERROR: MakeIndividualGlyphs(): Failed to zero-pad, at i=%d\n", i); continue; } // Write out Pix* pix_glyph_sq_pad_8 = pixConvertTo8(pix_glyph_sq_pad, false); char filename[1024]; snprintf(filename, 1024, "%s_%d.jpg", FLAGS_outputbase.c_str(), glyph_count++); if (pixWriteJpeg(filename, pix_glyph_sq_pad_8, 100, 0)) { tprintf("ERROR: MakeIndividualGlyphs(): Failed to write JPEG to %s," " at i=%d\n", filename, i); continue; } pixDestroy(&pix_glyph); pixDestroy(&pix_glyph_sq); pixDestroy(&pix_glyph_sq_pad); pixDestroy(&pix_glyph_sq_pad_8); n_boxes_saved++; y_previous = y; } if (n_boxes_saved == 0) { return false; } else { tprintf("Total number of characters saved = %d\n", n_boxes_saved); return true; } }
/* ----------------------------------------------------- */ void ProcessDigits(l_int32 index) { char rootname[8] = "digit5"; char buf[64]; l_int32 i, nc, ns, same; NUMA *na1; PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6; PIXA *pixa1, *pixa2, *pixa3; /* Read the unfiltered, unscaled pixa of twenty-five 5s */ snprintf(buf, sizeof(buf), "digits/%s.orig-25.pa", rootname); pixa1 = pixaRead(buf); /* Number and show the input images */ snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.orig-num", rootname); PixaDisplayNumbered(pixa1, buf); /* Remove some of them */ na1 = numaCreateFromString(removeset); pixaRemoveSelected(pixa1, na1); numaDestroy(&na1); snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.filt.pa", rootname); pixaWrite(buf, pixa1); /* Number and show the filtered images */ snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.filt-num", rootname); PixaDisplayNumbered(pixa1, buf); /* Extract the largest c.c., clip to the foreground, * and scale the result to a fixed size. */ nc = pixaGetCount(pixa1); pixa2 = pixaCreate(nc); for (i = 0; i < nc; i++) { pix1 = pixaGetPix(pixa1, i, L_CLONE); /* A threshold of 140 gives reasonable results */ pix2 = pixThresholdToBinary(pix1, 140); /* Join nearly touching pieces */ pix3 = pixCloseSafeBrick(NULL, pix2, 5, 5); /* Take the largest (by area) connected component */ pix4 = pixFilterComponentBySize(pix3, 0, L_SELECT_BY_AREA, 8, NULL); /* Extract the original 1 bpp pixels that have been * covered by the closing operation */ pixAnd(pix4, pix4, pix2); /* Grab the result as an image with no surrounding whitespace */ pixClipToForeground(pix4, &pix5, NULL); /* Rescale the result to the canonical size */ pix6 = pixScaleToSize(pix5, 20, 30); pixaAddPix(pixa2, pix6, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); pixDestroy(&pix5); } /* Add the index (a "5") in the text field of each pix; save pixa2 */ snprintf(buf, sizeof(buf), "%d", index); for (i = 0; i < nc; i++) { pix1 = pixaGetPix(pixa2, i, L_CLONE); pixSetText(pix1, buf); pixDestroy(&pix1); } snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.comp.pa", rootname); pixaWrite(buf, pixa2); /* Number and show the resulting binary templates */ snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.comp-num", rootname); PixaDisplayNumbered(pixa2, buf); /* Save the binary templates as a packed tiling (tiff g4). * This is the most efficient way to represent the templates. */ pix1 = pixaDisplayOnLattice(pixa2, 20, 30, NULL, NULL); pixDisplay(pix1, 1000, 500); snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.comp.tif", rootname); pixWrite(buf, pix1, IFF_TIFF_G4); /* The number of templates is in the pix text string; check it. */ pix2 = pixRead(buf); if (sscanf(pixGetText(pix2), "n = %d", &ns) != 1) fprintf(stderr, "Failed to read the number of templates!\n"); if (ns != nc) fprintf(stderr, "(stored = %d) != (actual number = %d)\n", ns, nc); /* Reconstruct the pixa of templates from the tiled compressed * image, and verify that the resulting pixa is the same. */ pixa3 = pixaMakeFromTiledPix(pix1, 20, 30, 0, 0, NULL); pixaEqual(pixa2, pixa3, 0, NULL, &same); if (!same) fprintf(stderr, "Pixa are not the same!\n"); pixDestroy(&pix1); pixDestroy(&pix2); pixaDestroy(&pixa1); pixaDestroy(&pixa2); pixaDestroy(&pixa3); }
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) { l_int32 h; l_float32 scalefactor; BOX *box; BOXA *boxa1, *boxa2; BOXAA *baa; PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; lept_rmdir("segtest"); lept_mkdir("segtest"); baa = boxaaCreate(5); /* Image region input. */ pix1 = pixRead("wet-day.jpg"); pix2 = pixScaleToSize(pix1, WIDTH, 0); pixWrite("/tmp/segtest/0.jpg", pix2, IFF_JFIF_JPEG); regTestCheckFile(rp, "/tmp/segtest/0.jpg"); /* 0 */ box = boxCreate(105, 161, 620, 872); /* image region */ boxa1 = boxaCreate(1); boxaAddBox(boxa1, box, L_INSERT); boxaaAddBoxa(baa, boxa1, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); /* Compute image region at w = 2 * WIDTH */ pix1 = pixRead("candelabrum-11.jpg"); pix2 = pixScaleToSize(pix1, WIDTH, 0); pix3 = pixConvertTo1(pix2, 100); pix4 = pixExpandBinaryPower2(pix3, 2); /* w = 2 * WIDTH */ pix5 = pixGenHalftoneMask(pix4, NULL, NULL, 1); pix6 = pixMorphSequence(pix5, "c20.1 + c1.20", 0); pix7 = pixMaskConnComp(pix6, 8, &boxa1); pix8 = pixReduceBinary2(pix7, NULL); /* back to w = WIDTH */ pix9 = pixBackgroundNormSimple(pix2, pix8, NULL); pixWrite("/tmp/segtest/1.jpg", pix9, IFF_JFIF_JPEG); regTestCheckFile(rp, "/tmp/segtest/1.jpg"); /* 1 */ boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5); /* back to w = WIDTH */ boxaaAddBoxa(baa, boxa2, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); pixDestroy(&pix5); pixDestroy(&pix6); pixDestroy(&pix7); pixDestroy(&pix8); pixDestroy(&pix9); boxaDestroy(&boxa1); /* Use mask to find image region */ pix1 = pixRead("lion-page.00016.jpg"); pix2 = pixScaleToSize(pix1, WIDTH, 0); pixWrite("/tmp/segtest/2.jpg", pix2, IFF_JFIF_JPEG); regTestCheckFile(rp, "/tmp/segtest/2.jpg"); /* 2 */ pix3 = pixRead("lion-mask.00016.tif"); pix4 = pixScaleToSize(pix3, WIDTH, 0); boxa1 = pixConnComp(pix4, NULL, 8); boxaaAddBoxa(baa, boxa1, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); /* Compute image region at full res */ pix1 = pixRead("rabi.png"); scalefactor = (l_float32)WIDTH / (l_float32)pixGetWidth(pix1); pix2 = pixScaleToGray(pix1, scalefactor); pixWrite("/tmp/segtest/3.jpg", pix2, IFF_JFIF_JPEG); regTestCheckFile(rp, "/tmp/segtest/3.jpg"); /* 3 */ pix3 = pixGenHalftoneMask(pix1, NULL, NULL, 0); pix4 = pixMorphSequence(pix3, "c20.1 + c1.20", 0); boxa1 = pixConnComp(pix4, NULL, 8); boxa2 = boxaTransform(boxa1, 0, 0, scalefactor, scalefactor); boxaaAddBoxa(baa, boxa2, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); boxaDestroy(&boxa1); /* Page with no image regions */ pix1 = pixRead("lucasta-47.jpg"); pix2 = pixScaleToSize(pix1, WIDTH, 0); boxa1 = boxaCreate(1); pixWrite("/tmp/segtest/4.jpg", pix2, IFF_JFIF_JPEG); regTestCheckFile(rp, "/tmp/segtest/4.jpg"); /* 4 */ boxaaAddBoxa(baa, boxa1, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); /* Page that is all image */ pix1 = pixRead("map1.jpg"); pix2 = pixScaleToSize(pix1, WIDTH, 0); pixWrite("/tmp/segtest/5.jpg", pix2, IFF_JFIF_JPEG); regTestCheckFile(rp, "/tmp/segtest/5.jpg"); /* 5 */ h = pixGetHeight(pix2); box = boxCreate(0, 0, WIDTH, h); boxa1 = boxaCreate(1); boxaAddBox(boxa1, box, L_INSERT); boxaaAddBoxa(baa, boxa1, L_INSERT); pixDestroy(&pix1); pixDestroy(&pix2); /* Save the boxaa file */ boxaaWrite("/tmp/segtest/seg.baa", baa); regTestCheckFile(rp, "/tmp/segtest/seg.baa"); /* 6 */ /* Do the conversion */ l_pdfSetDateAndVersion(FALSE); convertSegmentedFilesToPdf("/tmp/segtest", ".jpg", 100, L_G4_ENCODE, 140, baa, 75, 0.6, "Segmentation Test", "/tmp/pdfseg.7.pdf"); regTestCheckFile(rp, "/tmp/pdfseg.7.pdf"); /* 7 */ boxaaDestroy(&baa); return regTestCleanup(rp); }
int main(int argc, char **argv) { const char *name; l_int32 i, n; BOX *box; PIX *pix0, *pix1, *pixd; PIXA *pixa; SARRAY *sa1, *sa2, *sa3, *sa4; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; /* ---------------- Find all the jpg and tif images --------------- */ sa1 = getSortedPathnamesInDirectory(".", ".jpg", 0, 0); sa2 = getSortedPathnamesInDirectory(".", ".tif", 0, 0); sa3 = sarraySelectByRange(sa1, 0, 9); sa4 = sarraySelectByRange(sa2, 0, 9); sarrayConcatenate(sa3, sa4); n = sarrayGetCount(sa3); sarrayDestroy(&sa1); sarrayDestroy(&sa2); sarrayDestroy(&sa4); /* ---------------- Use replace to fill up a pixa -------------------*/ pixa = pixaCreate(1); pixaExtendArrayToSize(pixa, n); if ((pix0 = pixRead("marge.jpg")) == NULL) rp->success = FALSE; pix1 = pixScaleToSize(pix0, 144, 108); /* scale 0.25 */ pixDestroy(&pix0); pixaInitFull(pixa, pix1, NULL); /* fill it up */ pixd = pixaDisplayTiledInRows(pixa, 32, 1000, 1.0, 0, 25, 2); pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display); pixWrite("/tmp/regout/pix1.jpg", pixd, IFF_JFIF_JPEG); pixDestroy(&pix1); pixDestroy(&pixd); /* ---------------- And again with jpgs and tifs -------------------*/ for (i = 0; i < n; i++) { name = sarrayGetString(sa3, i, L_NOCOPY); if ((pix0 = pixRead(name)) == NULL) rp->success = FALSE; pix1 = pixScaleToSize(pix0, 144, 108); pixaReplacePix(pixa, i, pix1, NULL); pixDestroy(&pix0); } pixd = pixaDisplayTiledInRows(pixa, 32, 1000, 1.0, 0, 25, 2); pixDisplayWithTitle(pixd, 400, 100, NULL, rp->display); pixWrite("/tmp/regout/pix2.jpg", pixd, IFF_JFIF_JPEG); pixDestroy(&pixd); /* ---------------- And again, reversing the order ------------------*/ box = boxCreate(0, 0, 0, 0); pixaInitFull(pixa, NULL, box); boxDestroy(&box); for (i = 0; i < n; i++) { name = sarrayGetString(sa3, i, L_NOCOPY); if ((pix0 = pixRead(name)) == NULL) rp->success = FALSE; pix1 = pixScaleToSize(pix0, 144, 108); pixaReplacePix(pixa, n - 1 - i, pix1, NULL); pixDestroy(&pix0); } pixd = pixaDisplayTiledInRows(pixa, 32, 1000, 1.0, 0, 25, 2); pixDisplayWithTitle(pixd, 700, 100, NULL, rp->display); pixWrite("/tmp/regout/pix3.jpg", pixd, IFF_JFIF_JPEG); pixDestroy(&pixd); sarrayDestroy(&sa3); pixaDestroy(&pixa); return regTestCleanup(rp); }
int main(int argc, char **argv) { l_int32 i, spp; l_uint32 bval, wval; PIX *pixs, *pix1, *pix2, *pix3, *pixd; PIXA *pixa; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; /* Scale each image and add a white boundary */ pixa = pixaCreate(setsize); for (i = 0; i < setsize; i++) { pixs = pixRead(fnames[i]); spp = pixGetSpp(pixs); pixGetBlackOrWhiteVal(pixs, L_GET_WHITE_VAL, &wval); pixGetBlackOrWhiteVal(pixs, L_GET_BLACK_VAL, &bval); fprintf(stderr, "d = %d, spp = %d, bval = %x, wval = %x\n", pixGetDepth(pixs), spp, bval, wval); if (spp == 4) /* remove alpha, using white background */ pix1 = pixAlphaBlendUniform(pixs, wval); else pix1 = pixClone(pixs); pix2 = pixScaleToSize(pix1, 150, 150); pixGetBlackOrWhiteVal(pix2, L_GET_WHITE_VAL, &wval); pix3 = pixAddBorderGeneral(pix2, 30, 30, 20, 20, wval); pixaAddPix(pixa, pix3, L_INSERT); pixDestroy(&pixs); pixDestroy(&pix1); pixDestroy(&pix2); } pixd = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 1, 30, 0); regTestWritePixAndCheck(rp, pixd, IFF_PNG); pixDisplayWithTitle(pixd, 0, 100, NULL, rp->display); pixDestroy(&pixd); pixaDestroy(&pixa); /* Scale each image and add a black boundary */ pixa = pixaCreate(setsize); for (i = 0; i < setsize; i++) { pixs = pixRead(fnames[i]); spp = pixGetSpp(pixs); pixGetBlackOrWhiteVal(pixs, L_GET_WHITE_VAL, &wval); pixGetBlackOrWhiteVal(pixs, L_GET_BLACK_VAL, &bval); fprintf(stderr, "d = %d, spp = %d, bval = %x, wval = %x\n", pixGetDepth(pixs), spp, bval, wval); if (spp == 4) /* remove alpha, using white background */ pix1 = pixAlphaBlendUniform(pixs, wval); else pix1 = pixClone(pixs); pix2 = pixScaleToSize(pix1, 150, 150); pixGetBlackOrWhiteVal(pixs, L_GET_BLACK_VAL, &bval); pix3 = pixAddBorderGeneral(pix2, 30, 30, 20, 20, bval); pixaAddPix(pixa, pix3, L_INSERT); pixDestroy(&pixs); pixDestroy(&pix1); pixDestroy(&pix2); } pixd = pixaDisplayTiledInRows(pixa, 32, 1200, 1.0, 0, 30, 0); regTestWritePixAndCheck(rp, pixd, IFF_PNG); pixDisplayWithTitle(pixd, 1000, 100, NULL, rp->display); pixDestroy(&pixd); pixaDestroy(&pixa); return regTestCleanup(rp); }