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);
}
/*!
* pixApplyHorizDisparity()
*
* Input: dew
* pixs (1, 8 or 32 bpp)
* grayin (gray value, from 0 to 255, for pixels brought in;
* use -1 to use pixels on the boundary of pixs)
* Return: pixd (modified to remove horizontal disparity if possible),
* or null on error.
*
* Notes:
* (1) This applies the horizontal disparity array to the specified
* image.
* (2) Specify gray color for pixels brought in from the outside:
* 0 is black, 255 is white. Use -1 to select pixels from the
* boundary of the source image.
* (3) The input pixs has already been corrected for vertical disparity.
* If the horizontal disparity array doesn't exist, this returns
* a clone of @pixs.
*/
static PIX *
pixApplyHorizDisparity(L_DEWARP *dew,
PIX *pixs,
l_int32 grayin)
{
l_int32 i, j, w, h, d, fw, fh, wpls, wpld, wplf, jsrc, val8;
l_uint32 *datas, *lines, *datad, *lined;
l_float32 *dataf, *linef;
FPIX *fpix;
PIX *pixd;
PROCNAME("pixApplyHorizDisparity");
if (!dew)
return (PIX *)ERROR_PTR("dew not defined", procName, pixs);
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 1 && d != 8 && d != 32)
return (PIX *)ERROR_PTR("pix not 1, 8 or 32 bpp", procName, NULL);
if ((fpix = dew->fullhdispar) == NULL)
return (PIX *)ERROR_PTR("fullhdispar not defined", procName, NULL);
fpixGetDimensions(fpix, &fw, &fh);
if (fw < w || fh < h) {
fprintf(stderr, "fw = %d, w = %d, fh = %d, h = %d\n", fw, w, fh, h);
return (PIX *)ERROR_PTR("invalid fpix size", procName, NULL);
}
/* Two choices for requested pixels outside pixs: (1) use pixels'
* from the boundary of pixs; use white or light gray pixels. */
pixd = pixCreateTemplate(pixs);
if (grayin >= 0)
pixSetAllGray(pixd, grayin);
datas = pixGetData(pixs);
datad = pixGetData(pixd);
dataf = fpixGetData(fpix);
wpls = pixGetWpl(pixs);
wpld = pixGetWpl(pixd);
wplf = fpixGetWpl(fpix);
if (d == 1) {
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
linef = dataf + i * wplf;
for (j = 0; j < w; j++) {
jsrc = (l_int32)(j - linef[j] + 0.5);
if (grayin < 0) /* use value at boundary if outside */
jsrc = L_MIN(L_MAX(jsrc, 0), w - 1);
if (jsrc >= 0 && jsrc < w) { /* remains gray if outside */
if (GET_DATA_BIT(lines, jsrc))
SET_DATA_BIT(lined, j);
}
}
}
} else if (d == 8) {
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
linef = dataf + i * wplf;
for (j = 0; j < w; j++) {
jsrc = (l_int32)(j - linef[j] + 0.5);
if (grayin < 0)
jsrc = L_MIN(L_MAX(jsrc, 0), w - 1);
if (jsrc >= 0 && jsrc < w) {
val8 = GET_DATA_BYTE(lines, jsrc);
SET_DATA_BYTE(lined, j, val8);
}
}
}
} else { /* d == 32 */
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
linef = dataf + i * wplf;
for (j = 0; j < w; j++) {
jsrc = (l_int32)(j - linef[j] + 0.5);
if (grayin < 0)
jsrc = L_MIN(L_MAX(jsrc, 0), w - 1);
if (jsrc >= 0 && jsrc < w)
lined[j] = lines[jsrc];
}
}
}
return pixd;
}
