/*!
* wshedRenderColors()
*
* Input: wshed
* Return: pixd (initial image with all basins filled), or null on error
*/
PIX *
wshedRenderColors(L_WSHED *wshed) {
l_int32 w, h;
PIX *pixg, *pixt, *pixc, *pixm, *pixd;
PIXA *pixa;
PROCNAME("wshedRenderColors");
if (!wshed)
return (PIX *) ERROR_PTR("wshed not defined", procName, NULL);
wshedBasins(wshed, &pixa, NULL);
pixg = pixCopy(NULL, wshed->pixs);
pixGetDimensions(wshed->pixs, &w, &h, NULL);
pixd = pixConvertTo32(pixg);
pixt = pixaDisplayRandomCmap(pixa, w, h);
pixc = pixConvertTo32(pixt);
pixm = pixaDisplay(pixa, w, h);
pixCombineMasked(pixd, pixc, pixm);
pixDestroy(&pixg);
pixDestroy(&pixt);
pixDestroy(&pixc);
pixDestroy(&pixm);
pixaDestroy(&pixa);
return pixd;
}
main(int argc,
char **argv)
{
l_int32 i;
PIX *pix;
PIXA *pixa;
for (i = 0; i < NTests; i++)
GenerateSplitPlot(i);
/* Read the results back in ... */
pixa = pixaCreate(0);
for (i = 0; i < NTests; i++) {
sprintf(buf, "/tmp/junkplot.%d.png", i);
pix = pixRead(buf);
pixSaveTiled(pix, pixa, 1, 1, 25, 32);
pixDestroy(&pix);
sprintf(buf, "/tmp/junkplots.%d.png", i);
pix = pixRead(buf);
pixSaveTiled(pix, pixa, 1, 0, 25, 32);
pixDestroy(&pix);
}
/* ... and save into a tiled pix */
pix = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkotsuplot.png", pix, IFF_PNG);
pixDisplay(pix, 100, 100);
pixaDestroy(&pixa);
pixDestroy(&pix);
return 0;
}
int main(int argc,
char **argv)
{
PIX *pixs, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("stampede2.jpg");
pixa = pixaCreate(0);
pixSaveTiled(pixs, pixa, 1.0, 1, 20, 8);
AddTestSet(pixa, pixs, L_SOBEL_EDGE, 18, 40, 40, 0.7, -25, 280, 128);
AddTestSet(pixa, pixs, L_TWO_SIDED_EDGE, 18, 40, 40, 0.7, -25, 280, 128);
AddTestSet(pixa, pixs, L_SOBEL_EDGE, 10, 40, 40, 0.7, -15, 305, 128);
AddTestSet(pixa, pixs, L_TWO_SIDED_EDGE, 10, 40, 40, 0.7, -15, 305, 128);
AddTestSet(pixa, pixs, L_SOBEL_EDGE, 15, 40, 40, 0.6, -45, 285, 158);
AddTestSet(pixa, pixs, L_TWO_SIDED_EDGE, 15, 40, 40, 0.6, -45, 285, 158);
pixDestroy(&pixs);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 0 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
/*!
* pixSelectByWidthHeightRatio()
*
* Input: pixs (1 bpp)
* thresh (threshold ratio of width/height)
* connectivity (4 or 8)
* type (L_SELECT_IF_LT, L_SELECT_IF_GT,
* L_SELECT_IF_LTE, L_SELECT_IF_GTE)
* &changed (<optional return> 1 if changed; 0 if clone returned)
* Return: pixd, or null on error
*
* Notes:
* (1) The args specify constraints on the width-to-height ratio
* for components that are kept.
* (2) If unchanged, returns a copy of pixs. Otherwise,
* returns a new pix with the filtered components.
* (3) This filters components based on the width-to-height ratios.
* (4) Use L_SELECT_IF_LT or L_SELECT_IF_LTE to save components
* with less than the threshold ratio, and
* L_SELECT_IF_GT or L_SELECT_IF_GTE to remove them.
*/
PIX *
pixSelectByWidthHeightRatio(PIX *pixs,
l_float32 thresh,
l_int32 connectivity,
l_int32 type,
l_int32 *pchanged)
{
l_int32 w, h, empty, changed, count;
BOXA *boxa;
PIX *pixd;
PIXA *pixas, *pixad;
PROCNAME("pixSelectByWidthHeightRatio");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (connectivity != 4 && connectivity != 8)
return (PIX *)ERROR_PTR("connectivity not 4 or 8", procName, NULL);
if (type != L_SELECT_IF_LT && type != L_SELECT_IF_GT &&
type != L_SELECT_IF_LTE && type != L_SELECT_IF_GTE)
return (PIX *)ERROR_PTR("invalid type", procName, NULL);
if (pchanged) *pchanged = FALSE;
/* Check if any components exist */
pixZero(pixs, &empty);
if (empty)
return pixCopy(NULL, pixs);
/* Filter components */
boxa = pixConnComp(pixs, &pixas, connectivity);
pixad = pixaSelectByWidthHeightRatio(pixas, thresh, type, &changed);
boxaDestroy(&boxa);
pixaDestroy(&pixas);
/* Render the result */
if (!changed) {
pixaDestroy(&pixad);
return pixCopy(NULL, pixs);
}
else {
if (pchanged) *pchanged = TRUE;
pixGetDimensions(pixs, &w, &h, NULL);
count = pixaGetCount(pixad);
if (count == 0) /* return empty pix */
pixd = pixCreateTemplate(pixs);
else {
pixd = pixaDisplay(pixad, w, h);
pixCopyResolution(pixd, pixs);
pixCopyColormap(pixd, pixs);
pixCopyText(pixd, pixs);
pixCopyInputFormat(pixd, pixs);
}
pixaDestroy(&pixad);
return pixd;
}
}
void DisplayPix(PIXA **ppixa, l_int32 x, l_int32 y, char *fname)
{
PIX *pixt;
pixt = pixaDisplay(*ppixa, 0, 0);
if (fname)
pixWrite(fname, pixt, IFF_PNG);
pixDisplay(pixt, x, y);
pixDestroy(&pixt);
pixaDestroy(ppixa);
}
static void
PixaSaveDisplay(PIXA *pixa, L_REGPARAMS *rp)
{
PIX *pixd;
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return;
}
static void
DisplayResult(PIXA *pixac,
PIXA **ppixa,
l_int32 w,
l_int32 h,
l_int32 newline)
{
PIX *pixd;
pixd = pixaDisplay(*ppixa, w, h);
pixSaveTiled(pixd, pixac, 1, newline, 30, 8);
pixDestroy(&pixd);
pixaDestroy(ppixa);
return;
}
main(int argc,
char **argv)
{
char buf[256];
l_int32 i, j, k, index, conn, depth, bc;
BOX *box;
PIX *pix, *pixs, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pix = pixRead("feyn.tif");
box = boxCreate(383, 338, 1480, 1050);
pixs = pixClipRectangle(pix, box, NULL);
regTestWritePixAndCheck(rp, pixs, IFF_PNG); /* 0 */
for (i = 0; i < 2; i++) {
conn = 4 + 4 * i;
for (j = 0; j < 2; j++) {
depth = 8 + 8 * j;
for (k = 0; k < 2; k++) {
bc = k + 1;
index = 4 * i + 2 * j + k;
fprintf(stderr, "Set %d\n", index);
if (DEBUG) {
fprintf(stderr, "%d: conn = %d, depth = %d, bc = %d\n",
rp->index + 1, conn, depth, bc);
}
pixa = pixaCreate(0);
pixSaveTiled(pixs, pixa, 1, 1, 20, 8);
TestDistance(pixa, pixs, conn, depth, bc, rp);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 0, 0, NULL, rp->display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
}
}
}
boxDestroy(&box);
pixDestroy(&pix);
pixDestroy(&pixs);
regTestCleanup(rp);
return 0;
}
PIX *
PixTest1(PIX *pixs,
l_int32 size,
l_float32 factor,
L_REGPARAMS *rp)
{
l_int32 w, h;
PIX *pixm, *pixsd, *pixth, *pixd, *pixt;
PIXA *pixa;
pixm = pixsd = pixth = pixd = NULL;
pixGetDimensions(pixs, &w, &h, NULL);
/* Get speed */
startTimer();
pixSauvolaBinarize(pixs, size, factor, 1, NULL, NULL, NULL, &pixd);
fprintf(stderr, "\nSpeed: 1 tile, %7.3f Mpix/sec\n",
(w * h / 1000000.) / stopTimer());
pixDestroy(&pixd);
/* Get results */
pixSauvolaBinarize(pixs, size, factor, 1, &pixm, &pixsd, &pixth, &pixd);
pixa = pixaCreate(0);
pixSaveTiled(pixm, pixa, 1, 1, 30, 8);
pixSaveTiled(pixsd, pixa, 1, 0, 30, 8);
pixSaveTiled(pixth, pixa, 1, 1, 30, 8);
pixSaveTiled(pixd, pixa, 1, 0, 30, 8);
pixt = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG);
if (rp->index < 5)
pixDisplayWithTitle(pixt, 100, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixaDestroy(&pixa);
pixDestroy(&pixm);
pixDestroy(&pixsd);
pixDestroy(&pixth);
pixDestroy(&pixt);
return pixd;
}
int main(int argc,
char **argv)
{
char namebuf[256];
l_int32 i, j, k, maxdist, maxcolors, selsize, finalcolors;
PIX *pixs, *pixt, *pixd;
PIXA *pixa;
static char mainName[] = "colorseg_reg";
if (argc != 1)
return ERROR_INT("Syntax: colorseg_reg", mainName, 1);
pixs = pixRead("tetons.jpg");
for (k = 0; k < 3; k++) {
maxcolors = MaxColors[k];
finalcolors = FinalColors[k];
pixa = pixaCreate(0);
pixSaveTiled(pixs, pixa, 1.0, 1, 15, 32);
for (i = 1; i <= 9; i++) {
maxdist = 20 * i;
for (j = 0; j <= 6; j++) {
selsize = j;
pixt = pixColorSegment(pixs, maxdist, maxcolors, selsize,
finalcolors);
pixSaveTiled(pixt, pixa, 1.0, j == 0 ? 1 : 0, 15, 32);
pixDestroy(&pixt);
}
}
pixd = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd, 100, 100);
sprintf(namebuf, "/tmp/junkcolorseg%d.jpg", k);
pixWrite(namebuf, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
}
pixDestroy(&pixs);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, n, w, h, nactual, imax;
BOX *box;
BOXA *boxa;
PIX *pixs, *pixd, *pix;
PIXA *pixas, *pixat, *pixac;
L_PTRA *papix, *pabox, *papix2, *pabox2;
static char mainName[] = "ptra1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: ptra1_reg", mainName, 1);
setLeptDebugOK(1);
pixac = pixaCreate(0);
if ((pixs = pixRead("lucasta.1.300.tif")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, NULL);
boxa = pixConnComp(pixs, &pixas, 8);
pixDestroy(&pixs);
boxaDestroy(&boxa);
n = pixaGetCount(pixas);
/* Fill ptras with clones and reconstruct */
fprintf(stderr, "Fill with clones and reconstruct\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1);
/* Remove every other one for the first half;
* with compaction at each removal */
fprintf(stderr, "Remove every other in 1st half, with compaction\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_COPY);
for (i = 0; i < n / 2; i++) {
if (i % 2 == 0) {
pix = (PIX *)ptraRemove(papix, i, L_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_COMPACTION);
pixDestroy(&pix);
boxDestroy(&box);
}
}
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Remove every other one for the entire set,
* but without compaction at each removal */
fprintf(stderr,
"Remove every other in 1st half, without & then with compaction\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_COPY);
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
pix = (PIX *)ptraRemove(papix, i, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_NO_COMPACTION);
pixDestroy(&pix);
boxDestroy(&box);
}
}
ptraCompactArray(papix); /* now do the compaction */
ptraCompactArray(pabox);
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Fill ptras using insert at head, and reconstruct */
fprintf(stderr, "Insert at head and reconstruct\n");
papix = ptraCreate(n);
pabox = ptraCreate(n);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixas, i, L_CLONE);
box = pixaGetBox(pixas, i, L_CLONE);
ptraInsert(papix, 0, pix, L_MIN_DOWNSHIFT);
ptraInsert(pabox, 0, box, L_FULL_DOWNSHIFT);
}
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1);
/* Reverse the arrays by swapping */
fprintf(stderr, "Reverse by swapping\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
for (i = 0; i < n / 2; i++) {
ptraSwap(papix, i, n - i - 1);
ptraSwap(pabox, i, n - i - 1);
}
ptraCompactArray(papix); /* already compact; shouldn't do anything */
ptraCompactArray(pabox);
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Remove at the top of the array and push the hole to the end
* by neighbor swapping (!). This is O(n^2), so it's not a
* recommended way to copy a ptra. [joke] */
fprintf(stderr,
"Remove at top, pushing hole to end by swapping -- O(n^2)\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
papix2 = ptraCreate(0);
pabox2 = ptraCreate(0);
while (1) {
ptraGetActualCount(papix, &nactual);
if (nactual == 0) break;
ptraGetMaxIndex(papix, &imax);
pix = (PIX *)ptraRemove(papix, 0, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, 0, L_NO_COMPACTION);
ptraAdd(papix2, pix);
ptraAdd(pabox2, box);
for (i = 1; i <= imax; i++) {
ptraSwap(papix, i - 1, i);
ptraSwap(pabox, i - 1, i);
}
}
ptraCompactArray(papix); /* should be empty */
ptraCompactArray(pabox); /* ditto */
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1); /* nothing there */
pixat = ReconstructPixa(papix2, pabox2, CHOOSE_RECON);
ptraDestroy(&papix2, 0, 1);
ptraDestroy(&pabox2, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
/* Remove and insert one position above, allowing minimum downshift.
* If you specify L_AUTO_DOWNSHIFT, because there is only 1 hole,
* it will do a full downshift at each insert. This is a
* situation where the heuristic (expected number of holes)
* fails to do the optimal thing. */
fprintf(stderr, "Remove and insert one position above (min downshift)\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
for (i = 1; i < n; i++) {
pix = (PIX *)ptraRemove(papix, i, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_NO_COMPACTION);
ptraInsert(papix, i - 1, pix, L_MIN_DOWNSHIFT);
ptraInsert(pabox, i - 1, box, L_MIN_DOWNSHIFT);
}
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 1);
/* Remove and insert one position above, but this time
* forcing a full downshift at each step. */
fprintf(stderr, "Remove and insert one position above (full downshift)\n");
MakePtrasFromPixa(pixas, &papix, &pabox, L_CLONE);
for (i = 1; i < n; i++) {
pix = (PIX *)ptraRemove(papix, i, L_NO_COMPACTION);
box = (BOX *)ptraRemove(pabox, i, L_NO_COMPACTION);
ptraInsert(papix, i - 1, pix, L_AUTO_DOWNSHIFT);
ptraInsert(pabox, i - 1, box, L_AUTO_DOWNSHIFT);
}
/* ptraCompactArray(papix);
ptraCompactArray(pabox); */
pixat = ReconstructPixa(papix, pabox, CHOOSE_RECON);
ptraDestroy(&papix, 0, 1);
ptraDestroy(&pabox, 0, 1);
DisplayResult(pixac, &pixat, w, h, 0);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/junkptra1.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
pixaDestroy(&pixas);
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, j, x, y, val;
PIX *pixsq, *pixs, *pixc, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixsq = pixCreate(3, 3, 32);
pixSetAllArbitrary(pixsq, 0x00ff0000);
pixa = pixaCreate(6);
/* Moderately dense */
pixs = pixCreate(300, 300, 8);
for (i = 0; i < 100; i++) {
x = (153 * i * i * i + 59) % 299;
y = (117 * i * i * i + 241) % 299;
val = (97 * i + 74) % 256;
pixSetPixel(pixs, x, y, val);
}
pixd = pixSeedspread(pixs, 4); /* 4-cc */
pixc = pixConvertTo32(pixd);
for (i = 0; i < 100; i++) {
x = (153 * i * i * i + 59) % 299;
y = (117 * i * i * i + 241) % 299;
pixRasterop(pixc, x - 1, y - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
}
pixSaveTiled(pixc, pixa, REDUCTION, 1, 20, 32);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixc, 100, 100, "4-cc", rp->display);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixd = pixSeedspread(pixs, 8); /* 8-cc */
pixc = pixConvertTo32(pixd);
for (i = 0; i < 100; i++) {
x = (153 * i * i * i + 59) % 299;
y = (117 * i * i * i + 241) % 299;
pixRasterop(pixc, x - 1, y - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
}
pixSaveTiled(pixc, pixa, REDUCTION, 0, 20, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 1 */
pixDisplayWithTitle(pixc, 410, 100, "8-cc", rp->display);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixDestroy(&pixs);
/* Regular lattice */
pixs = pixCreate(200, 200, 8);
for (i = 5; i <= 195; i += 10) {
for (j = 5; j <= 195; j += 10) {
pixSetPixel(pixs, i, j, (7 * i + 17 * j) % 255);
}
}
pixd = pixSeedspread(pixs, 4); /* 4-cc */
pixc = pixConvertTo32(pixd);
for (i = 5; i <= 195; i += 10) {
for (j = 5; j <= 195; j += 10) {
pixRasterop(pixc, j - 1, i - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
}
}
pixSaveTiled(pixc, pixa, REDUCTION, 1, 20, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 2 */
pixDisplayWithTitle(pixc, 100, 430, "4-cc", rp->display);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixd = pixSeedspread(pixs, 8); /* 8-cc */
pixc = pixConvertTo32(pixd);
for (i = 5; i <= 195; i += 10) {
for (j = 5; j <= 195; j += 10) {
pixRasterop(pixc, j - 1, i - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
}
}
pixSaveTiled(pixc, pixa, REDUCTION, 0, 20, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 3 */
pixDisplayWithTitle(pixc, 310, 430, "8-cc", rp->display);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixDestroy(&pixs);
/* Very sparse points */
pixs = pixCreate(200, 200, 8);
pixSetPixel(pixs, 60, 20, 90);
pixSetPixel(pixs, 160, 40, 130);
pixSetPixel(pixs, 80, 80, 205);
pixSetPixel(pixs, 40, 160, 115);
pixd = pixSeedspread(pixs, 4); /* 4-cc */
pixc = pixConvertTo32(pixd);
pixRasterop(pixc, 60 - 1, 20 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixRasterop(pixc, 160 - 1, 40 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixRasterop(pixc, 80 - 1, 80 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixRasterop(pixc, 40 - 1, 160 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixSaveTiled(pixc, pixa, REDUCTION, 1, 20, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 4 */
pixDisplayWithTitle(pixc, 100, 600, "4-cc", rp->display);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixd = pixSeedspread(pixs, 8); /* 8-cc */
pixc = pixConvertTo32(pixd);
pixRasterop(pixc, 60 - 1, 20 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixRasterop(pixc, 160 - 1, 40 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixRasterop(pixc, 80 - 1, 80 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixRasterop(pixc, 40 - 1, 160 - 1, 3, 3, PIX_SRC, pixsq, 0, 0);
pixSaveTiled(pixc, pixa, REDUCTION, 0, 20, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 5 */
pixDisplayWithTitle(pixc, 310, 660, "8-cc", rp->display);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixDestroy(&pixs);
pixDestroy(&pixsq);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 6 */
pixDisplayWithTitle(pixc, 720, 100, "Final", rp->display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
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;
}
main(int argc,
char **argv)
{
char fname[256];
l_int32 i, w, h, nbins, factor, success, display;
l_int32 spike;
l_uint32 *array, *marray;
FILE *fp;
NUMA *na, *nan, *nai, *narbin;
PIX *pixs, *pixt, *pixd;
PIXA *pixa;
if (regTestSetup(argc, argv, &fp, &display, &success, NULL))
return 1;
/* Find the rank bin colors */
pixs = pixRead("map1.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
factor = L_MAX(1, (l_int32)sqrt((l_float64)(w * h / 20000.0)));
nbins = 10;
pixGetRankColorArray(pixs, nbins, L_SELECT_MIN, factor, &array, 2);
for (i = 0; i < nbins; i++)
fprintf(stderr, "%d: %x\n", i, array[i]);
pixd = pixDisplayColorArray(array, nbins, 200, 5, 1);
pixWrite("/tmp/rankhisto.0.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.0.png", 0, &success);
pixDisplayWithTitle(pixd, 100, 100, NULL, display);
pixDestroy(&pixd);
/* Modify the rank bin colors by mapping them such
* that the lightest color is mapped to white */
marray = (l_uint32 *)CALLOC(nbins, sizeof(l_uint32));
for (i = 0; i < nbins; i++)
pixelLinearMapToTargetColor(array[i], array[nbins - 1],
0xffffff00, &marray[i]);
pixd = pixDisplayColorArray(marray, nbins, 200, 5, 1);
pixWrite("/tmp/rankhisto.1.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.1.png", 1, &success);
pixDisplayWithTitle(pixd, 100, 600, NULL, display);
pixDestroy(&pixd);
FREE(marray);
/* Save the histogram plots */
#ifndef _WIN32
sleep(2); /* give gnuplot time to write out the files */
#else
Sleep(2000);
#endif /* _WIN32 */
pixa = PixSavePlots1();
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/rankhisto.2.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.2.png", 2, &success);
pixDisplayWithTitle(pixd, 100, 600, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
/* Map to the lightest bin; then do TRC adjustment */
pixt = pixLinearMapToTargetColor(NULL, pixs, array[nbins - 1], 0xffffff00);
pixd = pixGammaTRC(NULL, pixt, 1.0, 0, 240);
pixWrite("/tmp/rankhisto.3.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.3.png", 3, &success);
pixDisplayWithTitle(pixd, 600, 100, NULL, display);
pixDestroy(&pixt);
pixDestroy(&pixd);
/* Now test the edge cases for the histogram and rank LUT,
* where all the histo data is piled up at one place.
* We only require that the result be sensible. */
for (i = 0; i < 3; i++) {
if (i == 0)
spike = 0;
else if (i == 1)
spike = 50;
else
spike = 99;
na = numaMakeConstant(0, 100);
numaReplaceNumber(na, spike, 200.0);
nan = numaNormalizeHistogram(na, 1.0);
numaDiscretizeRankAndIntensity(nan, 10, &narbin, &nai, NULL, NULL);
snprintf(fname, sizeof(fname), "/tmp/rtnan%d", i + 1);
gplotSimple1(nan, GPLOT_PNG, fname, "Normalized Histogram");
snprintf(fname, sizeof(fname), "/tmp/rtnai%d", i + 1);
gplotSimple1(nai, GPLOT_PNG, fname, "Intensity vs. rank bin");
snprintf(fname, sizeof(fname), "/tmp/rtnarbin%d", i + 1);
gplotSimple1(narbin, GPLOT_PNG, fname, "LUT: rank bin vs. Intensity");
numaDestroy(&na);
numaDestroy(&nan);
numaDestroy(&narbin);
numaDestroy(&nai);
}
#ifndef _WIN32
sleep(2); /* give gnuplot time to write out the files */
#else
Sleep(2000);
#endif /* _WIN32 */
pixa = PixSavePlots2();
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/rankhisto.4.png", pixd, IFF_PNG);
regTestCheckFile(fp, argv, "/tmp/rankhisto.4.png", 4, &success);
pixDisplayWithTitle(pixd, 500, 600, NULL, display);
pixaDestroy(&pixa);
pixDestroy(&pixd);
pixDestroy(&pixs);
FREE(array);
regTestCleanup(argc, argv, fp, success, NULL);
return 0;
}
int main(int argc,
char **argv) {
l_int32 i, j, w, h, empty;
l_uint32 redval, greenval;
l_float32 f;
L_WSHED *wshed;
PIX *pixs, *pixc, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8;
PIXA *pixac;
PTA *pta;
static char mainName[] = "watershedtest";
if (argc != 1)
return ERROR_INT(" Syntax: watershedtest", mainName, 1);
pixac = pixaCreate(0);
pixs = pixCreate(500, 500, 8);
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 500; i++) {
for (j = 0; j < 500; j++) {
#if 1
f = 128.0 + 26.3 * sin(0.0438 * (l_float32) i);
f += 33.4 * cos(0.0712 * (l_float32) i);
f += 18.6 * sin(0.0561 * (l_float32) j);
f += 23.6 * cos(0.0327 * (l_float32) j);
#else
f = 128.0 + 26.3 * sin(0.0238 * (l_float32)i);
f += 33.4 * cos(0.0312 * (l_float32)i);
f += 18.6 * sin(0.0261 * (l_float32)j);
f += 23.6 * cos(0.0207 * (l_float32)j);
#endif
pixSetPixel(pixs, j, i, (l_int32) f);
}
}
pixSaveTiled(pixs, pixac, 1.0, 1, 10, 32);
pixWrite("/tmp/pattern.png", pixs, IFF_PNG);
startTimer();
pixLocalExtrema(pixs, 0, 0, &pix1, &pix2);
fprintf(stderr, "Time for extrema: %7.3f\n", stopTimer());
pixSetOrClearBorder(pix1, 2, 2, 2, 2, PIX_CLR);
composeRGBPixel(255, 0, 0, &redval);
composeRGBPixel(0, 255, 0, &greenval);
pixc = pixConvertTo32(pixs);
pixPaintThroughMask(pixc, pix2, 0, 0, greenval);
pixPaintThroughMask(pixc, pix1, 0, 0, redval);
pixSaveTiled(pixc, pixac, 1.0, 0, 10, 32);
pixWrite("/tmp/pixc.png", pixc, IFF_PNG);
pixSaveTiled(pix1, pixac, 1.0, 0, 10, 32);
pixSelectMinInConnComp(pixs, pix1, &pta, NULL);
/* ptaWriteStream(stderr, pta, 1); */
pix3 = pixGenerateFromPta(pta, w, h);
pixSaveTiled(pix3, pixac, 1.0, 1, 10, 32);
pix4 = pixConvertTo32(pixs);
pixPaintThroughMask(pix4, pix3, 0, 0, greenval);
pixSaveTiled(pix4, pixac, 1.0, 0, 10, 32);
pix5 = pixRemoveSeededComponents(NULL, pix3, pix1, 8, 2);
pixSaveTiled(pix5, pixac, 1.0, 0, 10, 32);
pixZero(pix5, &empty);
fprintf(stderr, "Is empty? %d\n", empty);
pixDestroy(&pix4);
pixDestroy(&pix5);
wshed = wshedCreate(pixs, pix3, 10, 0);
startTimer();
wshedApply(wshed);
fprintf(stderr, "Time for wshed: %7.3f\n", stopTimer());
pix6 = pixaDisplayRandomCmap(wshed->pixad, w, h);
pixSaveTiled(pix6, pixac, 1.0, 1, 10, 32);
numaWriteStream(stderr, wshed->nalevels);
pix7 = wshedRenderFill(wshed);
pixSaveTiled(pix7, pixac, 1.0, 0, 10, 32);
pix8 = wshedRenderColors(wshed);
pixSaveTiled(pix8, pixac, 1.0, 0, 10, 32);
wshedDestroy(&wshed);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/wshed.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pixs);
pixDestroy(&pixc);
ptaDestroy(&pta);
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout;
l_int32 w, h, d, w2, h2, i, ncols;
l_float32 angle, conf;
BOX *box;
BOXA *boxa, *boxas, *boxad, *boxa2;
NUMA *numa;
PIX *pixs, *pixt, *pixb, *pixb2, *pixd;
PIX *pixtlm, *pixvws;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXA *pixam, *pixac, *pixad, *pixat;
PIXAA *pixaa, *pixaa2;
PTA *pta;
SEL *selsplit;
static char mainName[] = "textlinemask";
if (argc != 3)
exit(ERROR_INT(" Syntax: textlinemask filein fileout", mainName, 1));
filein = argv[1];
fileout = argv[2];
pixDisplayWrite(NULL, -1); /* init debug output */
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, &d);
/* Binarize input */
if (d == 8)
pixt = pixThresholdToBinary(pixs, 128);
else if (d == 1)
pixt = pixClone(pixs);
else {
fprintf(stderr, "depth is %d\n", d);
exit(1);
}
/* Deskew */
pixb = pixFindSkewAndDeskew(pixt, 1, &angle, &conf);
pixDestroy(&pixt);
fprintf(stderr, "Skew angle: %7.2f degrees; %6.2f conf\n", angle, conf);
pixDisplayWrite(pixb, DEBUG_OUTPUT);
#if 1
/* Use full image morphology to find columns, at 2x reduction.
* This only works for very simple layouts where each column
* of text extends the full height of the input image.
* pixam has a pix component over each column. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pixt1 = pixMorphCompSequence(pixb2, "c5.500", 0);
boxa = pixConnComp(pixt1, &pixam, 8);
ncols = boxaGetCount(boxa);
fprintf(stderr, "Num columns: %d\n", ncols);
pixDisplayWrite(pixt1, DEBUG_OUTPUT);
/* Use selective region-based morphology to get the textline mask. */
pixad = pixaMorphSequenceByRegion(pixb2, pixam, "c100.3", 0, 0);
pixGetDimensions(pixb2, &w2, &h2, NULL);
if (DEBUG_OUTPUT) {
pixt2 = pixaDisplay(pixad, w2, h2);
pixDisplayWrite(pixt2, DEBUG_OUTPUT);
pixDestroy(&pixt2);
}
/* Some of the lines may be touching, so use a HMT to split the
* lines in each column, and use a pixaa to save the results. */
selsplit = selCreateFromString(seltext, 17, 7, "selsplit");
pixaa = pixaaCreate(ncols);
for (i = 0; i < ncols; i++) {
pixt3 = pixaGetPix(pixad, i, L_CLONE);
box = pixaGetBox(pixad, i, L_COPY);
pixt4 = pixHMT(NULL, pixt3, selsplit);
pixXor(pixt4, pixt4, pixt3);
boxa2 = pixConnComp(pixt4, &pixac, 8);
pixaaAddPixa(pixaa, pixac, L_INSERT);
pixaaAddBox(pixaa, box, L_INSERT);
if (DEBUG_OUTPUT) {
pixt5 = pixaDisplayRandomCmap(pixac, 0, 0);
pixDisplayWrite(pixt5, DEBUG_OUTPUT);
fprintf(stderr, "Num textlines in col %d: %d\n", i,
boxaGetCount(boxa2));
pixDestroy(&pixt5);
}
pixDestroy(&pixt3);
pixDestroy(&pixt4);
boxaDestroy(&boxa2);
}
/* Visual output */
if (DEBUG_OUTPUT) {
pixDisplayMultiple("/tmp/junk_write_display*");
pixat = pixaReadFiles("/tmp", "junk_write_display");
pixt5 = selDisplayInPix(selsplit, 31, 2);
pixaAddPix(pixat, pixt5, L_INSERT);
pixt6 = pixaDisplayTiledAndScaled(pixat, 32, 400, 3, 0, 35, 3);
pixWrite(fileout, pixt6, IFF_PNG);
pixaDestroy(&pixat);
pixDestroy(&pixt6);
}
/* Test pixaa I/O */
pixaaWrite("/tmp/junkpixaa", pixaa);
pixaa2 = pixaaRead("/tmp/junkpixaa");
pixaaWrite("/tmp/junkpixaa2", pixaa2);
/* Test pixaa display */
pixd = pixaaDisplay(pixaa, w2, h2);
pixWrite("/tmp/junkdisplay", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Cleanup */
pixDestroy(&pixb2);
pixDestroy(&pixt1);
pixaDestroy(&pixam);
pixaDestroy(&pixad);
pixaaDestroy(&pixaa);
pixaaDestroy(&pixaa2);
boxaDestroy(&boxa);
selDestroy(&selsplit);
#endif
#if 0
/* Use the baseline finder; not really what is needed */
numa = pixFindBaselines(pixb, &pta, 1);
#endif
#if 0
/* Use the textline mask function; parameters are not quite right */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pixtlm = pixGenTextlineMask(pixb2, &pixvws, NULL, 1);
pixDisplay(pixtlm, 0, 100);
pixDisplay(pixvws, 500, 100);
pixDestroy(&pixb2);
pixDestroy(&pixtlm);
pixDestroy(&pixvws);
#endif
#if 0
/* Use the Breuel whitespace partition method; slow and we would
* still need to work to extract the fg regions. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
boxas = pixConnComp(pixb2, NULL, 8);
boxad = boxaGetWhiteblocks(boxas, NULL, L_SORT_BY_HEIGHT,
3, 0.1, 200, 0.2, 0);
pixd = pixDrawBoxa(pixb2, boxad, 7, 0xe0708000);
pixDisplay(pixd, 100, 500);
pixDestroy(&pixb2);
pixDestroy(&pixd);
boxaDestroy(&boxas);
boxaDestroy(&boxad);
#endif
#if 0
/* Use morphology to find columns and then selective
* region-based morphology to get the textline mask.
* This is for display; we really want to get a pixa of the
* specific textline masks. */
startTimer();
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pixt1 = pixMorphCompSequence(pixb2, "c5.500", 0); /* column mask */
pixt2 = pixMorphSequenceByRegion(pixb2, pixt1, "c100.3", 8, 0, 0, &boxa);
fprintf(stderr, "time = %7.3f sec\n", stopTimer());
pixDisplay(pixt1, 100, 500);
pixDisplay(pixt2, 800, 500);
pixDestroy(&pixb2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
boxaDestroy(&boxa);
#endif
pixDestroy(&pixs);
pixDestroy(&pixb);
exit(0);
}
/*!
* pixGetTextlineCenters()
*
* Input: pixs (1 bpp)
* debugflag (1 for debug output)
* Return: ptaa (of center values of textlines)
*
* Notes:
* (1) This in general does not have a point for each value
* of x, because there will be gaps between words.
* It doesn't matter because we will fit a quadratic to the
* points that we do have.
*/
PTAA *
pixGetTextlineCenters(PIX *pixs,
l_int32 debugflag)
{
l_int32 i, w, h, bx, by, nsegs;
BOXA *boxa;
PIX *pix, *pixt1, *pixt2, *pixt3;
PIXA *pixa1, *pixa2;
PTA *pta;
PTAA *ptaa;
PROCNAME("pixGetTextlineCenters");
if (!pixs || pixGetDepth(pixs) != 1)
return (PTAA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
pixGetDimensions(pixs, &w, &h, NULL);
/* Filter to solidify the text lines within the x-height region,
* and to remove most of the ascenders and descenders. */
pixt1 = pixMorphSequence(pixs, "c15.1 + o15.1 + c30.1", 0);
pixDisplayWithTitle(pixt1, 0, 800, "pix1", debugflag);
/* Get the 8-connected components ... */
boxa = pixConnComp(pixt1, &pixa1, 8);
pixDestroy(&pixt1);
boxaDestroy(&boxa);
if (pixaGetCount(pixa1) == 0) {
pixaDestroy(&pixa1);
return NULL;
}
/* ... and remove the short and thin c.c */
pixa2 = pixaSelectBySize(pixa1, 100, 4, L_SELECT_IF_BOTH,
L_SELECT_IF_GT, 0);
if ((nsegs = pixaGetCount(pixa2)) == 0) {
pixaDestroy(&pixa2);
return NULL;
}
if (debugflag) {
pixt2 = pixaDisplay(pixa2, w, h);
pixDisplayWithTitle(pixt2, 800, 800, "pix2", 1);
pixDestroy(&pixt2);
}
/* For each c.c., get the weighted center of each vertical column.
* The result is a set of points going approximately through
* the center of the x-height part of the text line. */
ptaa = ptaaCreate(nsegs);
for (i = 0; i < nsegs; i++) {
pixaGetBoxGeometry(pixa2, i, &bx, &by, NULL, NULL);
pix = pixaGetPix(pixa2, i, L_CLONE);
pta = pixGetMeanVerticals(pix, bx, by);
ptaaAddPta(ptaa, pta, L_INSERT);
pixDestroy(&pix);
}
if (debugflag) {
pixt3 = pixCreateTemplate(pixt2);
pix = pixDisplayPtaa(pixt3, ptaa);
pixDisplayWithTitle(pix, 0, 1400, "pix3", 1);
pixDestroy(&pix);
pixDestroy(&pixt3);
}
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
return ptaa;
}
int main(int argc,
char **argv) {
l_int32 w, h, wd, hd;
l_float32 deg2rad, angle, conf;
PIX *pixs, *pixb1, *pixb2, *pixr, *pixf, *pixd, *pixc;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
deg2rad = 3.1415926535 / 180.;
pixa = pixaCreate(0);
pixs = pixRead("feyn.tif");
pixSetOrClearBorder(pixs, 100, 250, 100, 0, PIX_CLR);
pixb1 = pixReduceRankBinaryCascade(pixs, 2, 2, 0, 0);
regTestWritePixAndCheck(rp, pixb1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pixb1, 0, 100, NULL, rp->display);
/* Add a border and locate and deskew a 40 degree rotation */
pixb2 = pixAddBorder(pixb1, BORDER, 0);
pixGetDimensions(pixb2, &w, &h, NULL);
pixSaveTiled(pixb2, pixa, 0.5, 1, 20, 8);
pixr = pixRotateBySampling(pixb2, w / 2, h / 2,
deg2rad * 40., L_BRING_IN_WHITE);
regTestWritePixAndCheck(rp, pixr, IFF_PNG); /* 1 */
pixSaveTiled(pixr, pixa, 0.5, 0, 20, 0);
pixFindSkewSweepAndSearchScorePivot(pixr, &angle, &conf, NULL, 1, 1,
0.0, 45.0, 2.0, 0.03,
L_SHEAR_ABOUT_CENTER);
fprintf(stderr, "Should be 40 degrees: angle = %7.3f, conf = %7.3f\n",
angle, conf);
pixf = pixRotateBySampling(pixr, w / 2, h / 2,
deg2rad * angle, L_BRING_IN_WHITE);
pixd = pixRemoveBorder(pixf, BORDER);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 2 */
pixSaveTiled(pixd, pixa, 0.5, 0, 20, 0);
pixDestroy(&pixr);
pixDestroy(&pixf);
pixDestroy(&pixd);
/* Do a rotation larger than 90 degrees using embedding;
* Use 2 sets of measurements at 90 degrees to scan the
* full range of possible rotation angles. */
pixGetDimensions(pixb1, &w, &h, NULL);
pixr = pixRotate(pixb1, deg2rad * 37., L_ROTATE_SAMPLING,
L_BRING_IN_WHITE, w, h);
regTestWritePixAndCheck(rp, pixr, IFF_PNG); /* 3 */
pixSaveTiled(pixr, pixa, 0.5, 1, 20, 0);
startTimer();
pixFindSkewOrthogonalRange(pixr, &angle, &conf, 2, 1,
47.0, 1.0, 0.03, 0.0);
fprintf(stderr, "Orth search time: %7.3f sec\n", stopTimer());
fprintf(stderr, "Should be about -128 degrees: angle = %7.3f\n", angle);
pixd = pixRotate(pixr, deg2rad * angle, L_ROTATE_SAMPLING,
L_BRING_IN_WHITE, w, h);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 4 */
pixGetDimensions(pixd, &wd, &hd, NULL);
pixc = pixCreate(w, h, 1);
pixRasterop(pixc, 0, 0, w, h, PIX_SRC, pixd, (wd - w) / 2, (hd - h) / 2);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 5 */
pixSaveTiled(pixc, pixa, 0.5, 0, 20, 0);
pixDestroy(&pixr);
pixDestroy(&pixf);
pixDestroy(&pixd);
pixDestroy(&pixc);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 6 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixb1);
pixDestroy(&pixb2);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
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, nbox, npta, fgcount, bgcount, count;
BOXA *boxa;
PIX *pixs, *pixfg, *pixbg, *pixc, *pixb, *pixd;
PIX *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
PTA *pta;
PTAA *ptaafg, *ptaabg;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn-fract.tif");
boxa = pixConnComp(pixs, NULL, 8);
nbox = boxaGetCount(boxa);
regTestCompareValues(rp, nbox, 464, 0); /* 0 */
/* Get fg and bg boundary pixels */
pixfg = pixMorphSequence(pixs, "e3.3", 0);
pixXor(pixfg, pixfg, pixs);
pixCountPixels(pixfg, &fgcount, NULL);
regTestCompareValues(rp, fgcount, 58764, 0); /* 1 */
pixbg = pixMorphSequence(pixs, "d3.3", 0);
pixXor(pixbg, pixbg, pixs);
pixCountPixels(pixbg, &bgcount, NULL);
regTestCompareValues(rp, bgcount, 60335, 0); /* 2 */
/* Get ptaa of fg pixels */
ptaafg = ptaaGetBoundaryPixels(pixs, L_BOUNDARY_FG, 8, NULL, NULL);
npta = ptaaGetCount(ptaafg);
regTestCompareValues(rp, npta, nbox, 0); /* 3 */
count = 0;
for (i = 0; i < npta; i++) {
pta = ptaaGetPta(ptaafg, i, L_CLONE);
count += ptaGetCount(pta);
ptaDestroy(&pta);
}
regTestCompareValues(rp, fgcount, count, 0); /* 4 */
/* Get ptaa of bg pixels. Note that the number of bg pts
* is, in general, larger than the number of bg boundary pixels,
* because bg boundary pixels are shared by two c.c. that
* are 1 pixel apart. */
ptaabg = ptaaGetBoundaryPixels(pixs, L_BOUNDARY_BG, 8, NULL, NULL);
npta = ptaaGetCount(ptaabg);
regTestCompareValues(rp, npta, nbox, 0); /* 5 */
count = 0;
for (i = 0; i < npta; i++) {
pta = ptaaGetPta(ptaabg, i, L_CLONE);
count += ptaGetCount(pta);
ptaDestroy(&pta);
}
regTestCompareValues(rp, count, 60602, 0); /* 6 */
/* Render the fg boundary pixels on top of pixs. */
pixa = pixaCreate(4);
pixc = pixRenderRandomCmapPtaa(pixs, ptaafg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 7 */
pixSaveTiledOutline(pixc, pixa, 1.0, 1, 30, 2, 32);
pixDestroy(&pixc);
/* Render the bg boundary pixels on top of pixs. */
pixc = pixRenderRandomCmapPtaa(pixs, ptaabg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 8 */
pixSaveTiledOutline(pixc, pixa, 1.0, 0, 30, 2, 32);
pixDestroy(&pixc);
pixClearAll(pixs);
/* Render the fg boundary pixels alone. */
pixc = pixRenderRandomCmapPtaa(pixs, ptaafg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 9 */
pixSaveTiledOutline(pixc, pixa, 1.0, 1, 30, 2, 32);
/* Verify that the fg pixels are the same set as we
* originally started with. */
pixb = pixConvertTo1(pixc, 255);
regTestComparePix(rp, pixb, pixfg); /* 10 */
pixDestroy(&pixc);
pixDestroy(&pixb);
/* Render the bg boundary pixels alone. */
pixc = pixRenderRandomCmapPtaa(pixs, ptaabg, 0, 0, 0);
regTestWritePixAndCheck(rp, pixc, IFF_PNG); /* 11 */
pixSaveTiledOutline(pixc, pixa, 1.0, 0, 30, 2, 32);
/* Verify that the bg pixels are the same set as we
* originally started with. */
pixb = pixConvertTo1(pixc, 255);
regTestComparePix(rp, pixb, pixbg); /* 12 */
pixDestroy(&pixc);
pixDestroy(&pixb);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 0, 0, NULL, rp->display);
ptaaDestroy(&ptaafg);
ptaaDestroy(&ptaabg);
pixDestroy(&pixs);
pixDestroy(&pixfg);
pixDestroy(&pixbg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
/* Test rotation */
pix1 = pixRead("feyn-word.tif");
pix2 = pixAddBorderGeneral(pix1, 200, 200, 200, 200, 0);
pixa = pixaCreate(0);
pix3 = PtaDisplayRotate(pix2, 0, 0);
pixaAddPix(pixa, pix3, L_INSERT);
pix3 = PtaDisplayRotate(pix2, 500, 100);
pixaAddPix(pixa, pix3, L_INSERT);
pix3 = PtaDisplayRotate(pix2, 100, 410);
pixaAddPix(pixa, pix3, L_INSERT);
pix3 = PtaDisplayRotate(pix2, 500, 410);
pixaAddPix(pixa, pix3, L_INSERT);
pix4 = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 30, 2);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix4, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix4);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 i, d, h;
l_float32 rat;
PIX *pixs, *pixgb, *pixt1, *pixt2, *pixt3, *pixt4, *pixg, *pixd;
PIXA *pixa;
PTA *ptas, *ptad;
static char mainName[] = "bilinear_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: bilinear_reg", mainName, 1));
pixs = pixRead("feyn.tif");
pixg = pixScaleToGray3(pixs);
#if ALL
/* Test non-invertability of sampling */
pixa = pixaCreate(0);
for (i = 1; i < 3; i++) {
pixgb = pixAddBorder(pixg, ADDED_BORDER_PIXELS, 255);
MakePtas(i, &ptas, &ptad);
pixt1 = pixBilinearSampledPta(pixgb, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt1, pixa, 2, 1, 20, 8);
pixt2 = pixBilinearSampledPta(pixt1, ptas, ptad, L_BRING_IN_WHITE);
pixSaveTiled(pixt2, pixa, 2, 0, 20, 0);
pixd = pixRemoveBorder(pixt2, ADDED_BORDER_PIXELS);
pixInvert(pixd, pixd);
pixXor(pixd, pixd, pixg);
pixSaveTiled(pixd, pixa, 2, 0, 20, 0);
if (i == 0) pixWrite("/tmp/junksamp.png", pixt1, IFF_PNG);
pixDestroy(&pixgb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
}
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkbilin1.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 300);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
#endif
#if ALL
/* Test non-invertability of interpolation */
pixa = pixaCreate(0);
for (i = 1; i < 3; i++) {
pixgb = pixAddBorder(pixg, ADDED_BORDER_PIXELS, 255);
MakePtas(i, &ptas, &ptad);
pixt1 = pixBilinearPta(pixgb, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt1, pixa, 2, 1, 20, 8);
pixt2 = pixBilinearPta(pixt1, ptas, ptad, L_BRING_IN_WHITE);
pixSaveTiled(pixt2, pixa, 2, 0, 20, 0);
pixd = pixRemoveBorder(pixt2, ADDED_BORDER_PIXELS);
pixInvert(pixd, pixd);
pixXor(pixd, pixd, pixg);
pixSaveTiled(pixd, pixa, 2, 0, 20, 0);
if (i == 0) pixWrite("/tmp/junkinterp.png", pixt1, IFF_PNG);
pixDestroy(&pixgb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
}
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkbilin2.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 300);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
#endif
#if ALL /* test with large distortion and inversion */
MakePtas(0, &ptas, &ptad);
pixa = pixaCreate(0);
startTimer();
pixt1 = pixBilinearSampledPta(pixg, ptas, ptad, L_BRING_IN_WHITE);
fprintf(stderr, " Time for pixBilinearSampled(): %6.2f sec\n", stopTimer());
pixSaveTiled(pixt1, pixa, 2, 1, 20, 8);
startTimer();
pixt2 = pixBilinearPta(pixg, ptas, ptad, L_BRING_IN_WHITE);
fprintf(stderr, " Time for pixBilinearInterpolated(): %6.2f sec\n",
stopTimer());
pixSaveTiled(pixt2, pixa, 2, 0, 20, 8);
pixt3 = pixBilinearSampledPta(pixt1, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt3, pixa, 2, 0, 20, 8);
pixt4 = pixBilinearPta(pixt2, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt4, pixa, 2, 0, 20, 8);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkbilin3.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 300);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixg);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
#endif
return 0;
}
void
RotateTest(PIX *pixs,
l_int32 reduction,
L_REGPARAMS *rp)
{
l_int32 w, h, d, outformat;
PIX *pixt1, *pixt2, *pixt3, *pixd;
PIXA *pixa;
pixGetDimensions(pixs, &w, &h, &d);
outformat = (d == 8 || d == 32) ? IFF_JFIF_JPEG : IFF_PNG;
pixa = pixaCreate(0);
pixt1 = pixRotate(pixs, ANGLE1, L_ROTATE_SHEAR, L_BRING_IN_WHITE, w, h);
pixSaveTiled(pixt1, pixa, reduction, 1, 20, 32);
pixt2 = pixRotate(pixs, ANGLE1, L_ROTATE_SHEAR, L_BRING_IN_BLACK, w, h);
pixSaveTiled(pixt2, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixt1 = pixRotate(pixs, ANGLE1, L_ROTATE_SHEAR, L_BRING_IN_WHITE, 0, 0);
pixSaveTiled(pixt1, pixa, reduction, 1, 20, 0);
pixt2 = pixRotate(pixs, ANGLE1, L_ROTATE_SHEAR, L_BRING_IN_BLACK, 0, 0);
pixSaveTiled(pixt2, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixt1 = pixRotate(pixs, ANGLE2, L_ROTATE_SHEAR, L_BRING_IN_WHITE, w, h);
pixSaveTiled(pixt1, pixa, reduction, 1, 20, 0);
pixt2 = pixRotate(pixs, ANGLE2, L_ROTATE_SHEAR, L_BRING_IN_BLACK, w, h);
pixSaveTiled(pixt2, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixt1 = pixRotate(pixs, ANGLE2, L_ROTATE_SHEAR, L_BRING_IN_WHITE, 0, 0);
pixSaveTiled(pixt1, pixa, reduction, 1, 20, 0);
pixt2 = pixRotate(pixs, ANGLE2, L_ROTATE_SHEAR, L_BRING_IN_BLACK, 0, 0);
pixSaveTiled(pixt2, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, outformat);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixa = pixaCreate(0);
pixt1 = pixRotate(pixs, ANGLE2, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, w, h);
pixSaveTiled(pixt1, pixa, reduction, 1, 20, 32);
pixt2 = pixRotate(pixs, ANGLE2, L_ROTATE_SAMPLING, L_BRING_IN_BLACK, w, h);
pixSaveTiled(pixt2, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixt1 = pixRotate(pixs, ANGLE2, L_ROTATE_SAMPLING, L_BRING_IN_WHITE, 0, 0);
pixSaveTiled(pixt1, pixa, reduction, 1, 20, 0);
pixt2 = pixRotate(pixs, ANGLE2, L_ROTATE_SAMPLING, L_BRING_IN_BLACK, 0, 0);
pixSaveTiled(pixt2, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
if (pixGetDepth(pixs) == 1)
pixt1 = pixScaleToGray2(pixs);
else
pixt1 = pixClone(pixs);
pixt2 = pixRotate(pixt1, ANGLE2, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, w, h);
pixSaveTiled(pixt2, pixa, reduction, 1, 20, 0);
pixt3 = pixRotate(pixt1, ANGLE2, L_ROTATE_AREA_MAP, L_BRING_IN_BLACK, w, h);
pixSaveTiled(pixt3, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixt2 = pixRotate(pixt1, ANGLE2, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, 0, 0);
pixSaveTiled(pixt2, pixa, reduction, 1, 20, 0);
pixt3 = pixRotate(pixt1, ANGLE2, L_ROTATE_AREA_MAP, L_BRING_IN_BLACK, 0, 0);
pixSaveTiled(pixt3, pixa, reduction, 0, 20, 0);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt1);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, outformat);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return;
}
main(int argc,
char **argv)
{
l_int32 error;
l_uint32 *data;
PIX *pix1, *pix2, *pix3, *pix1c, *pix2c, *pix1t, *pix2t, *pixd;
PIXA *pixa;
static char mainName[] = "pixmem_reg";
error = 0;
pixa = pixaCreate(0);
/* Copy with internal resizing: onto a cmapped image */
pix1 = pixRead("weasel4.16c.png");
pix2 = pixRead("feyn-fract.tif");
pix3 = pixRead("lucasta.150.jpg");
fprintf(stderr, "before copy 2 --> 3\n");
pixCopy(pix3, pix2);
Compare(pix2, pix3, &error);
pixSaveTiled(pix3, pixa, 4, 1, 30, 32);
fprintf(stderr, "before copy 3 --> 1\n");
pixCopy(pix1, pix3);
Compare(pix2, pix1, &error);
pixSaveTiled(pix1, pixa, 4, 0, 30, 32);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Copy with internal resizing: from a cmapped image */
pix1 = pixRead("weasel4.16c.png");
pix2 = pixRead("feyn-fract.tif");
pix3 = pixRead("lucasta.150.jpg");
fprintf(stderr, "before copy 1 --> 2\n");
pixCopy(pix2, pix1);
Compare(pix2, pix1, &error);
pixSaveTiled(pix2, pixa, 1, 1, 30, 32);
fprintf(stderr, "before copy 2 --> 3\n");
pixCopy(pix3, pix2);
Compare(pix3, pix2, &error);
pixSaveTiled(pix3, pixa, 1, 0, 30, 32);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Transfer of data pixs --> pixd, when pixs is not cloned.
* pixs is destroyed. */
pix1 = pixRead("weasel4.16c.png");
pix2 = pixRead("feyn-fract.tif");
pix3 = pixRead("lucasta.150.jpg");
pix1c = pixCopy(NULL, pix1);
fprintf(stderr, "before transfer 1 --> 2\n");
pixTransferAllData(pix2, &pix1, 0, 0);
Compare(pix2, pix1c, &error);
pixSaveTiled(pix2, pixa, 1, 1, 30, 32);
fprintf(stderr, "before transfer 2 --> 3\n");
pixTransferAllData(pix3, &pix2, 0, 0);
Compare(pix3, pix1c, &error);
pixSaveTiled(pix3, pixa, 1, 0, 30, 32);
pixDestroy(&pix1c);
pixDestroy(&pix3);
/* Another transfer of data pixs --> pixd, when pixs is not cloned.
* pixs is destroyed. */
pix1 = pixRead("weasel4.16c.png");
pix2 = pixRead("feyn-fract.tif");
pix3 = pixRead("lucasta.150.jpg");
pix1c = pixCopy(NULL, pix1);
pix2c = pixCopy(NULL, pix2);
fprintf(stderr, "before copy transfer 1 --> 2\n");
pixTransferAllData(pix2, &pix1c, 0, 0);
Compare(pix2, pix1, &error);
pixSaveTiled(pix2, pixa, 1, 0, 30, 32);
fprintf(stderr, "before copy transfer 2 --> 3\n");
pixTransferAllData(pix3, &pix2, 0, 0);
Compare(pix3, pix1, &error);
pixSaveTiled(pix3, pixa, 1, 0, 30, 32);
pixDestroy(&pix1);
pixDestroy(&pix2c);
pixDestroy(&pix3);
/* Transfer of data pixs --> pixd, when pixs is cloned.
* pixs has its refcount reduced by 1. */
pix1 = pixRead("weasel4.16c.png");
pix2 = pixRead("feyn-fract.tif");
pix3 = pixRead("lucasta.150.jpg");
pix1c = pixClone(pix1);
pix2c = pixClone(pix2);
fprintf(stderr, "before clone transfer 1 --> 2\n");
pixTransferAllData(pix2, &pix1c, 0, 0);
Compare(pix2, pix1, &error);
pixSaveTiled(pix2, pixa, 1, 0, 30, 32);
fprintf(stderr, "before clone transfer 2 --> 3\n");
pixTransferAllData(pix3, &pix2c, 0, 0);
Compare(pix3, pix1, &error);
pixSaveTiled(pix3, pixa, 1, 0, 30, 32);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* Extraction of data when pixs is not cloned, putting
* the data into a new template of pixs. */
pix2 = pixRead("feyn-fract.tif");
fprintf(stderr, "no clone: before extraction and reinsertion of 2\n");
pix2c = pixCopy(NULL, pix2); /* for later reference */
data = pixExtractData(pix2);
pix2t = pixCreateTemplateNoInit(pix2);
pixFreeData(pix2t);
pixSetData(pix2t, data);
Compare(pix2c, pix2t, &error);
pixSaveTiled(pix2t, pixa, 4, 1, 30, 32);
pixDestroy(&pix2);
pixDestroy(&pix2c);
pixDestroy(&pix2t);
/* Extraction of data when pixs is cloned, putting
* a copy of the data into a new template of pixs. */
pix1 = pixRead("weasel4.16c.png");
fprintf(stderr, "clone: before extraction and reinsertion of 1\n");
pix1c = pixClone(pix1); /* bump refcount of pix1 to 2 */
data = pixExtractData(pix1); /* should make a copy of data */
pix1t = pixCreateTemplateNoInit(pix1);
pixFreeData(pix1t);
pixSetData(pix1t, data);
Compare(pix1c, pix1t, &error);
pixSaveTiled(pix1t, pixa, 1, 0, 30, 32);
pixDestroy(&pix1);
pixDestroy(&pix1c);
pixDestroy(&pix1t);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/junkpixmem.png", pixd, IFF_PNG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
if (error)
fprintf(stderr, "Fail: an error occurred\n");
else
fprintf(stderr, "Success: no errors\n");
return 0;
}
main(int argc,
char **argv)
{
char bufname[256];
l_int32 i, j, w, h, d, x, y, wpls;
l_uint32 *datas, *lines;
l_float32 *vc;
l_float32 *mat1, *mat2, *mat3, *mat1i, *mat2i, *mat3i, *matdinv;
l_float32 matd[9], matdi[9];
BOXA *boxa, *boxa2;
PIX *pix, *pixs, *pixb, *pixg, *pixc, *pixcs;
PIX *pixd, *pixt1, *pixt2, *pixt3;
PIXA *pixa;
PTA *ptas, *ptad;
static char mainName[] = "affine_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: affine_reg", mainName, 1));
if ((pixs = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
#if ALL
/* Test invertability of sequential. */
pixa = pixaCreate(0);
for (i = 0; i < 3; i++) {
pixb = pixAddBorder(pixs, ADDED_BORDER_PIXELS, 0);
MakePtas(i, &ptas, &ptad);
pixt1 = pixAffineSequential(pixb, ptad, ptas, 0, 0);
pixSaveTiled(pixt1, pixa, 3, 1, 20, 8);
pixt2 = pixAffineSequential(pixt1, ptas, ptad, 0, 0);
pixSaveTiled(pixt2, pixa, 3, 0, 20, 0);
pixd = pixRemoveBorder(pixt2, ADDED_BORDER_PIXELS);
pixXor(pixd, pixd, pixs);
pixSaveTiled(pixd, pixa, 3, 0, 20, 0);
sprintf(bufname, "/tmp/junkseq%d.png", i);
pixWrite(bufname, pixd, IFF_PNG);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
}
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine1.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 100);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
#endif
#if ALL
/* Test invertability of sampling */
pixa = pixaCreate(0);
for (i = 0; i < 3; i++) {
pixb = pixAddBorder(pixs, ADDED_BORDER_PIXELS, 0);
MakePtas(i, &ptas, &ptad);
pixt1 = pixAffineSampledPta(pixb, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt1, pixa, 3, 1, 20, 8);
pixt2 = pixAffineSampledPta(pixt1, ptas, ptad, L_BRING_IN_WHITE);
pixSaveTiled(pixt2, pixa, 3, 0, 20, 0);
pixd = pixRemoveBorder(pixt2, ADDED_BORDER_PIXELS);
pixXor(pixd, pixd, pixs);
pixSaveTiled(pixd, pixa, 3, 0, 20, 0);
if (i == 0) pixWrite("/tmp/junksamp.png", pixt1, IFF_PNG);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
}
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine2.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 300);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
#endif
#if ALL
/* Test invertability of interpolation on grayscale */
pixa = pixaCreate(0);
pixg = pixScaleToGray3(pixs);
for (i = 0; i < 3; i++) {
pixb = pixAddBorder(pixg, ADDED_BORDER_PIXELS / 3, 255);
MakePtas(i, &ptas, &ptad);
pixt1 = pixAffinePta(pixb, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt1, pixa, 1, 1, 20, 8);
pixt2 = pixAffinePta(pixt1, ptas, ptad, L_BRING_IN_WHITE);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixd = pixRemoveBorder(pixt2, ADDED_BORDER_PIXELS / 3);
pixXor(pixd, pixd, pixg);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
if (i == 0) pixWrite("/tmp/junkinterp.png", pixt1, IFF_PNG);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
}
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine3.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 500);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
pixDestroy(&pixg);
#endif
#if ALL
/* Test invertability of interpolation on color */
pixa = pixaCreate(0);
pixc = pixRead("test24.jpg");
pixcs = pixScale(pixc, 0.3, 0.3);
for (i = 0; i < 3; i++) {
pixb = pixAddBorder(pixcs, ADDED_BORDER_PIXELS / 4, 0xffffff00);
MakePtas(i, &ptas, &ptad);
pixt1 = pixAffinePta(pixb, ptad, ptas, L_BRING_IN_WHITE);
pixSaveTiled(pixt1, pixa, 1, 1, 20, 32);
pixt2 = pixAffinePta(pixt1, ptas, ptad, L_BRING_IN_WHITE);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixd = pixRemoveBorder(pixt2, ADDED_BORDER_PIXELS / 4);
pixXor(pixd, pixd, pixcs);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
}
pixt1 = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine4.png", pixt1, IFF_PNG);
pixDisplay(pixt1, 100, 500);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
pixDestroy(&pixc);
pixDestroy(&pixcs);
#endif
#if ALL
/* Comparison between sequential and sampling */
MakePtas(3, &ptas, &ptad);
pixa = pixaCreate(0);
/* Use sequential transforms */
pixt1 = pixAffineSequential(pixs, ptas, ptad,
ADDED_BORDER_PIXELS, ADDED_BORDER_PIXELS);
pixSaveTiled(pixt1, pixa, 2, 0, 20, 8);
/* Use sampled transform */
pixt2 = pixAffineSampledPta(pixs, ptas, ptad, L_BRING_IN_WHITE);
pixSaveTiled(pixt2, pixa, 2, 0, 20, 8);
/* Compare the results */
pixXor(pixt2, pixt2, pixt1);
pixSaveTiled(pixt2, pixa, 2, 0, 20, 8);
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine5.png", pixd, IFF_PNG);
pixDisplay(pixd, 100, 700);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixd);
pixaDestroy(&pixa);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
#endif
#if ALL
/* Get timings and test with large distortion */
MakePtas(4, &ptas, &ptad);
pixa = pixaCreate(0);
pixg = pixScaleToGray3(pixs);
startTimer();
pixt1 = pixAffineSequential(pixg, ptas, ptad, 0, 0);
fprintf(stderr, " Time for pixAffineSequentialPta(): %6.2f sec\n",
stopTimer());
pixSaveTiled(pixt1, pixa, 1, 1, 20, 8);
startTimer();
pixt2 = pixAffineSampledPta(pixg, ptas, ptad, L_BRING_IN_WHITE);
fprintf(stderr, " Time for pixAffineSampledPta(): %6.2f sec\n", stopTimer());
pixSaveTiled(pixt2, pixa, 1, 0, 20, 8);
startTimer();
pixt3 = pixAffinePta(pixg, ptas, ptad, L_BRING_IN_WHITE);
fprintf(stderr, " Time for pixAffinePta(): %6.2f sec\n", stopTimer());
pixSaveTiled(pixt3, pixa, 1, 0, 20, 8);
pixXor(pixt1, pixt1, pixt2);
pixSaveTiled(pixt1, pixa, 1, 1, 20, 8);
pixXor(pixt2, pixt2, pixt3);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 8);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine6.png", pixd, IFF_PNG);
pixDisplay(pixd, 100, 900);
pixDestroy(&pixd);
pixDestroy(&pixg);
pixaDestroy(&pixa);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
#endif
pixDestroy(&pixs);
#if 1
/* Set up pix and boxa */
pixa = pixaCreate(0);
pix = pixRead("lucasta.1.300.tif");
pixTranslate(pix, pix, 70, 0, L_BRING_IN_WHITE);
pixt1 = pixCloseBrick(NULL, pix, 14, 5);
pixOpenBrick(pixt1, pixt1, 1, 2);
boxa = pixConnComp(pixt1, NULL, 8);
pixs = pixConvertTo32(pix);
pixGetDimensions(pixs, &w, &h, NULL);
pixc = pixCopy(NULL, pixs);
RenderHashedBoxa(pixc, boxa, 113);
pixSaveTiled(pixc, pixa, 2, 1, 30, 32);
pixDestroy(&pix);
pixDestroy(&pixc);
pixDestroy(&pixt1);
/* Set up an affine transform in matd, and apply it to boxa */
mat1 = createMatrix2dTranslate(SHIFTX, SHIFTY);
mat2 = createMatrix2dScale(SCALEX, SCALEY);
mat3 = createMatrix2dRotate(w / 2, h / 2, ROTATION);
l_productMat3(mat3, mat2, mat1, matd, 3);
boxa2 = boxaAffineTransform(boxa, matd);
/* Set up the inverse transform in matdi */
mat1i = createMatrix2dTranslate(-SHIFTX, -SHIFTY);
mat2i = createMatrix2dScale(1.0/ SCALEX, 1.0 / SCALEY);
mat3i = createMatrix2dRotate(w / 2, h / 2, -ROTATION);
l_productMat3(mat1i, mat2i, mat3i, matdi, 3);
/* Invert the original affine transform in matdinv */
affineInvertXform(matd, &matdinv);
fprintf(stderr, "Affine transform, applied to boxa\n");
for (i = 0; i < 9; i++) {
if (i && (i % 3 == 0)) fprintf(stderr, "\n");
fprintf(stderr, " %7.3f ", matd[i]);
}
fprintf(stderr, "\nInverse transform, made by composing inverse parts");
for (i = 0; i < 9; i++) {
if (i % 3 == 0) fprintf(stderr, "\n");
fprintf(stderr, " %7.3f ", matdi[i]);
}
fprintf(stderr, "\nInverse transform, made by inverting the affine xform");
for (i = 0; i < 6; i++) {
if (i % 3 == 0) fprintf(stderr, "\n");
fprintf(stderr, " %7.3f ", matdinv[i]);
}
fprintf(stderr, "\n");
/* Apply the inverted affine transform pixs */
pixd = pixAffine(pixs, matdinv, L_BRING_IN_WHITE);
RenderHashedBoxa(pixd, boxa2, 513);
pixSaveTiled(pixd, pixa, 2, 0, 30, 32);
pixDestroy(&pixd);
pixd = pixaDisplay(pixa, 0, 0);
pixWrite("/tmp/junkaffine7.png", pixd, IFF_PNG);
pixDisplay(pixd, 100, 900);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
boxaDestroy(&boxa2);
FREE(mat1);
FREE(mat2);
FREE(mat3);
FREE(mat1i);
FREE(mat2i);
FREE(mat3i);
#endif
return 0;
}
main(int argc,
char **argv)
{
l_float32 sum, sumx, sumy, diff;
L_DEWARP *dew;
L_DEWARPA *dewa;
FPIX *fpixs, *fpixs2, *fpixs3, *fpixs4, *fpixg, *fpixd;
FPIX *fpix1, *fpix2, *fpixt1, *fpixt2;
DPIX *dpix, *dpix2;
L_KERNEL *kel, *kelx, *kely;
PIX *pixs, *pixs2, *pixs3, *pixt, *pixd, *pixg, *pixb, *pixn;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXA *pixa;
PTA *ptas, *ptad;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Gaussian kernel */
kel = makeGaussianKernel(5, 5, 3.0, 4.0);
kernelGetSum(kel, &sum);
if (rp->display) fprintf(stderr, "Sum for 2d gaussian kernel = %f\n", sum);
pixt = kernelDisplayInPix(kel, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 0 */
pixSaveTiled(pixt, pixa, 1, 1, 20, 8);
pixDestroy(&pixt);
/* Separable gaussian kernel */
makeGaussianKernelSep(5, 5, 3.0, 4.0, &kelx, &kely);
kernelGetSum(kelx, &sumx);
if (rp->display) fprintf(stderr, "Sum for x gaussian kernel = %f\n", sumx);
kernelGetSum(kely, &sumy);
if (rp->display) fprintf(stderr, "Sum for y gaussian kernel = %f\n", sumy);
if (rp->display) fprintf(stderr, "Sum for x * y gaussian kernel = %f\n",
sumx * sumy);
pixt = kernelDisplayInPix(kelx, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 1 */
pixSaveTiled(pixt, pixa, 1, 0, 20, 8);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixSaveTiled(pixt, pixa, 1, 0, 20, 8);
pixDestroy(&pixt);
/* Use pixRasterop() to generate source image */
pixs = pixRead("test8.jpg");
pixs2 = pixRead("karen8.jpg");
pixRasterop(pixs, 150, 125, 150, 100, PIX_SRC, pixs2, 75, 100);
regTestWritePixAndCheck(rp, pixs, IFF_JFIF_JPEG); /* 3 */
/* Convolution directly with pix */
pixt1 = pixConvolve(pixs, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 4 */
pixSaveTiled(pixt1, pixa, 1, 1, 20, 8);
pixt2 = pixConvolveSep(pixs, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 5 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 8);
/* Convolution indirectly with fpix, using fpixRasterop()
* to generate the source image. */
fpixs = pixConvertToFPix(pixs, 3);
fpixs2 = pixConvertToFPix(pixs2, 3);
fpixRasterop(fpixs, 150, 125, 150, 100, fpixs2, 75, 100);
fpixt1 = fpixConvolve(fpixs, kel, 1);
pixt3 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 6 */
pixSaveTiled(pixt3, pixa, 1, 1, 20, 8);
fpixt2 = fpixConvolveSep(fpixs, kelx, kely, 1);
pixt4 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 7 */
pixSaveTiled(pixt4, pixa, 1, 0, 20, 8);
pixDestroy(&pixs2);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
/* Comparison of results */
pixCompareGray(pixt1, pixt2, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and pixConvolveSep: %f\n",
diff);
pixCompareGray(pixt3, pixt4, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of fpixConvolve and fpixConvolveSep: %f\n",
diff);
pixCompareGray(pixt1, pixt3, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and fpixConvolve: %f\n", diff);
pixCompareGray(pixt2, pixt4, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolveSep and fpixConvolveSep: %f\n",
diff);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Test arithmetic operations; add in a fraction rotated by 180 */
pixs3 = pixRotate180(NULL, pixs);
regTestWritePixAndCheck(rp, pixs3, IFF_JFIF_JPEG); /* 8 */
pixSaveTiled(pixs3, pixa, 1, 1, 20, 8);
fpixs3 = pixConvertToFPix(pixs3, 3);
fpixd = fpixLinearCombination(NULL, fpixs, fpixs3, 20.0, 5.0);
fpixAddMultConstant(fpixd, 0.0, 23.174); /* multiply up in magnitude */
pixd = fpixDisplayMaxDynamicRange(fpixd); /* bring back to 8 bpp */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixSaveTiled(pixd, pixa, 1, 0, 20, 8);
pixDestroy(&pixs3);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixd);
pixDestroy(&pixd);
pixDestroy(&pixs);
fpixDestroy(&fpixs);
/* Save the comparison graph; gnuplot should have made it by now! */
#ifndef _WIN32
sleep(2);
#else
Sleep(2000);
#endif /* _WIN32 */
pixt5 = pixRead("/tmp/grayroot.png");
regTestWritePixAndCheck(rp, pixt5, IFF_PNG); /* 10 */
pixSaveTiled(pixt5, pixa, 1, 1, 20, 8);
pixDestroy(&pixt5);
/* Display results */
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test some more convolutions, with sampled output. First on pix */
pixa = pixaCreate(0);
pixs = pixRead("1555-7.jpg");
pixg = pixConvertTo8(pixs, 0);
l_setConvolveSampling(5, 5);
pixt1 = pixConvolve(pixg, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 12 */
pixSaveTiled(pixt1, pixa, 1, 1, 20, 32);
pixt2 = pixConvolveSep(pixg, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 13 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
pixt3 = pixConvolveRGB(pixs, kel);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 14 */
pixSaveTiled(pixt3, pixa, 1, 0, 20, 32);
pixt4 = pixConvolveRGBSep(pixs, kelx, kely);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 15 */
pixSaveTiled(pixt4, pixa, 1, 0, 20, 32);
/* Then on fpix */
fpixg = pixConvertToFPix(pixg, 1);
fpixt1 = fpixConvolve(fpixg, kel, 1);
pixt5 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt5, IFF_JFIF_JPEG); /* 16 */
pixSaveTiled(pixt5, pixa, 1, 1, 20, 32);
fpixt2 = fpixConvolveSep(fpixg, kelx, kely, 1);
pixt6 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt6, IFF_JFIF_JPEG); /* 17 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
regTestCompareSimilarPix(rp, pixt1, pixt5, 2, 0.00, 0); /* 18 */
regTestCompareSimilarPix(rp, pixt2, pixt6, 2, 0.00, 0); /* 19 */
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixg);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 20 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test extension (continued and slope).
* First, build a smooth vertical disparity array;
* then extend and show the contours. */
pixs = pixRead("cat-35.jpg");
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
dewa = dewarpaCreate(1, 30, 1, 15, 0);
dew = dewarpCreate(pixb, 35);
dewarpaInsertDewarp(dewa, dew);
dewarpBuildModel(dew, NULL);
dewarpPopulateFullRes(dew, NULL);
fpixs = dew->fullvdispar;
fpixs2 = fpixAddContinuedBorder(fpixs, 200, 200, 100, 300);
fpixs3 = fpixAddSlopeBorder(fpixs, 200, 200, 100, 300);
dpix = fpixConvertToDPix(fpixs3);
fpixs4 = dpixConvertToFPix(dpix);
pixt1 = fpixRenderContours(fpixs, 2.0, 0.2);
pixt2 = fpixRenderContours(fpixs2, 2.0, 0.2);
pixt3 = fpixRenderContours(fpixs3, 2.0, 0.2);
pixt4 = fpixRenderContours(fpixs4, 2.0, 0.2);
pixt5 = pixRead("karen8.jpg");
dpix2 = pixConvertToDPix(pixt5, 1);
pixt6 = dpixConvertToPix(dpix2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 21 */
pixDisplayWithTitle(pixt1, 0, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 22 */
pixDisplayWithTitle(pixt2, 470, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 23 */
pixDisplayWithTitle(pixt3, 1035, 100, NULL, rp->display);
regTestComparePix(rp, pixt3, pixt4); /* 24 */
regTestComparePix(rp, pixt5, pixt6); /* 25 */
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixs4);
dpixDestroy(&dpix);
dpixDestroy(&dpix2);
/* Test affine and projective transforms on fpix */
fpixWrite("/tmp/fpix1.fp", dew->fullvdispar);
fpix1 = fpixRead("/tmp/fpix1.fp");
pixt1 = fpixAutoRenderContours(fpix1, 40);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 26 */
pixDisplayWithTitle(pixt1, 0, 500, NULL, rp->display);
pixDestroy(&pixt1);
MakePtasAffine(1, &ptas, &ptad);
fpix2 = fpixAffinePta(fpix1, ptad, ptas, 200, 0.0);
pixt2 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 27 */
pixDisplayWithTitle(pixt2, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pixt2);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
MakePtas(1, &ptas, &ptad);
fpix2 = fpixProjectivePta(fpix1, ptad, ptas, 200, 0.0);
pixt3 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 28 */
pixDisplayWithTitle(pixt3, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pixt3);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
fpixDestroy(&fpix1);
dewarpaDestroy(&dewa);
kernelDestroy(&kel);
kernelDestroy(&kelx);
kernelDestroy(&kely);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_float32 scalefact;
L_BMF *bmf, *bmftop;
L_KERNEL *kel, *kelx, *kely;
PIX *pixs, *pixg, *pixt, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ----------------- Test on 8 bpp grayscale ---------------------*/
pixa = pixaCreate(5);
bmf = bmfCreate("./fonts", 6);
bmftop = bmfCreate("./fonts", 10);
pixs = pixRead("lucasta-47.jpg");
pixg = pixScale(pixs, 0.4, 0.4); /* 8 bpp grayscale */
pix1 = pixConvertTo32(pixg); /* 32 bpp rgb */
AddTextAndSave(pixa, pix1, 1, bmf, textstr[0], L_ADD_BELOW, 0xff000000);
pix2 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_RGB);
AddTextAndSave(pixa, pix2, 0, bmf, textstr[1], L_ADD_BELOW, 0x00ff0000);
pix3 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_BGR);
AddTextAndSave(pixa, pix3, 0, bmf, textstr[2], L_ADD_BELOW, 0x0000ff00);
pix4 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_VRGB);
AddTextAndSave(pixa, pix4, 0, bmf, textstr[3], L_ADD_BELOW, 0x00ff0000);
pix5 = pixConvertGrayToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_VBGR);
AddTextAndSave(pixa, pix5, 0, bmf, textstr[4], L_ADD_BELOW, 0x0000ff00);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop,
"Regression test for subpixel scaling: gray",
0xff00ff00, L_ADD_ABOVE, NULL);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 0 */
pixDisplayWithTitle(pixd, 50, 50, NULL, rp->display);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
/* ----------------- Test on 32 bpp rgb ---------------------*/
pixa = pixaCreate(5);
pixs = pixRead("fish24.jpg");
pix1 = pixScale(pixs, 0.4, 0.4);
AddTextAndSave(pixa, pix1, 1, bmf, textstr[0], L_ADD_BELOW, 0xff000000);
pix2 = pixConvertToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_RGB);
AddTextAndSave(pixa, pix2, 0, bmf, textstr[1], L_ADD_BELOW, 0x00ff0000);
pix3 = pixConvertToSubpixelRGB(pixs, 0.4, 0.35, L_SUBPIXEL_ORDER_BGR);
AddTextAndSave(pixa, pix3, 0, bmf, textstr[2], L_ADD_BELOW, 0x0000ff00);
pix4 = pixConvertToSubpixelRGB(pixs, 0.4, 0.45, L_SUBPIXEL_ORDER_VRGB);
AddTextAndSave(pixa, pix4, 0, bmf, textstr[3], L_ADD_BELOW, 0x00ff0000);
pix5 = pixConvertToSubpixelRGB(pixs, 0.4, 0.4, L_SUBPIXEL_ORDER_VBGR);
AddTextAndSave(pixa, pix5, 0, bmf, textstr[4], L_ADD_BELOW, 0x0000ff00);
pixt = pixaDisplay(pixa, 0, 0);
pixd = pixAddSingleTextblock(pixt, bmftop,
"Regression test for subpixel scaling: color",
0xff00ff00, L_ADD_ABOVE, NULL);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 1 */
pixDisplayWithTitle(pixd, 50, 350, NULL, rp->display);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixt);
pixDestroy(&pixd);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
bmfDestroy(&bmf);
bmfDestroy(&bmftop);
/* --------------- Test on images that are initially 1 bpp ------------*/
/* For these, it is better to apply a lowpass filter before scaling */
/* Normal scaling of 8 bpp grayscale */
scalefact = 800. / 2320.;
pixs = pixRead("patent.png"); /* sharp, 300 ppi, 1 bpp image */
pix1 = pixConvertTo8(pixs, FALSE); /* use 8 bpp input */
pix2 = pixScale(pix1, scalefact, scalefact);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 2 */
/* Subpixel scaling; bad because there is very little aliasing. */
pix3 = pixConvertToSubpixelRGB(pix1, scalefact, scalefact,
L_SUBPIXEL_ORDER_RGB);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3 */
/* Get same (bad) result doing subpixel rendering on RGB input */
pix4 = pixConvertTo32(pixs);
pix5 = pixConvertToSubpixelRGB(pix4, scalefact, scalefact,
L_SUBPIXEL_ORDER_RGB);
regTestComparePix(rp, pix3, pix5); /* 4 */
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 5 */
/* Now apply a small lowpass filter before scaling. */
makeGaussianKernelSep(2, 2, 1.0, 1.0, &kelx, &kely);
startTimer();
pix6 = pixConvolveSep(pix1, kelx, kely, 8, 1); /* normalized */
fprintf(stderr, "Time sep: %7.3f\n", stopTimer());
regTestWritePixAndCheck(rp, pix6, IFF_PNG); /* 6 */
/* Get same lowpass result with non-separated convolution */
kel = makeGaussianKernel(2, 2, 1.0, 1.0);
startTimer();
pix7 = pixConvolve(pix1, kel, 8, 1); /* normalized */
fprintf(stderr, "Time non-sep: %7.3f\n", stopTimer());
regTestComparePix(rp, pix6, pix7); /* 7 */
/* Now do the subpixel scaling on this slightly blurred image */
pix8 = pixConvertToSubpixelRGB(pix6, scalefact, scalefact,
L_SUBPIXEL_ORDER_RGB);
regTestWritePixAndCheck(rp, pix8, IFF_PNG); /* 8 */
kernelDestroy(&kelx);
kernelDestroy(&kely);
kernelDestroy(&kel);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
L_BMF *bmf;
PIX *pixs1, *pixs2, *pixg, *pixt, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
bmf = bmfCreate("./fonts", 8);
pixs1 = pixCreate(301, 301, 32);
pixs2 = pixCreate(601, 601, 32);
pixSetAll(pixs1);
pixSetAll(pixs2);
pixRenderLineArb(pixs1, 0, 20, 300, 20, 5, 0, 0, 255);
pixRenderLineArb(pixs1, 0, 70, 300, 70, 5, 0, 255, 0);
pixRenderLineArb(pixs1, 0, 120, 300, 120, 5, 0, 255, 255);
pixRenderLineArb(pixs1, 0, 170, 300, 170, 5, 255, 0, 0);
pixRenderLineArb(pixs1, 0, 220, 300, 220, 5, 255, 0, 255);
pixRenderLineArb(pixs1, 0, 270, 300, 270, 5, 255, 255, 0);
pixRenderLineArb(pixs2, 0, 20, 300, 20, 5, 0, 0, 255);
pixRenderLineArb(pixs2, 0, 70, 300, 70, 5, 0, 255, 0);
pixRenderLineArb(pixs2, 0, 120, 300, 120, 5, 0, 255, 255);
pixRenderLineArb(pixs2, 0, 170, 300, 170, 5, 255, 0, 0);
pixRenderLineArb(pixs2, 0, 220, 300, 220, 5, 255, 0, 255);
pixRenderLineArb(pixs2, 0, 270, 300, 270, 5, 255, 255, 0);
/* Color, small pix */
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_LEFT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_RIGHT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_LEFT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_RIGHT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 50, 50, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Grayscale, small pix */
pixg = pixConvertTo8(pixs1, 0);
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 250, 50, NULL, rp->display);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Color, larger pix */
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_LEFT,
120, -40, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_RIGHT,
120, -40, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_LEFT,
120, -40, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_RIGHT,
120, -40, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 550, 50, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Grayscale, larger pix */
pixg = pixConvertTo8(pixs2, 0);
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 850, 50, NULL, rp->display);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
bmfDestroy(&bmf);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *array1, *array2;
l_int32 n1, n2, n3;
size_t size1, size2;
FILE *fp;
BOXA *boxa1, *boxa2;
PIX *pixs, *pix1;
PIXA *pixa1;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixs = pixRead("feyn.tif");
/* --------------------------------------------------------------- *
* Test pixConnComp() and pixCountConnComp(), *
* with output to both boxa and pixa *
* --------------------------------------------------------------- */
/* First, test with 4-cc */
boxa1= pixConnComp(pixs, &pixa1, 4);
n1 = boxaGetCount(boxa1);
boxa2= pixConnComp(pixs, NULL, 4);
n2 = boxaGetCount(boxa2);
pixCountConnComp(pixs, 4, &n3);
fprintf(stderr, "Number of 4 c.c.: n1 = %d; n2 = %d, n3 = %d\n",
n1, n2, n3);
regTestCompareValues(rp, n1, n2, 0); /* 0 */
regTestCompareValues(rp, n1, n3, 0); /* 1 */
regTestCompareValues(rp, n1, 4452, 0); /* 2 */
pix1 = pixaDisplay(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 3 */
regTestComparePix(rp, pixs, pix1); /* 4 */
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixDestroy(&pix1);
/* Test with 8-cc */
boxa1= pixConnComp(pixs, &pixa1, 8);
n1 = boxaGetCount(boxa1);
boxa2= pixConnComp(pixs, NULL, 8);
n2 = boxaGetCount(boxa2);
pixCountConnComp(pixs, 8, &n3);
fprintf(stderr, "Number of 8 c.c.: n1 = %d; n2 = %d, n3 = %d\n",
n1, n2, n3);
regTestCompareValues(rp, n1, n2, 0); /* 5 */
regTestCompareValues(rp, n1, n3, 0); /* 6 */
regTestCompareValues(rp, n1, 4305, 0); /* 7 */
pix1 = pixaDisplay(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 8 */
regTestComparePix(rp, pixs, pix1); /* 9 */
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixDestroy(&pix1);
/* --------------------------------------------------------------- *
* Test boxa I/O *
* --------------------------------------------------------------- */
lept_mkdir("lept/conn");
boxa1 = pixConnComp(pixs, NULL, 4);
fp = lept_fopen("/tmp/lept/conn/boxa1.ba", "wb+");
boxaWriteStream(fp, boxa1);
lept_fclose(fp);
fp = lept_fopen("/tmp/lept/conn/boxa1.ba", "rb");
boxa2 = boxaReadStream(fp);
lept_fclose(fp);
fp = lept_fopen("/tmp/lept/conn/boxa2.ba", "wb+");
boxaWriteStream(fp, boxa2);
lept_fclose(fp);
array1 = l_binaryRead("/tmp/lept/conn/boxa1.ba", &size1);
array2 = l_binaryRead("/tmp/lept/conn/boxa2.ba", &size2);
regTestCompareStrings(rp, array1, size1, array2, size2); /* 10 */
lept_free(array1);
lept_free(array2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* --------------------------------------------------------------- *
* Just for fun, display each component as a random color in *
* cmapped 8 bpp. Background is color 0; it is set to white. *
* --------------------------------------------------------------- */
boxa1 = pixConnComp(pixs, &pixa1, 4);
pix1 = pixaDisplayRandomCmap(pixa1, pixGetWidth(pixs), pixGetHeight(pixs));
cmap = pixGetColormap(pix1);
pixcmapResetColor(cmap, 0, 255, 255, 255); /* reset background to white */
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 11 */
if (rp->display) pixDisplay(pix1, 100, 100);
boxaDestroy(&boxa1);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixDestroy(&pixs);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 w, h, d, w2, h2, i, ncols, ret;
l_float32 angle, conf;
BOX *box;
BOXA *boxa, *boxa2;
PIX *pix, *pixs, *pixb, *pixb2, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIXA *pixam; /* mask with a single component over each column */
PIXA *pixac, *pixad, *pixat;
PIXAA *pixaa, *pixaa2;
SEL *selsplit;
static char mainName[] = "arabic_lines";
if (argc != 1)
return ERROR_INT(" Syntax: arabic_lines", mainName, 1);
pixDisplayWrite(NULL, -1); /* init debug output */
/* Binarize input */
pixs = pixRead("arabic.png");
pixGetDimensions(pixs, &w, &h, &d);
pix = pixConvertTo1(pixs, 128);
/* Deskew */
pixb = pixFindSkewAndDeskew(pix, 1, &angle, &conf);
pixDestroy(&pix);
fprintf(stderr, "Skew angle: %7.2f degrees; %6.2f conf\n", angle, conf);
pixDisplayWrite(pixb, 1);
/* Use full image morphology to find columns, at 2x reduction.
This only works for very simple layouts where each column
of text extends the full height of the input image. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pix1 = pixMorphCompSequence(pixb2, "c5.500", 0);
boxa = pixConnComp(pix1, &pixam, 8);
ncols = boxaGetCount(boxa);
fprintf(stderr, "Num columns: %d\n", ncols);
pixDisplayWrite(pix1, 1);
/* Use selective region-based morphology to get the textline mask. */
pixad = pixaMorphSequenceByRegion(pixb2, pixam, "c100.3", 0, 0);
pixGetDimensions(pixb2, &w2, &h2, NULL);
pix2 = pixaDisplay(pixad, w2, h2);
pixDisplayWrite(pix2, 1);
pixDestroy(&pix2);
/* Some of the lines may be touching, so use a HMT to split the
lines in each column, and use a pixaa to save the results. */
selsplit = selCreateFromString(seltext, 17, 7, "selsplit");
pixaa = pixaaCreate(ncols);
for (i = 0; i < ncols; i++) {
pix3 = pixaGetPix(pixad, i, L_CLONE);
box = pixaGetBox(pixad, i, L_COPY);
pix4 = pixHMT(NULL, pix3, selsplit);
pixXor(pix4, pix4, pix3);
boxa2 = pixConnComp(pix4, &pixac, 8);
pixaaAddPixa(pixaa, pixac, L_INSERT);
pixaaAddBox(pixaa, box, L_INSERT);
pix5 = pixaDisplayRandomCmap(pixac, 0, 0);
pixDisplayWrite(pix5, 1);
fprintf(stderr, "Num textlines in col %d: %d\n", i,
boxaGetCount(boxa2));
pixDestroy(&pix5);
pixDestroy(&pix3);
pixDestroy(&pix4);
boxaDestroy(&boxa2);
}
/* Visual output */
ret = system("gthumb /tmp/display/file* &");
pixat = pixaReadFiles("/tmp/display", "file");
pix5 = selDisplayInPix(selsplit, 31, 2);
pixaAddPix(pixat, pix5, L_INSERT);
pix6 = pixaDisplayTiledAndScaled(pixat, 32, 400, 3, 0, 35, 3);
pixWrite("/tmp/result.png", pix6, IFF_PNG);
pixaDestroy(&pixat);
pixDestroy(&pix6);
/* Test pixaa I/O */
pixaaWrite("/tmp/pixaa", pixaa);
pixaa2 = pixaaRead("/tmp/pixaa");
pixaaWrite("/tmp/pixaa2", pixaa2);
/* Test pixaa display */
pixd = pixaaDisplay(pixaa, w2, h2);
pixWrite("/tmp/textlines.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Cleanup */
pixDestroy(&pixb2);
pixDestroy(&pix1);
pixaDestroy(&pixam);
pixaDestroy(&pixad);
pixaaDestroy(&pixaa);
pixaaDestroy(&pixaa2);
boxaDestroy(&boxa);
selDestroy(&selsplit);
pixDestroy(&pixs);
pixDestroy(&pixb);
return 0;
}
