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);
}