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);
}
int main(int argc,
char **argv) {
l_int32 i, w, h, d, rotflag;
PIX *pixs, *pixt, *pixd;
l_float32 angle, deg2rad, pops, ang;
char *filein, *fileout;
static char mainName[] = "rotatetest1";
if (argc != 4)
return ERROR_INT(" Syntax: rotatetest1 filein angle fileout",
mainName, 1);
filein = argv[1];
angle = atof(argv[2]);
fileout = argv[3];
deg2rad = 3.1415926535 / 180.;
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pix not made", mainName, 1);
if (pixGetDepth(pixs) == 1) {
pixt = pixScaleToGray3(pixs);
pixDestroy(&pixs);
pixs = pixAddBorderGeneral(pixt, 1, 0, 1, 0, 255);
pixDestroy(&pixt);
}
pixGetDimensions(pixs, &w, &h, &d);
fprintf(stderr, "w = %d, h = %d\n", w, h);
#if 0
/* repertory of rotation operations to choose from */
pixd = pixRotateAM(pixs, deg2rad * angle, L_BRING_IN_WHITE);
pixd = pixRotateAMColor(pixs, deg2rad * angle, 0xffffff00);
pixd = pixRotateAMColorFast(pixs, deg2rad * angle, 255);
pixd = pixRotateAMCorner(pixs, deg2rad * angle, L_BRING_IN_WHITE);
pixd = pixRotateShear(pixs, w /2, h / 2, deg2rad * angle,
L_BRING_IN_WHITE);
pixd = pixRotate3Shear(pixs, w /2, h / 2, deg2rad * angle,
L_BRING_IN_WHITE);
pixRotateShearIP(pixs, w / 2, h / 2, deg2rad * angle); pixd = pixs;
#endif
#if 0
/* timing of shear rotation */
for (i = 0; i < NITERS; i++) {
pixd = pixRotateShear(pixs, (i * w) / NITERS,
(i * h) / NITERS, deg2rad * angle,
L_BRING_IN_WHITE);
pixDisplay(pixd, 100 + 20 * i, 100 + 20 * i);
pixDestroy(&pixd);
}
#endif
#if 0
/* timing of in-place shear rotation */
for (i = 0; i < NITERS; i++) {
pixRotateShearIP(pixs, w/2, h/2, deg2rad * angle, L_BRING_IN_WHITE);
/* pixRotateShearCenterIP(pixs, deg2rad * angle, L_BRING_IN_WHITE); */
pixDisplay(pixs, 100 + 20 * i, 100 + 20 * i);
}
pixd = pixs;
if (pixGetDepth(pixd) == 1)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixs);
#endif
#if 0
/* timing of various rotation operations (choose) */
startTimer();
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
for (i = 0; i < NTIMES; i++) {
pixd = pixRotateShearCenter(pixs, deg2rad * angle, L_BRING_IN_WHITE);
pixDestroy(&pixd);
}
pops = (l_float32)(w * h * NTIMES / 1000000.) / stopTimer();
fprintf(stderr, "vers. 1, mpops: %f\n", pops);
startTimer();
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
for (i = 0; i < NTIMES; i++) {
pixRotateShearIP(pixs, w/2, h/2, deg2rad * angle, L_BRING_IN_WHITE);
}
pops = (l_float32)(w * h * NTIMES / 1000000.) / stopTimer();
fprintf(stderr, "shear, mpops: %f\n", pops);
pixWrite(fileout, pixs, IFF_PNG);
for (i = 0; i < NTIMES; i++) {
pixRotateShearIP(pixs, w/2, h/2, -deg2rad * angle, L_BRING_IN_WHITE);
}
pixWrite("/usr/tmp/junkout", pixs, IFF_PNG);
#endif
#if 0
/* area-mapping rotation operations */
pixd = pixRotateAM(pixs, deg2rad * angle, L_BRING_IN_WHITE);
/* pixd = pixRotateAMColorFast(pixs, deg2rad * angle, 255); */
if (pixGetDepth(pixd) == 1)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
#endif
#if 0
/* compare the standard area-map color rotation with
* the fast area-map color rotation, on a pixel basis */
{
PIX *pix1, *pix2;
NUMA *nar, *nag, *nab, *naseq;
GPLOT *gplot;
startTimer();
pix1 = pixRotateAMColor(pixs, 0.12, 0xffffff00);
fprintf(stderr, " standard color rotate: %7.2f sec\n", stopTimer());
pixWrite("junkcolor1", pix1, IFF_JFIF_JPEG);
startTimer();
pix2 = pixRotateAMColorFast(pixs, 0.12, 0xffffff00);
fprintf(stderr, " fast color rotate: %7.2f sec\n", stopTimer());
pixWrite("junkcolor2", pix2, IFF_JFIF_JPEG);
pixd = pixAbsDifference(pix1, pix2);
pixGetColorHistogram(pixd, 1, &nar, &nag, &nab);
naseq = numaMakeSequence(0., 1., 256);
gplot = gplotCreate("junk_absdiff", GPLOT_X11, "Number vs diff",
"diff", "number");
gplotAddPlot(gplot, naseq, nar, GPLOT_POINTS, "red");
gplotAddPlot(gplot, naseq, nag, GPLOT_POINTS, "green");
gplotAddPlot(gplot, naseq, nab, GPLOT_POINTS, "blue");
gplotMakeOutput(gplot);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pixd);
numaDestroy(&nar);
numaDestroy(&nag);
numaDestroy(&nab);
numaDestroy(&naseq);
gplotDestroy(&gplot);
}
#endif
/* Do a succession of 180 7-degree rotations in a cw
* direction, and unwind the result with another set in
* a ccw direction. Although there is a considerable amount
* of distortion after successive rotations, after all
* 360 rotations, the resulting image is restored to
* its original pristine condition! */
#if 1
rotflag = L_ROTATE_AREA_MAP;
/* rotflag = L_ROTATE_SHEAR; */
/* rotflag = L_ROTATE_SAMPLING; */
ang = 7.0 * deg2rad;
pixGetDimensions(pixs, &w, &h, NULL);
pixd = pixRotate(pixs, ang, rotflag, L_BRING_IN_WHITE, w, h);
pixWrite("junkrot7", pixd, IFF_PNG);
for (i = 1; i < 180; i++) {
pixs = pixd;
pixd = pixRotate(pixs, ang, rotflag, L_BRING_IN_WHITE, w, h);
if ((i % 30) == 0) pixDisplay(pixd, 600, 0);
pixDestroy(&pixs);
}
pixWrite("junkspin", pixd, IFF_PNG);
pixDisplay(pixd, 0, 0);
for (i = 0; i < 180; i++) {
pixs = pixd;
pixd = pixRotate(pixs, -ang, rotflag, L_BRING_IN_WHITE, w, h);
if (i && (i % 30) == 0) pixDisplay(pixd, 600, 500);
pixDestroy(&pixs);
}
pixWrite("junkunspin", pixd, IFF_PNG);
pixDisplay(pixd, 0, 500);
pixDestroy(&pixd);
#endif
return 0;
}
static void
RotateTest(PIX *pixs,
l_float32 scale,
L_REGPARAMS *rp)
{
l_int32 w, h, d, i, outformat;
PIX *pixt, *pixd;
PIXA *pixa;
pixa = pixaCreate(0);
pixGetDimensions(pixs, &w, &h, &d);
outformat = (d == 8 || d == 32) ? IFF_JFIF_JPEG : IFF_PNG;
pixd = pixRotate(pixs, ANGLE1, L_ROTATE_SHEAR, L_BRING_IN_WHITE, w, h);
for (i = 1; i < NTIMES; i++) {
if ((i % MODSIZE) == 0) {
if (i == MODSIZE) {
pixSaveTiled(pixd, pixa, scale, 1, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
} else {
pixSaveTiled(pixd, pixa, scale, 0, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
}
}
pixt = pixRotate(pixd, ANGLE1, L_ROTATE_SHEAR,
L_BRING_IN_WHITE, w, h);
pixDestroy(&pixd);
pixd = pixt;
}
pixDestroy(&pixd);
pixd = pixRotate(pixs, ANGLE1, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, w, h);
for (i = 1; i < NTIMES; i++) {
if ((i % MODSIZE) == 0) {
if (i == MODSIZE) {
pixSaveTiled(pixd, pixa, scale, 1, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
} else {
pixSaveTiled(pixd, pixa, scale, 0, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
}
}
pixt = pixRotate(pixd, ANGLE1, L_ROTATE_SAMPLING,
L_BRING_IN_WHITE, w, h);
pixDestroy(&pixd);
pixd = pixt;
}
pixDestroy(&pixd);
pixd = pixRotate(pixs, ANGLE1, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, w, h);
for (i = 1; i < NTIMES; i++) {
if ((i % MODSIZE) == 0) {
if (i == MODSIZE) {
pixSaveTiled(pixd, pixa, scale, 1, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
} else {
pixSaveTiled(pixd, pixa, scale, 0, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
}
}
pixt = pixRotate(pixd, ANGLE1, L_ROTATE_AREA_MAP,
L_BRING_IN_WHITE, w, h);
pixDestroy(&pixd);
pixd = pixt;
}
pixDestroy(&pixd);
pixd = pixRotateAMCorner(pixs, ANGLE2, L_BRING_IN_WHITE);
for (i = 1; i < NTIMES; i++) {
if ((i % MODSIZE) == 0) {
if (i == MODSIZE) {
pixSaveTiled(pixd, pixa, scale, 1, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
} else {
pixSaveTiled(pixd, pixa, scale, 0, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
}
}
pixt = pixRotateAMCorner(pixd, ANGLE2, L_BRING_IN_WHITE);
pixDestroy(&pixd);
pixd = pixt;
}
pixDestroy(&pixd);
if (d == 32) {
pixd = pixRotateAMColorFast(pixs, ANGLE1, 0xb0ffb000);
for (i = 1; i < NTIMES; i++) {
if ((i % MODSIZE) == 0) {
if (i == MODSIZE) {
pixSaveTiled(pixd, pixa, scale, 1, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
} else {
pixSaveTiled(pixd, pixa, scale, 0, 20, 32);
regTestWritePixAndCheck(rp, pixd, outformat);
}
}
pixt = pixRotateAMColorFast(pixd, ANGLE1, 0xb0ffb000);
pixDestroy(&pixd);
pixd = pixt;
}
}
pixDestroy(&pixd);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return;
}
main(int argc,
char **argv)
{
l_int32 i;
l_float32 pi, scale, angle;
PIX *pixc, *pixm, *pix1, *pix2, *pix3;
PIXA *pixa;
PTA *pta1, *pta2, *pta3, *pta4;
static char mainName[] = "smallpix_reg";
/* Make a small test image, the hard way! */
pi = 3.1415926535;
pixc = pixCreate(9, 9, 32);
pixm = pixCreate(9, 9, 1);
pta1 = generatePtaLineFromPt(4, 4, 3.1, 0.0);
pta2 = generatePtaLineFromPt(4, 4, 3.1, 0.5 * pi);
pta3 = generatePtaLineFromPt(4, 4, 3.1, pi);
pta4 = generatePtaLineFromPt(4, 4, 3.1, 1.5 * pi);
ptaJoin(pta1, pta2, 0, 0);
ptaJoin(pta1, pta3, 0, 0);
ptaJoin(pta1, pta4, 0, 0);
pixRenderPta(pixm, pta1, L_SET_PIXELS);
pixPaintThroughMask(pixc, pixm, 0, 0, 0x00ff0000);
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
ptaDestroy(&pta4);
pixDestroy(&pixm);
/* Results differ for scaleSmoothLow() w/ and w/out + 0.5.
* Neither is properly symmetric (with symm pattern on odd-sized
* pix, because the smoothing is destroying the symmetry. */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 2);
for (i = 0; i < 11; i++) {
scale = 0.30 + 0.035 * (l_float32)i;
pix2 = pixScaleSmooth(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 6);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 100, NULL);
/* Results same for pixScaleAreaMap w/ and w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 2);
for (i = 0; i < 11; i++) {
scale = 0.30 + 0.035 * (l_float32)i;
pix2 = pixScaleAreaMap(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 6);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 200, NULL);
/* Results better for pixScaleBySampling with + 0.5, for small,
* odd-dimension pix. */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 2);
for (i = 0; i < 11; i++) {
scale = 0.30 + 0.035 * (l_float32)i;
pix2 = pixScaleBySampling(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 6);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 300, NULL);
/* Results same for pixRotateAM w/ and w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateAM(pix1, angle, L_BRING_IN_BLACK);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 400, NULL);
/* If the size is odd, we express the center exactly, and the
* results are better for pixRotateBySampling() w/out 0.5
* However, if the size is even, the center value is not
* exact, and if we choose it 0.5 smaller than the actual
* center, we get symmetrical results with +0.5.
* So we choose not to include + 0.5. */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateBySampling(pix1, 4, 4, angle, L_BRING_IN_BLACK);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 500, NULL);
/* Results same for pixRotateAMCorner w/ and w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateAMCorner(pix1, angle, L_BRING_IN_BLACK);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 600, NULL);
/* Results better for pixRotateAMColorFast without + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateAMColorFast(pix1, angle, 0);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 700, NULL);
/* Results slightly better for pixScaleColorLI() w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
scale = 1.0 + 0.2 * (l_float32)i;
pix2 = pixScaleColorLI(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 4);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 800, NULL);
/* Results slightly better for pixScaleColorLI() w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
scale = 1.0 + 0.2 * (l_float32)i;
pix2 = pixScaleLI(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 4);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 940, NULL);
pixDestroy(&pixc);
return 0;
}
