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 i, w, h; PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5; PIXA *pixa; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; pixa = pixaCreate(0); /* Blending on a light image */ pix1 = pixRead("fish24.jpg"); pixGetDimensions(pix1, &w, &h, NULL); for (i = 0; i < 3; i++) { pix2 = pixRead(blenders[i]); if (i == 2) { pix3 = pixScale(pix2, 0.5, 0.5); pixDestroy(&pix2); pix2 = pix3; } pix3 = pixAddAlphaToBlend(pix2, 0.3, 0); pix4 = pixMirroredTiling(pix3, w, h); pix5 = pixBlendWithGrayMask(pix1, pix4, NULL, 0, 0); pixaAddPix(pixa, pix5, L_INSERT); regTestWritePixAndCheck(rp, pix5, IFF_JFIF_JPEG); /* 0 - 2 */ pixDisplayWithTitle(pix5, 200 * i, 0, NULL, rp->display); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); } pixDestroy(&pix1); /* Blending on a dark image */ pix0 = pixRead("karen8.jpg"); pix1 = pixScale(pix0, 2.0, 2.0); pixGetDimensions(pix1, &w, &h, NULL); for (i = 0; i < 2; i++) { pix2 = pixRead(blenders[i]); pix3 = pixAddAlphaToBlend(pix2, 0.3, 1); pix4 = pixMirroredTiling(pix3, w, h); pix5 = pixBlendWithGrayMask(pix1, pix4, NULL, 0, 0); pixaAddPix(pixa, pix5, L_INSERT); regTestWritePixAndCheck(rp, pix5, IFF_JFIF_JPEG); /* 3 - 4 */ pixDisplayWithTitle(pix5, 600 + 200 * i, 0, NULL, rp->display); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); } pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0, "Blendings: blend4_reg", "/tmp/blend.pdf"); L_INFO("Output pdf: /tmp/blend.pdf\n", rp->testname); pixDestroy(&pix0); pixDestroy(&pix1); pixaDestroy(&pixa); return regTestCleanup(rp); }
main(int argc, char **argv) { l_int32 i, j, w1, h1, w2, h2, w, h, same; BOX *box1, *box2; PIX *pixs, *pixs1, *pixs2, *pix1, *pix2; PIX *pixg, *pixg1, *pixg2, *pixc2, *pixbl, *pixd; PIXA *pixa; static char mainName[] = "blend2_reg"; /* --- Set up the 8 bpp blending image --- */ pixg = pixCreate(660, 500, 8); for (i = 0; i < 500; i++) for (j = 0; j < 660; j++) pixSetPixel(pixg, j, i, (l_int32)(0.775 * j) % 256); /* --- Set up the initial color images to be blended together --- */ pixs1 = pixRead("wyom.jpg"); pixs2 = pixRead("fish24.jpg"); pixGetDimensions(pixs1, &w1, &h1, NULL); pixGetDimensions(pixs2, &w2, &h2, NULL); h = L_MIN(h1, h2); w = L_MIN(w1, w2); box1 = boxCreate(0, 0, w1, h1); box2 = boxCreate(0, 300, 660, 500); pix1 = pixClipRectangle(pixs1, box1, NULL); pix2 = pixClipRectangle(pixs2, box2, NULL); pixDestroy(&pixs1); pixDestroy(&pixs2); boxDestroy(&box1); boxDestroy(&box2); /* --- Blend 2 rgb images --- */ pixa = pixaCreate(0); pixSaveTiled(pixg, pixa, 1, 1, 40, 32); pixd = pixBlendWithGrayMask(pix1, pix2, pixg, 50, 50); pixSaveTiled(pix1, pixa, 1, 1, 40, 32); pixSaveTiled(pix2, pixa, 1, 0, 40, 32); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixd); /* --- Blend 2 grayscale images --- */ pixg1 = pixConvertRGBToLuminance(pix1); pixg2 = pixConvertRGBToLuminance(pix2); pixd = pixBlendWithGrayMask(pixg1, pixg2, pixg, 50, 50); pixSaveTiled(pixg1, pixa, 1, 1, 40, 32); pixSaveTiled(pixg2, pixa, 1, 0, 40, 32); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixg1); pixDestroy(&pixg2); pixDestroy(&pixd); /* --- Blend a colormap image and an rgb image --- */ pixc2 = pixFixedOctcubeQuantGenRGB(pix2, 2); pixd = pixBlendWithGrayMask(pix1, pixc2, pixg, 50, 50); pixSaveTiled(pix1, pixa, 1, 1, 40, 32); pixSaveTiled(pixc2, pixa, 1, 0, 40, 32); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixc2); pixDestroy(&pixd); /* --- Blend a colormap image and a grayscale image --- */ pixg1 = pixConvertRGBToLuminance(pix1); pixc2 = pixFixedOctcubeQuantGenRGB(pix2, 2); pixd = pixBlendWithGrayMask(pixg1, pixc2, pixg, 50, 50); pixSaveTiled(pixg1, pixa, 1, 1, 40, 32); pixSaveTiled(pixc2, pixa, 1, 0, 40, 32); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixd); pixd = pixBlendWithGrayMask(pixg1, pixc2, pixg, -100, -100); pixSaveTiled(pixg1, pixa, 1, 1, 40, 32); pixSaveTiled(pixc2, pixa, 1, 0, 40, 32); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixd); pixDestroy(&pixg1); pixDestroy(&pixc2); /* --- Test png read/write with alpha channel --- */ /* First make pixs1, using pixg as the alpha channel */ pixs = pixRead("fish24.jpg"); box1 = boxCreate(0, 300, 660, 500); pixs1 = pixClipRectangle(pixs, box1, NULL); pixSaveTiled(pixs1, pixa, 1, 1, 40, 32); pixSetRGBComponent(pixs1, pixg, L_ALPHA_CHANNEL); /* To see the alpha channel, blend with a black image */ pixbl = pixCreate(660, 500, 32); pixd = pixBlendWithGrayMask(pixbl, pixs1, NULL, 0, 0); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixd); /* Write out the RGBA image and read it back */ l_pngSetWriteAlpha(1); pixWrite("/tmp/junkpixs1.png", pixs1, IFF_PNG); l_pngSetStripAlpha(0); pixs2 = pixRead("/tmp/junkpixs1.png"); /* Make sure that the alpha channel image hasn't changed */ pixg2 = pixGetRGBComponent(pixs2, L_ALPHA_CHANNEL); pixEqual(pixg, pixg2, &same); if (same) fprintf(stderr, "PNG with alpha read/write OK\n"); else fprintf(stderr, "PNG with alpha read/write failed\n"); /* Blend again with a black image */ pixd = pixBlendWithGrayMask(pixbl, pixs2, NULL, 0, 0); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixd); /* Blend with a white image */ pixSetAll(pixbl); pixd = pixBlendWithGrayMask(pixbl, pixs2, NULL, 0, 0); pixSaveTiled(pixd, pixa, 1, 0, 40, 32); pixDestroy(&pixd); l_pngSetWriteAlpha(0); /* reset to default */ l_pngSetStripAlpha(1); /* reset to default */ pixDestroy(&pixbl); pixDestroy(&pixs); pixDestroy(&pixs1); pixDestroy(&pixs2); pixDestroy(&pixg2); boxDestroy(&box1); /* --- Display results --- */ pixd = pixaDisplay(pixa, 0, 0); pixDisplay(pixd, 100, 100); pixWrite("/tmp/junkblend2.jpg", pixd, IFF_JFIF_JPEG); pixDestroy(&pixd); pixaDestroy(&pixa); pixDestroy(&pixg); pixDestroy(&pix1); pixDestroy(&pix2); return 0; }
int main(int argc, char **argv) { PIX *pixs2, *pixs3, *pixb1, *pixb2, *pixb3; PIX *pixr2, *pixr3; PIX *pixc1, *pixc2, *pixc3, *pixcs1, *pixcs2, *pixcs3; PIX *pixd, *pixt1, *pixt2, *pixt3; PTA *ptas1, *ptas2, *ptas3, *ptad1, *ptad2, *ptad3; L_REGPARAMS *rp; if (regTestSetup(argc, argv, &rp)) return 1; pixc1 = pixRead("test24.jpg"); pixc2 = pixRead("wyom.jpg"); pixc3 = pixRead("marge.jpg"); /* Test alpha blend scaling */ pixd = pixCreate(900, 400, 32); pixSetAll(pixd); pixs2 = pixScaleWithAlpha(pixc2, 0.5, 0.5, NULL, 0.3); pixs3 = pixScaleWithAlpha(pixc3, 0.4, 0.4, NULL, 0.7); pixb1 = pixBlendWithGrayMask(pixd, pixs3, NULL, 100, 100); pixb2 = pixBlendWithGrayMask(pixb1, pixs2, NULL, 300, 130); pixb3 = pixBlendWithGrayMask(pixb2, pixs3, NULL, 600, 160); regTestWritePixAndCheck(rp, pixb3, IFF_PNG); /* 0 */ pixDisplayWithTitle(pixb3, 900, 100, NULL, rp->display); pixDestroy(&pixd); pixDestroy(&pixs2); pixDestroy(&pixs3); pixDestroy(&pixb1); pixDestroy(&pixb2); pixDestroy(&pixb3); /* Test alpha blend rotation */ pixd = pixCreate(1200, 800, 32); pixSetAll(pixd); pixr3 = pixRotateWithAlpha(pixc3, -0.3, NULL, 1.0); pixr2 = pixRotateWithAlpha(pixc2, +0.3, NULL, 1.0); pixb3 = pixBlendWithGrayMask(pixd, pixr3, NULL, 100, 100); pixb2 = pixBlendWithGrayMask(pixb3, pixr2, NULL, 400, 100); regTestWritePixAndCheck(rp, pixb2, IFF_PNG); /* 1 */ pixDisplayWithTitle(pixb2, 500, 100, NULL, rp->display); pixDestroy(&pixd); pixDestroy(&pixr3); pixDestroy(&pixr2); pixDestroy(&pixb3); pixDestroy(&pixb2); pixcs1 = pixScale(pixc1, 0.35, 0.35); pixcs2 = pixScale(pixc2, 0.55, 0.55); pixcs3 = pixScale(pixc3, 0.65, 0.65); /* Test alpha blend affine */ pixd = pixCreate(800, 900, 32); pixSetAll(pixd); MakePtas(2, 3, &ptas1, &ptad1); MakePtas(4, 3, &ptas2, &ptad2); MakePtas(3, 3, &ptas3, &ptad3); pixt1 = pixAffinePtaWithAlpha(pixcs1, ptad1, ptas1, NULL, 1.0, 300); pixt2 = pixAffinePtaWithAlpha(pixcs2, ptad2, ptas2, NULL, 0.8, 400); pixt3 = pixAffinePtaWithAlpha(pixcs3, ptad3, ptas3, NULL, 0.7, 300); pixb1 = pixBlendWithGrayMask(pixd, pixt1, NULL, -250, 20); pixb2 = pixBlendWithGrayMask(pixb1, pixt2, NULL, -150, -250); pixb3 = pixBlendWithGrayMask(pixb2, pixt3, NULL, -100, 220); regTestWritePixAndCheck(rp, pixb3, IFF_PNG); /* 2 */ pixDisplayWithTitle(pixb3, 100, 100, NULL, rp->display); pixDestroy(&pixd); pixDestroy(&pixb1); pixDestroy(&pixb2); pixDestroy(&pixb3); pixDestroy(&pixt1); pixDestroy(&pixt2); pixDestroy(&pixt3); ptaDestroy(&ptas1); ptaDestroy(&ptas2); ptaDestroy(&ptas3); ptaDestroy(&ptad1); ptaDestroy(&ptad2); ptaDestroy(&ptad3); /* Test alpha blend projective */ pixd = pixCreate(900, 900, 32); pixSetAll(pixd); MakePtas(2, 4, &ptas1, &ptad1); MakePtas(4, 4, &ptas2, &ptad2); MakePtas(3, 4, &ptas3, &ptad3); pixt1 = pixProjectivePtaWithAlpha(pixcs1, ptad1, ptas1, NULL, 1.0, 300); pixt2 = pixProjectivePtaWithAlpha(pixcs2, ptad2, ptas2, NULL, 0.8, 400); pixt3 = pixProjectivePtaWithAlpha(pixcs3, ptad3, ptas3, NULL, 0.7, 400); pixb1 = pixBlendWithGrayMask(pixd, pixt1, NULL, -150, 20); pixb2 = pixBlendWithGrayMask(pixb1, pixt2, NULL, -50, -250); pixb3 = pixBlendWithGrayMask(pixb2, pixt3, NULL, -100, 220); regTestWritePixAndCheck(rp, pixb3, IFF_PNG); /* 3 */ pixDisplayWithTitle(pixb3, 300, 100, NULL, rp->display); pixDestroy(&pixd); pixDestroy(&pixb1); pixDestroy(&pixb2); pixDestroy(&pixb3); pixDestroy(&pixt1); pixDestroy(&pixt2); pixDestroy(&pixt3); ptaDestroy(&ptas1); ptaDestroy(&ptas2); ptaDestroy(&ptas3); ptaDestroy(&ptad1); ptaDestroy(&ptad2); ptaDestroy(&ptad3); /* Test alpha blend bilinear */ pixd = pixCreate(900, 900, 32); pixSetAll(pixd); MakePtas(2, 4, &ptas1, &ptad1); MakePtas(4, 4, &ptas2, &ptad2); MakePtas(3, 4, &ptas3, &ptad3); pixt1 = pixBilinearPtaWithAlpha(pixcs1, ptad1, ptas1, NULL, 1.0, 300); pixt2 = pixBilinearPtaWithAlpha(pixcs2, ptad2, ptas2, NULL, 0.8, 400); pixt3 = pixBilinearPtaWithAlpha(pixcs3, ptad3, ptas3, NULL, 0.7, 400); pixb1 = pixBlendWithGrayMask(pixd, pixt1, NULL, -150, 20); pixb2 = pixBlendWithGrayMask(pixb1, pixt2, NULL, -50, -250); pixb3 = pixBlendWithGrayMask(pixb2, pixt3, NULL, -100, 220); regTestWritePixAndCheck(rp, pixb3, IFF_PNG); /* 4 */ pixDisplayWithTitle(pixb3, 500, 100, NULL, rp->display); pixDestroy(&pixd); pixDestroy(&pixb1); pixDestroy(&pixb2); pixDestroy(&pixb3); pixDestroy(&pixt1); pixDestroy(&pixt2); pixDestroy(&pixt3); ptaDestroy(&ptas1); ptaDestroy(&ptas2); ptaDestroy(&ptas3); ptaDestroy(&ptad1); ptaDestroy(&ptad2); ptaDestroy(&ptad3); pixDestroy(&pixc1); pixDestroy(&pixc2); pixDestroy(&pixc3); pixDestroy(&pixcs1); pixDestroy(&pixcs2); pixDestroy(&pixcs3); return regTestCleanup(rp); }