int main(int argc,
char **argv) {
l_int32 w, d, tilewidth;
PIX *pixs;
PIXA *pixa, *pixad1, *pixad2;
PIXAA *pixaa1, *pixaa2;
static char mainName[] = "pixaatest";
if (argc != 1)
return ERROR_INT(" Syntax: pixaatest", mainName, 1);
/* Read in file, split it into a set of tiles, and generate a pdf.
* Two things to note for these tiny images:
* (1) If you use dct format (jpeg) for each image instead of
* flate (lossless), the quantization will be apparent.
* (2) If the resolution in pixaConvertToPdf() is above 50, and
* you add a red boundary, you will see errors in the boundary
* width.
*/
pixs = pixRead("test24.jpg");
pixGetDimensions(pixs, &w, NULL, &d);
pixa = pixaSplitPix(pixs, nx, ny, 0, 0);
/* pixa = pixaSplitPix(pixs, nx, ny, 2, 0xff000000); */ /* red border */
pixWrite("/tmp/junk0", pixa->pix[0], IFF_PNG);
pixWrite("/tmp/junk9", pixa->pix[9], IFF_PNG);
pixaConvertToPdf(pixa, 50, 1.0, 0, 95, "individual", "/tmp/junkout0.pdf");
/* Generate two pixaa by sampling the pixa, and write them to file */
pixaa1 = pixaaCreateFromPixa(pixa, nx, L_CHOOSE_CONSECUTIVE, L_CLONE);
pixaa2 = pixaaCreateFromPixa(pixa, nx, L_CHOOSE_SKIP_BY, L_CLONE);
pixaaWrite("/tmp/pixaa1.paa", pixaa1);
pixaaWrite("/tmp/pixaa2.paa", pixaa2);
pixaDestroy(&pixa);
pixaaDestroy(&pixaa1);
pixaaDestroy(&pixaa2);
/* Read each pixaa from file; tile/scale into a pixa */
pixaa1 = pixaaRead("/tmp/pixaa1.paa");
pixaa2 = pixaaRead("/tmp/pixaa2.paa");
tilewidth = w / nx;
pixad1 = pixaaDisplayTiledAndScaled(pixaa1, d, tilewidth, ncols, 0, 10, 0);
pixad2 = pixaaDisplayTiledAndScaled(pixaa2, d, tilewidth, ncols, 0, 10, 0);
/* Generate a pdf from each pixa */
pixaConvertToPdf(pixad1, 50, 1.0, 0, 75, "consecutive", "/tmp/junkout1.pdf");
pixaConvertToPdf(pixad2, 50, 1.0, 0, 75, "skip_by", "/tmp/junkout2.pdf");
/* Write each pixa to a set of files, and generate a PS */
pixaWriteFiles("/tmp/junksplit1.", pixad1, IFF_JFIF_JPEG);
pixaWriteFiles("/tmp/junksplit2.", pixad2, IFF_JFIF_JPEG);
convertFilesToPS("/tmp", "junksplit1", 40, "/tmp/junkout1.ps");
convertFilesToPS("/tmp", "junksplit2", 40, "/tmp/junkout2.ps");
pixDestroy(&pixs);
pixaaDestroy(&pixaa1);
pixaaDestroy(&pixaa2);
pixaDestroy(&pixad1);
pixaDestroy(&pixad2);
return 0;
}
int main(int argc,
char **argv)
{
char buf[256];
l_int32 w, h, i, j, k, index, op, dir, stretch;
l_float32 del, angle, angledeg;
BOX *box;
L_BMF *bmf;
PIX *pixs, *pix1, *pix2, *pixd;
PIXA *pixa;
static char mainName[] = "warpertest";
if (argc != 1)
return ERROR_INT("syntax: warpertest", mainName, 1);
bmf = bmfCreate(NULL, 6);
/* -------- Stereoscopic warping --------------*/
#if RUN_WARP
pixs = pixRead("german.png");
pixGetDimensions(pixs, &w, &h, NULL);
pixa = pixaCreate(50);
for (i = 0; i < 50; i++) { /* need to test > 2 widths ! */
j = 7 * i;
box = boxCreate(0, 0, w - j, h - j);
pix1 = pixClipRectangle(pixs, box, NULL);
pixd = pixWarpStereoscopic(pix1, 15, 22, 8, 30, -20, 1);
pixSetChromaSampling(pixd, 0);
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pix1);
boxDestroy(&box);
}
pixDestroy(&pixs);
pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0, "warp.pdf",
"/tmp/warp.pdf");
pixd = pixaDisplayTiledInRows(pixa, 32, 2000, 1.0, 0, 20, 2);
pixWrite("/tmp/warp.jpg", pixd, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
#endif
/* -------- Quadratic Vertical Shear --------------*/
#if RUN_QUAD_VERT_SHEAR
pixs = pixCreate(501, 501, 32);
pixGetDimensions(pixs, &w, &h, NULL);
pixSetAll(pixs);
pixRenderLineArb(pixs, 0, 30, 500, 30, 5, 0, 0, 255);
pixRenderLineArb(pixs, 0, 110, 500, 110, 5, 0, 255, 0);
pixRenderLineArb(pixs, 0, 190, 500, 190, 5, 0, 255, 255);
pixRenderLineArb(pixs, 0, 270, 500, 270, 5, 255, 0, 0);
pixRenderLineArb(pixs, 0, 360, 500, 360, 5, 255, 0, 255);
pixRenderLineArb(pixs, 0, 450, 500, 450, 5, 255, 255, 0);
pixa = pixaCreate(50);
for (i = 0; i < 50; i++) {
j = 3 * i;
dir = ((i / 2) & 1) ? L_WARP_TO_RIGHT : L_WARP_TO_LEFT;
op = (i & 1) ? L_INTERPOLATED : L_SAMPLED;
box = boxCreate(0, 0, w - j, h - j);
pix1 = pixClipRectangle(pixs, box, NULL);
pix2 = pixQuadraticVShear(pix1, dir, 60, -20, op, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%s, %s", dirstr[dir], opstr[op]);
pixd = pixAddSingleTextblock(pix2, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
boxDestroy(&box);
}
pixDestroy(&pixs);
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0, "quad_vshear.pdf",
"/tmp/quad_vshear.pdf");
pixd = pixaDisplayTiledInRows(pixa, 32, 2000, 1.0, 0, 20, 2);
pixWrite("/tmp/quad_vshear.jpg", pixd, IFF_PNG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
#endif
/* -------- Linear Horizontal stretching --------------*/
#if RUN_LIN_HORIZ_STRETCH
pixs = pixRead("german.png");
pixa = pixaCreate(50);
for (k = 0; k < 2; k++) {
for (i = 0; i < 25; i++) {
index = 25 * k + i;
stretch = 10 + 4 * i;
if (k == 0) stretch = -stretch;
dir = (k == 1) ? L_WARP_TO_RIGHT : L_WARP_TO_LEFT;
op = (i & 1) ? L_INTERPOLATED : L_SAMPLED;
pix1 = pixStretchHorizontal(pixs, dir, L_LINEAR_WARP,
stretch, op, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%s, %s", dirstr[dir], opstr[op]);
pixd = pixAddSingleTextblock(pix1, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pix1);
}
}
pixDestroy(&pixs);
pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0, "linear_hstretch.pdf",
"/tmp/linear_hstretch.pdf");
pixd = pixaDisplayTiledInRows(pixa, 32, 2500, 1.0, 0, 20, 2);
pixWrite("/tmp/linear_hstretch.jpg", pixd, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
#endif
/* -------- Quadratic Horizontal stretching --------------*/
#if RUN_QUAD_HORIZ_STRETCH
pixs = pixRead("german.png");
pixa = pixaCreate(50);
for (k = 0; k < 2; k++) {
for (i = 0; i < 25; i++) {
index = 25 * k + i;
stretch = 10 + 4 * i;
if (k == 0) stretch = -stretch;
dir = (k == 1) ? L_WARP_TO_RIGHT : L_WARP_TO_LEFT;
op = (i & 1) ? L_INTERPOLATED : L_SAMPLED;
pix1 = pixStretchHorizontal(pixs, dir, L_QUADRATIC_WARP,
stretch, op, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%s, %s", dirstr[dir], opstr[op]);
pixd = pixAddSingleTextblock(pix1, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pix1);
}
}
pixDestroy(&pixs);
pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0, "quad_hstretch.pdf",
"/tmp/quad_hstretch.pdf");
pixd = pixaDisplayTiledInRows(pixa, 32, 2500, 1.0, 0, 20, 2);
pixWrite("/tmp/quad_hstretch.jpg", pixd, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
#endif
/* -------- Horizontal Shear --------------*/
#if RUN_HORIZ_SHEAR
pixs = pixRead("german.png");
pixGetDimensions(pixs, &w, &h, NULL);
pixa = pixaCreate(50);
for (i = 0; i < 25; i++) {
del = 0.2 / 12.;
angle = -0.2 + (i - (i & 1)) * del;
angledeg = 180. * angle / 3.14159265;
op = (i & 1) ? L_INTERPOLATED : L_SAMPLED;
if (op == L_SAMPLED)
pix1 = pixHShear(NULL, pixs, h / 2, angle, L_BRING_IN_WHITE);
else
pix1 = pixHShearLI(pixs, h / 2, angle, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%6.2f degree, %s", angledeg, opstr[op]);
pixd = pixAddSingleTextblock(pix1, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pix1);
}
pixDestroy(&pixs);
pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0, "hshear.pdf",
"/tmp/hshear.pdf");
pixd = pixaDisplayTiledInRows(pixa, 32, 2500, 1.0, 0, 20, 2);
pixWrite("/tmp/hshear.jpg", pixd, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
#endif
/* -------- Vertical Shear --------------*/
#if RUN_VERT_SHEAR
pixs = pixRead("german.png");
pixGetDimensions(pixs, &w, &h, NULL);
pixa = pixaCreate(50);
for (i = 0; i < 25; i++) {
del = 0.2 / 12.;
angle = -0.2 + (i - (i & 1)) * del;
angledeg = 180. * angle / 3.14159265;
op = (i & 1) ? L_INTERPOLATED : L_SAMPLED;
if (op == L_SAMPLED)
pix1 = pixVShear(NULL, pixs, w / 2, angle, L_BRING_IN_WHITE);
else
pix1 = pixVShearLI(pixs, w / 2, angle, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%6.2f degree, %s", angledeg, opstr[op]);
pixd = pixAddSingleTextblock(pix1, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pix1);
}
pixDestroy(&pixs);
pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0, "vshear.pdf",
"/tmp/vshear.pdf");
pixd = pixaDisplayTiledInRows(pixa, 32, 2500, 1.0, 0, 20, 2);
pixWrite("/tmp/vshear.jpg", pixd, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
#endif
bmfDestroy(&bmf);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, j, sindex, wb, hb, ws, hs, delx, dely, x, y, y0;
PIX *pixs, *pixb, *pix1, *pix2;
PIXA *pixa;
PIXCMAP *cmap;
setLeptDebugOK(1);
lept_mkdir("lept/blend");
pixa = pixaCreate(0);
pixs = pixRead("rabi.png"); /* blendee */
pixb = pixRead("weasel4.11c.png"); /* blender */
/* Fade the blender */
pixcmapShiftIntensity(pixGetColormap(pixb), FADE_FRACTION);
/* Downscale the input */
wb = pixGetWidth(pixb);
hb = pixGetHeight(pixb);
pix1 = pixScaleToGray4(pixs);
/* Threshold to 5 levels, 4 bpp */
ws = pixGetWidth(pix1);
hs = pixGetHeight(pix1);
pix2 = pixThresholdTo4bpp(pix1, 5, 1);
pixaAddPix(pixa, pix2, L_COPY);
pixaAddPix(pixa, pixb, L_COPY);
cmap = pixGetColormap(pix2);
pixcmapWriteStream(stderr, cmap);
/* Overwrite the white pixels (at sindex in pix2) */
pixcmapGetIndex(cmap, 255, 255, 255, &sindex);
/* Blend the weasel 20 times */
delx = ws / NX;
dely = hs / NY;
for (i = 0; i < NY; i++) {
y = 20 + i * dely;
if (y >= hs + hb)
continue;
for (j = 0; j < NX; j++) {
x = 30 + j * delx;
y0 = y;
if (j & 1) {
y0 = y + dely / 2;
if (y0 >= hs + hb)
continue;
}
if (x >= ws + wb)
continue;
pixBlendCmap(pix2, pixb, x, y0, sindex);
}
}
pixaAddPix(pixa, pix2, L_COPY);
cmap = pixGetColormap(pix2);
pixcmapWriteStream(stderr, cmap);
fprintf(stderr, "Writing to: /tmp/lept/blend/blendcmap.pdf\n");
pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, "cmap-blendtest",
"/tmp/lept/blend/blendcmap.pdf");
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixaDestroy(&pixa);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 index;
l_uint32 val32;
BOX *box, *box1, *box2, *box3, *box4, *box5;
BOXA *boxa;
L_KERNEL *kel;
PIX *pixs, *pixg, *pixb, *pixd, *pixt, *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Color non-white pixels on RGB */
pixs = pixRead("lucasta-frag.jpg");
pixt = pixConvert8To32(pixs);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_DARK, 220, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 0 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_DARK, 220, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-white pixels on colormap */
pixt = pixThresholdTo4bpp(pixs, 6, 1);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_DARK, 220, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_DARK, 220, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 3 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-black pixels on RGB */
pixt = pixConvert8To32(pixs);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_LIGHT, 20, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_LIGHT, 80, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Color non-black pixels on colormap */
pixt = pixThresholdTo4bpp(pixs, 6, 1);
box = boxCreate(120, 30, 200, 200);
pixColorGray(pixt, box, L_PAINT_LIGHT, 20, 0, 0, 255);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 6 */
pixaAddPix(pixa, pixt, L_COPY);
pixColorGray(pixt, NULL, L_PAINT_LIGHT, 20, 255, 100, 100);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 7 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Add highlight color to RGB */
pixt = pixConvert8To32(pixs);
box = boxCreate(507, 5, 385, 45);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
pixDisplayWrite(pixb, 1);
composeRGBPixel(50, 0, 250, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
box = boxCreate(236, 107, 262, 40);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
composeRGBPixel(250, 0, 50, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
box = boxCreate(222, 208, 247, 43);
pixg = pixClipRectangle(pixs, box, NULL);
pixb = pixThresholdToBinary(pixg, 180);
pixInvert(pixb, pixb);
composeRGBPixel(60, 250, 60, &val32);
pixPaintThroughMask(pixt, pixb, box->x, box->y, val32);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 8 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Add highlight color to colormap */
pixt = pixThresholdTo4bpp(pixs, 5, 1);
cmap = pixGetColormap(pixt);
pixcmapGetIndex(cmap, 255, 255, 255, &index);
box = boxCreate(507, 5, 385, 45);
pixSetSelectCmap(pixt, box, index, 50, 0, 250);
boxDestroy(&box);
box = boxCreate(236, 107, 262, 40);
pixSetSelectCmap(pixt, box, index, 250, 0, 50);
boxDestroy(&box);
box = boxCreate(222, 208, 247, 43);
pixSetSelectCmap(pixt, box, index, 60, 250, 60);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 9 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Paint lines on RGB */
pixt = pixConvert8To32(pixs);
pixRenderLineArb(pixt, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt, 30, 40, 440, 40, 5, 100, 200, 25);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxArb(pixt, box, 3, 200, 200, 25);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 10 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Paint lines on colormap */
pixt = pixThresholdTo4bpp(pixs, 5, 1);
pixRenderLineArb(pixt, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt, 30, 40, 440, 40, 5, 100, 200, 25);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxArb(pixt, box, 3, 200, 200, 25);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 11 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Blend lines on RGB */
pixt = pixConvert8To32(pixs);
pixRenderLineBlend(pixt, 450, 20, 850, 320, 5, 200, 50, 125, 0.35);
pixRenderLineBlend(pixt, 30, 40, 440, 40, 5, 100, 200, 25, 0.35);
box = boxCreate(70, 80, 300, 245);
pixRenderBoxBlend(pixt, box, 3, 200, 200, 25, 0.6);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 12 */
pixaAddPix(pixa, pixt, L_INSERT);
boxDestroy(&box);
/* Colorize gray on cmapped image. */
pix1 = pixRead("lucasta.150.jpg");
pix2 = pixThresholdTo4bpp(pix1, 7, 1);
box1 = boxCreate(73, 206, 140, 27);
pixColorGrayCmap(pix2, box1, L_PAINT_LIGHT, 130, 207, 43);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 13 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "One box added");
box2 = boxCreate(255, 404, 197, 25);
pixColorGrayCmap(pix2, box2, L_PAINT_LIGHT, 230, 67, 119);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 14 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Two boxes added");
box3 = boxCreate(122, 756, 224, 22);
pixColorGrayCmap(pix2, box3, L_PAINT_DARK, 230, 67, 119);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 15 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Three boxes added");
box4 = boxCreate(11, 780, 147, 22);
pixColorGrayCmap(pix2, box4, L_PAINT_LIGHT, 70, 137, 229);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 16 */
pixaAddPix(pixa, pix2, L_COPY);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Four boxes added");
box5 = boxCreate(163, 605, 78, 22);
pixColorGrayCmap(pix2, box5, L_PAINT_LIGHT, 70, 137, 229);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 17 */
pixaAddPix(pixa, pix2, L_INSERT);
if (rp->display)
pixPrintStreamInfo(stderr, pix2, "Five boxes added");
pixDestroy(&pix1);
boxDestroy(&box1);
boxDestroy(&box2);
boxDestroy(&box3);
boxDestroy(&box4);
boxDestroy(&box5);
pixDestroy(&pixs);
/* Make a gray image and identify the fg pixels (val > 230) */
pixs = pixRead("feyn-fract.tif");
pix1 = pixConvertTo8(pixs, 0);
kel = makeGaussianKernel(2, 2, 1.5, 1.0);
pix2 = pixConvolve(pix1, kel, 8, 1);
pix3 = pixThresholdToBinary(pix2, 230);
boxa = pixConnComp(pix3, NULL, 8);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix3);
kernelDestroy(&kel);
/* Color the individual components in the gray image */
pix4 = pixColorGrayRegions(pix2, boxa, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 18 */
pixaAddPix(pixa, pix4, L_INSERT);
pixDisplayWithTitle(pix4, 0, 0, NULL, rp->display);
/* Threshold to 10 levels of gray */
pix3 = pixThresholdOn8bpp(pix2, 10, 1);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 19 */
pixaAddPix(pixa, pix3, L_COPY);
/* Color the individual components in the cmapped image */
pix4 = pixColorGrayRegions(pix3, boxa, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 20 */
pixaAddPix(pixa, pix4, L_INSERT);
pixDisplayWithTitle(pix4, 0, 100, NULL, rp->display);
boxaDestroy(&boxa);
/* Color the entire gray image (not component-wise) */
pixColorGray(pix2, NULL, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 21 */
pixaAddPix(pixa, pix2, L_INSERT);
/* Color the entire cmapped image (not component-wise) */
pixColorGray(pix3, NULL, L_PAINT_DARK, 230, 255, 0, 0);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 22 */
pixaAddPix(pixa, pix3, L_INSERT);
/* Reconstruct cmapped images */
pixd = ReconstructByValue(rp, "weasel2.4c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 23 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = ReconstructByValue(rp, "weasel4.11c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 24 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = ReconstructByValue(rp, "weasel8.240c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 25 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Fake reconstruct cmapped images, with one color into a band */
pixd = FakeReconstructByBand(rp, "weasel2.4c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 26 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = FakeReconstructByBand(rp, "weasel4.11c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 27 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = FakeReconstructByBand(rp, "weasel8.240c.png");
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 28 */
pixaAddPix(pixa, pixd, L_INSERT);
/* If in testing mode, make a pdf */
if (rp->display) {
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0,
"Colorize and paint", "/tmp/lept/regout/paint.pdf");
L_INFO("Output pdf: /tmp/lept/regout/paint.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 i, w, h;
PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Blending on a light image */
pix1 = pixRead("fish24.jpg");
pixGetDimensions(pix1, &w, &h, NULL);
for (i = 0; i < 3; i++) {
pix2 = pixRead(blenders[i]);
if (i == 2) {
pix3 = pixScale(pix2, 0.5, 0.5);
pixDestroy(&pix2);
pix2 = pix3;
}
pix3 = pixAddAlphaToBlend(pix2, 0.3, 0);
pix4 = pixMirroredTiling(pix3, w, h);
pix5 = pixBlendWithGrayMask(pix1, pix4, NULL, 0, 0);
pixaAddPix(pixa, pix5, L_INSERT);
regTestWritePixAndCheck(rp, pix5, IFF_JFIF_JPEG); /* 0 - 2 */
pixDisplayWithTitle(pix5, 200 * i, 0, NULL, rp->display);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
}
pixDestroy(&pix1);
/* Blending on a dark image */
pix0 = pixRead("karen8.jpg");
pix1 = pixScale(pix0, 2.0, 2.0);
pixGetDimensions(pix1, &w, &h, NULL);
for (i = 0; i < 2; i++) {
pix2 = pixRead(blenders[i]);
pix3 = pixAddAlphaToBlend(pix2, 0.3, 1);
pix4 = pixMirroredTiling(pix3, w, h);
pix5 = pixBlendWithGrayMask(pix1, pix4, NULL, 0, 0);
pixaAddPix(pixa, pix5, L_INSERT);
regTestWritePixAndCheck(rp, pix5, IFF_JFIF_JPEG); /* 3 - 4 */
pixDisplayWithTitle(pix5, 600 + 200 * i, 0, NULL, rp->display);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
}
pixaConvertToPdf(pixa, 100, 1.0, L_JPEG_ENCODE, 0,
"Blendings: blend4_reg", "/tmp/blend.pdf");
L_INFO("Output pdf: /tmp/blend.pdf\n", rp->testname);
pixDestroy(&pix0);
pixDestroy(&pix1);
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 1 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 2 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 3 */
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 4 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 5 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 6 */
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix1, 200, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
regTestCompareValues(rp, 1, same, 0.0); /* 8 */
regTestCompareValues(rp, 0.053, diffarea, 0.002); /* 9 */
regTestCompareValues(rp, 0.240, diffxor, 0.002); /* 10 */
regTestWritePixAndCheck(rp, pixdb, IFF_PNG); /* 11 */
pixDisplayWithTitle(pixdb, 400, 0, NULL, rp->display);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix1, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
regTestCompareValues(rp, 1, same, 0.0); /* 15 */
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* ----------- Test pixaDisplayBoxaa() ------------ */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
/* Check that the transpose is reversible */
regTestCompareValues(rp, 1, success, 0.0); /* 16 */
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 17 */
pixDisplayWithTitle(pix1, 0, 600, NULL, rp->display);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
l_pdfSetDateAndVersion(FALSE);
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
regTestCheckFile(rp, "/tmp/lept/boxa/show.pdf"); /* 18 */
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char label[512];
l_int32 rval, gval, bval, w, h, i, j, rwhite, gwhite, bwhite, count;
l_uint32 pixel;
GPLOT *gplot1, *gplot2;
NUMA *naseq, *na;
NUMAA *naa1, *naa2;
PIX *pixs, *pixt, *pixt0, *pixt1, *pixt2;
PIX *pixr, *pixg, *pixb; /* for color content extraction */
PIXA *pixa, *pixat;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Generate a pdf of results when called with display */
pixa = pixaCreate(0);
/* Generate colors by sampling hue with max sat and value.
* This image has been saved as 19-colors.png. */
pixat = pixaCreate(19);
for (i = 0; i < 19; i++) {
convertHSVToRGB((240 * i / 18), 255, 255, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &pixel);
pixt1 = pixCreate(50, 100, 32);
pixSetAllArbitrary(pixt1, pixel);
pixaAddPix(pixat, pixt1, L_INSERT);
}
pixt2 = pixaDisplayTiledInRows(pixat, 32, 1100, 1.0, 0, 0, 0);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 0 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixaDestroy(&pixat);
/* Colorspace conversion in rgb */
pixs = pixRead("wyom.jpg");
pixaAddPix(pixa, pixs, L_INSERT);
pixt = pixConvertRGBToHSV(NULL, pixs);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixt, L_COPY);
pixConvertHSVToRGB(pixt, pixt);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 2 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 3 */
pixaAddPix(pixa, pixt, L_COPY);
cmap = pixGetColormap(pixt);
if (rp->display) pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 4 */
pixaAddPix(pixa, pixt, L_COPY);
pixcmapConvertHSVToRGB(cmap);
if (rp->display) pixcmapWriteStream(stderr, cmap);
regTestWritePixAndCheck(rp, pixt, IFF_JFIF_JPEG); /* 5 */
pixaAddPix(pixa, pixt, L_INSERT);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
regTestWritePixAndCheck(rp, pixr, IFF_JFIF_JPEG); /* 6 */
pixaAddPix(pixa, pixr, L_INSERT);
regTestWritePixAndCheck(rp, pixg, IFF_JFIF_JPEG); /* 7 */
pixaAddPix(pixa, pixg, L_INSERT);
regTestWritePixAndCheck(rp, pixb, IFF_JFIF_JPEG); /* 8 */
pixaAddPix(pixa, pixb, L_INSERT);
/* Color content measurement. This tests the global
* mapping of (r,g,b) --> (white), for 20 different
* values of (r,g,b). For each mappings, we compute
* the color magnitude and threshold it at six values.
* For each of those six thresholds, we plot the
* fraction of pixels that exceeds the threshold
* color magnitude, where the red value (mapped to
* white) goes between 100 and 195. */
pixat = pixaCreate(20);
naseq = numaMakeSequence(100, 5, 20);
naa1 = numaaCreate(6);
naa2 = numaaCreate(6);
for (i = 0; i < 6; i++) {
na = numaCreate(20);
numaaAddNuma(naa1, na, L_COPY);
numaaAddNuma(naa2, na, L_INSERT);
}
pixGetDimensions(pixs, &w, &h, NULL);
for (i = 0; i < 20; i++) {
rwhite = 100 + 5 * i;
gwhite = 200 - 5 * i;
bwhite = 150;
pixt0 = pixGlobalNormRGB(NULL, pixs, rwhite, gwhite, bwhite, 255);
pixaAddPix(pixat, pixt0, L_INSERT);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_DIFF_FROM_AVERAGE_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa1, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
pixt1 = pixColorMagnitude(pixs, rwhite, gwhite, bwhite,
L_MAX_MIN_DIFF_FROM_2);
for (j = 0; j < 6; j++) {
pixt2 = pixThresholdToBinary(pixt1, 30 + 10 * j);
pixInvert(pixt2, pixt2);
pixCountPixels(pixt2, &count, NULL);
na = numaaGetNuma(naa2, j, L_CLONE);
numaAddNumber(na, (l_float32)count / (l_float32)(w * h));
numaDestroy(&na);
pixDestroy(&pixt2);
}
pixDestroy(&pixt1);
}
gplot1 = gplotCreate("/tmp/regout/colorspace.10", GPLOT_PNG,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/regout/colorspace.11", GPLOT_PNG,
"Fraction with given color (min diff)",
"white point space for red", "amount of color");
for (j = 0; j < 6; j++) {
na = numaaGetNuma(naa1, j, L_CLONE);
sprintf(label, "thresh %d", 30 + 10 * j);
gplotAddPlot(gplot1, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
na = numaaGetNuma(naa2, j, L_CLONE);
gplotAddPlot(gplot2, naseq, na, GPLOT_LINES, label);
numaDestroy(&na);
}
gplotMakeOutput(gplot1);
gplotMakeOutput(gplot2);
gplotDestroy(&gplot1);
gplotDestroy(&gplot2);
pixt1 = pixaDisplayTiledAndScaled(pixat, 32, 250, 4, 0, 10, 2);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 9 */
pixaAddPix(pixa, pixt1, L_INSERT);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", rp->display);
pixaDestroy(&pixat);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
/* Give gnuplot time to write out the files */
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
/* Save as golden files, or check against them */
regTestCheckFile(rp, "/tmp/regout/colorspace.10.png"); /* 10 */
regTestCheckFile(rp, "/tmp/regout/colorspace.11.png"); /* 11 */
if (rp->display) {
pixt = pixRead("/tmp/regout/colorspace.10.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixt = pixRead("/tmp/regout/colorspace.11.png");
pixaAddPix(pixa, pixt, L_INSERT);
pixaConvertToPdf(pixa, 0, 1.0, 0, 0, "colorspace tests",
"/tmp/regout/colorspace.pdf");
L_INFO("Output pdf: /tmp/regout/colorspace.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv) {
l_int32 i, n;
l_float32 a, b, c, d, e;
NUMA *nax, *nafit;
PIX *pixs, *pixn, *pixg, *pixb, *pixt1, *pixt2;
PIXA *pixa;
PTA *pta, *ptad;
PTAA *ptaa1, *ptaa2;
pixs = pixRead("cat-35.jpg");
/* pixs = pixRead("zanotti-78.jpg"); */
/* Normalize for varying background and binarize */
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
pixDestroy(&pixn);
pixDestroy(&pixg);
/* Get the textline centers */
pixa = pixaCreate(6);
ptaa1 = dewarpGetTextlineCenters(pixb, 0);
pixt1 = pixCreateTemplate(pixs);
pixSetAll(pixt1);
pixt2 = pixDisplayPtaa(pixt1, ptaa1);
pixWrite("/tmp/textline1.png", pixt2, IFF_PNG);
pixDisplayWithTitle(pixt2, 0, 100, "textline centers 1", 1);
pixaAddPix(pixa, pixt2, L_INSERT);
pixDestroy(&pixt1);
/* Remove short lines */
fprintf(stderr, "Num all lines = %d\n", ptaaGetCount(ptaa1));
ptaa2 = dewarpRemoveShortLines(pixb, ptaa1, 0.8, 0);
pixt1 = pixCreateTemplate(pixs);
pixSetAll(pixt1);
pixt2 = pixDisplayPtaa(pixt1, ptaa2);
pixWrite("/tmp/textline2.png", pixt2, IFF_PNG);
pixDisplayWithTitle(pixt2, 300, 100, "textline centers 2", 1);
pixaAddPix(pixa, pixt2, L_INSERT);
pixDestroy(&pixt1);
n = ptaaGetCount(ptaa2);
fprintf(stderr, "Num long lines = %d\n", n);
ptaaDestroy(&ptaa1);
pixDestroy(&pixb);
/* Long lines over input image */
pixt1 = pixCopy(NULL, pixs);
pixt2 = pixDisplayPtaa(pixt1, ptaa2);
pixWrite("/tmp/textline3.png", pixt2, IFF_PNG);
pixDisplayWithTitle(pixt2, 600, 100, "textline centers 3", 1);
pixaAddPix(pixa, pixt2, L_INSERT);
pixDestroy(&pixt1);
/* Quadratic fit to curve */
pixt1 = pixCopy(NULL, pixs);
for (i = 0; i < n; i++) {
pta = ptaaGetPta(ptaa2, i, L_CLONE);
ptaGetArrays(pta, &nax, NULL);
ptaGetQuadraticLSF(pta, &a, &b, &c, &nafit);
fprintf(stderr, "Quadratic: a = %10.6f, b = %7.3f, c = %7.3f\n",
a, b, c);
ptad = ptaCreateFromNuma(nax, nafit);
pixDisplayPta(pixt1, pixt1, ptad);
ptaDestroy(&pta);
ptaDestroy(&ptad);
numaDestroy(&nax);
numaDestroy(&nafit);
}
pixWrite("/tmp/textline4.png", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 900, 100, "textline centers 4", 1);
pixaAddPix(pixa, pixt1, L_INSERT);
/* Cubic fit to curve */
pixt1 = pixCopy(NULL, pixs);
for (i = 0; i < n; i++) {
pta = ptaaGetPta(ptaa2, i, L_CLONE);
ptaGetArrays(pta, &nax, NULL);
ptaGetCubicLSF(pta, &a, &b, &c, &d, &nafit);
fprintf(stderr, "Cubic: a = %10.6f, b = %10.6f, c = %7.3f, d = %7.3f\n",
a, b, c, d);
ptad = ptaCreateFromNuma(nax, nafit);
pixDisplayPta(pixt1, pixt1, ptad);
ptaDestroy(&pta);
ptaDestroy(&ptad);
numaDestroy(&nax);
numaDestroy(&nafit);
}
pixWrite("/tmp/textline5.png", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 1200, 100, "textline centers 5", 1);
pixaAddPix(pixa, pixt1, L_INSERT);
/* Quartic fit to curve */
pixt1 = pixCopy(NULL, pixs);
for (i = 0; i < n; i++) {
pta = ptaaGetPta(ptaa2, i, L_CLONE);
ptaGetArrays(pta, &nax, NULL);
ptaGetQuarticLSF(pta, &a, &b, &c, &d, &e, &nafit);
fprintf(stderr,
"Quartic: a = %7.3f, b = %7.3f, c = %9.5f, d = %7.3f, e = %7.3f\n",
a, b, c, d, e);
ptad = ptaCreateFromNuma(nax, nafit);
pixDisplayPta(pixt1, pixt1, ptad);
ptaDestroy(&pta);
ptaDestroy(&ptad);
numaDestroy(&nax);
numaDestroy(&nafit);
}
pixWrite("/tmp/textline6.png", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 1500, 100, "textline centers 6", 1);
pixaAddPix(pixa, pixt1, L_INSERT);
pixaConvertToPdf(pixa, 300, 0.5, L_JPEG_ENCODE, 75,
"LS fittings to textlines", "/tmp/dewarp_fittings.pdf");
pixaDestroy(&pixa);
pixDestroy(&pixs);
ptaaDestroy(&ptaa2);
return 0;
}
l_int32 main(int argc,
char **argv)
{
char buf[512];
l_int32 i, n, index;
l_int32 rval[4], gval[4], bval[4];
l_uint32 scolor, dcolor;
L_BMF *bmf;
PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5;
PIXA *pixa;
PIXCMAP *cmap;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* Read in the bg colors */
for (i = 0; i < 4; i++)
sscanf(bgcolors[i], "%d %d %d", &rval[i], &gval[i], &bval[i]);
bmf = bmfCreate("fonts", 8);
/* Get the input image (100 ppi resolution) */
pix0 = pixRead("harmoniam100-11.png");
cmap = pixGetColormap(pix0);
pixa = pixaCreate(0);
/* Do cmapped coloring on the white pixels only */
pixcmapGetIndex(cmap, 255, 255, 255, &index); /* index of white pixels */
for (i = 0; i < 4; i++) {
pixcmapResetColor(cmap, index, rval[i], gval[i], bval[i]);
snprintf(buf, sizeof(buf), "(rval, bval, gval) = (%d, %d, %d)",
rval[i], gval[i], bval[i]);
pix1 = pixAddSingleTextblock(pix0, bmf, buf, 0xff000000,
L_ADD_AT_BOT, NULL);
pixaAddPix(pixa, pix1, L_INSERT);
}
/* Do cmapped background coloring on all the pixels */
for (i = 0; i < 4; i++) {
scolor = 0xffffff00; /* source color */
composeRGBPixel(rval[i], gval[i], bval[i], &dcolor); /* dest color */
pix1 = pixShiftByComponent(NULL, pix0, scolor, dcolor);
snprintf(buf, sizeof(buf), "(rval, bval, gval) = (%d, %d, %d)",
rval[i], gval[i], bval[i]);
pix2 = pixAddSingleTextblock(pix1, bmf, buf, 0xff000000,
L_ADD_AT_BOT, NULL);
pixaAddPix(pixa, pix2, L_INSERT);
pixDestroy(&pix1);
}
/* Do background coloring on rgb */
pix1 = pixConvertTo32(pix0);
for (i = 0; i < 4; i++) {
scolor = 0xffffff00;
composeRGBPixel(rval[i], gval[i], bval[i], &dcolor);
pix2 = pixShiftByComponent(NULL, pix1, scolor, dcolor);
snprintf(buf, sizeof(buf), "(rval, bval, gval) = (%d, %d, %d)",
rval[i], gval[i], bval[i]);
pix3 = pixAddSingleTextblock(pix2, bmf, buf, 0xff000000,
L_ADD_AT_BOT, NULL);
pixaAddPix(pixa, pix3, L_INSERT);
pixDestroy(&pix2);
}
pixDestroy(&pix1);
/* Compare cmapped & rgb foreground coloring */
scolor = 0x0; /* source color */
composeRGBPixel(200, 30, 150, &dcolor); /* ugly fg dest color */
pix1 = pixShiftByComponent(NULL, pix0, scolor, dcolor); /* cmapped */
snprintf(buf, sizeof(buf), "(rval, bval, gval) = (%d, %d, %d)",
200, 100, 50);
pix2 = pixAddSingleTextblock(pix1, bmf, buf, 0xff000000,
L_ADD_AT_BOT, NULL);
pixaAddPix(pixa, pix2, L_INSERT);
pix3 = pixConvertTo32(pix0);
pix4 = pixShiftByComponent(NULL, pix3, scolor, dcolor); /* rgb */
snprintf(buf, sizeof(buf), "(rval, bval, gval) = (%d, %d, %d)",
200, 100, 50);
pix5 = pixAddSingleTextblock(pix4, bmf, buf, 0xff000000,
L_ADD_AT_BOT, NULL);
pixaAddPix(pixa, pix5, L_INSERT);
regTestComparePix(rp, pix1, pix4);
regTestComparePix(rp, pix2, pix5);
pixDestroy(&pix1);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Log all the results */
n = pixaGetCount(pixa);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
regTestWritePixAndCheck(rp, pix1, IFF_PNG);
pixDestroy(&pix1);
}
/* If in testing mode, make a pdf */
if (rp->display) {
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0,
"Colored background", "/tmp/regout/coloring.pdf");
L_INFO("Output pdf: /tmp/regout/coloring.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
pixDestroy(&pix0);
bmfDestroy(&bmf);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_int32 w, h, ystart, yend, y, ymax, ymid, i, window, sum1, sum2, rankx;
l_uint32 uval;
l_float32 ave, rankval, maxvar, variance, norm, conf, angle, radangle;
NUMA *na1;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7;
PIXA *pixa;
static char mainName[] = "findbinding";
if (argc != 1)
return ERROR_INT(" Syntax: findbinding", mainName, 1);
lept_mkdir("lept/binding");
pixa = pixaCreate(0);
pix1 = pixRead("binding-example.45.jpg");
pix2 = pixConvertTo8(pix1, 0);
/* Find the skew angle */
pix3 = pixConvertTo1(pix2, 150);
pixFindSkewSweepAndSearch(pix3, &angle, &conf, 2, 2, 7.0, 1.0, 0.01);
fprintf(stderr, "angle = %f, conf = %f\n", angle, conf);
/* Deskew, bringing in black pixels at the edges */
if (L_ABS(angle) < 0.1 || conf < 1.5) {
pix4 = pixClone(pix2);
} else {
radangle = 3.1416 * angle / 180.0;
pix4 = pixRotate(pix2, radangle, L_ROTATE_AREA_MAP,
L_BRING_IN_BLACK, 0, 0);
}
/* Rotate 90 degrees to make binding horizontal */
pix5 = pixRotateOrth(pix4, 1);
/* Sort pixels in each row by their gray value.
* Dark pixels on the left, light ones on the right. */
pix6 = pixRankRowTransform(pix5);
pixDisplay(pix5, 0, 0);
pixDisplay(pix6, 550, 0);
pixaAddPix(pixa, pix4, L_COPY);
pixaAddPix(pixa, pix5, L_COPY);
pixaAddPix(pixa, pix6, L_COPY);
/* Make an a priori estimate of the y-interval within which the
* binding will be found. The search will be done in this interval. */
pixGetDimensions(pix6, &w, &h, NULL);
ystart = 0.25 * h;
yend = 0.75 * h;
/* Choose a very light rank value; close to white, which
* corresponds to a column in pix6 near the right side. */
rankval = 0.98;
rankx = (l_int32)(w * rankval);
/* Investigate variance in a small window (vertical, size = 5)
* of the pixels in that column. These are the %rankval
* pixels in each raster of pix6. Find the y-location of
* maximum variance. */
window = 5;
norm = 1.0 / window;
maxvar = 0.0;
na1 = numaCreate(0);
numaSetParameters(na1, ystart, 1);
for (y = ystart; y <= yend; y++) {
sum1 = sum2 = 0;
for (i = 0; i < window; i++) {
pixGetPixel(pix6, rankx, y + i, &uval);
sum1 += uval;
sum2 += uval * uval;
}
ave = norm * sum1;
variance = norm * sum2 - ave * ave;
numaAddNumber(na1, variance);
ymid = y + window / 2;
if (variance > maxvar) {
maxvar = variance;
ymax = ymid;
}
}
/* Plot the windowed variance as a function of the y-value
* of the window location */
fprintf(stderr, "maxvar = %f, ymax = %d\n", maxvar, ymax);
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/binding/root", NULL);
pix7 = pixRead("/tmp/lept/binding/root.png");
pixDisplay(pix7, 0, 800);
pixaAddPix(pixa, pix7, L_COPY);
/* Superimpose the variance plot over the image.
* The variance peak is at the binding. */
pixRenderPlotFromNumaGen(&pix5, na1, L_VERTICAL_LINE, 3, w - 120, 100, 1,
0x0000ff00);
pixDisplay(pix5, 1050, 0);
pixaAddPix(pixa, pix5, L_COPY);
/* Bundle the results up in a pdf */
fprintf(stderr, "Writing pdf output file: /tmp/lept/binding/binding.pdf\n");
pixaConvertToPdf(pixa, 45, 1.0, 0, 0, "Binding locator",
"/tmp/lept/binding/binding.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixaDestroy(&pixa);
numaDestroy(&na1);
return 0;
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
static char mainName[] = "boxa1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: boxa1_reg", mainName, 1);
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
pixDisplay(pix1, 100, 100);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
pixDisplay(pix1, 100, 500);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
pixDisplay(pixdb, 700, 100);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 0, 100);
pixWrite("/tmp/lept/boxa/pix1.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 500, 100);
pixWrite("/tmp/lept/boxa/pix2.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 1000, 100);
pixWrite("/tmp/lept/boxa/pix3.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
if (same)
fprintf(stderr, "Good: boxes files are identical\n");
else
fprintf(stderr, "Bad: boxes files differ\n");
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* Test pixaDisplayBoxaa() */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
if (success)
fprintf(stderr, "Good: transpose is reversible\n");
else
fprintf(stderr, "Bad: transpose failed\n");
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
pixDisplay(pix1, 0, 600);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return 0;
}
/*!
* \brief pixGrayMorphSequence()
*
* \param[in] pixs
* \param[in] sequence string specifying sequence
* \param[in] dispsep controls debug display of each result in the sequence:
* 0: no output
* > 0: gives horizontal separation in pixels between
* successive displays
* < 0: pdf output; abs(dispsep) is used for naming
* \param[in] dispy if dispsep > 0, this gives the y-value of the
* UL corner for display; otherwise it is ignored
* \return pixd, or NULL on error
*
* <pre>
* Notes:
* (1) This works on 8 bpp grayscale images.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) This only uses brick SELs.
* (4) A new image is always produced; the input image is not changed.
* (5) This contains an interpreter, allowing sequences to be
* generated and run.
* (6) The format of the sequence string is defined below.
* (7) In addition to morphological operations, the composite
* morph/subtract tophat can be performed.
* (8) Sel sizes (width, height) must each be odd numbers.
* (9) Intermediate results can optionally be displayed
* (10) The sequence string is formatted as follows:
* ~ An arbitrary number of operations, each separated
* by a '+' character. White space is ignored.
* ~ Each operation begins with a case-independent character
* specifying the operation:
* d or D (dilation)
* e or E (erosion)
* o or O (opening)
* c or C (closing)
* t or T (tophat)
* ~ The args to the morphological operations are bricks of hits,
* and are formatted as a.b, where a and b are horizontal and
* vertical dimensions, rsp. (each must be an odd number)
* ~ The args to the tophat are w or W (for white tophat)
* or b or B (for black tophat), followed by a.b as for
* the dilation, erosion, opening and closing.
* Example valid sequences are:
* "c5.3 + o7.5"
* "c9.9 + tw9.9"
* </pre>
*/
PIX *
pixGrayMorphSequence(PIX *pixs,
const char *sequence,
l_int32 dispsep,
l_int32 dispy)
{
char *rawop, *op, *fname;
char buf[256];
l_int32 nops, i, valid, w, h, x, pdfout;
PIX *pixt1, *pixt2;
PIXA *pixa;
SARRAY *sa;
PROCNAME("pixGrayMorphSequence");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (!sequence)
return (PIX *)ERROR_PTR("sequence not defined", procName, NULL);
/* Split sequence into individual operations */
sa = sarrayCreate(0);
sarraySplitString(sa, sequence, "+");
nops = sarrayGetCount(sa);
pdfout = (dispsep < 0) ? 1 : 0;
/* Verify that the operation sequence is valid */
valid = TRUE;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, L_NOCOPY);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
case 'e':
case 'E':
case 'o':
case 'O':
case 'c':
case 'C':
if (sscanf(&op[1], "%d.%d", &w, &h) != 2) {
fprintf(stderr, "*** op: %s invalid\n", op);
valid = FALSE;
break;
}
if (w < 1 || (w & 1) == 0 || h < 1 || (h & 1) == 0 ) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be odd\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s; w = %d, h = %d\n", op, w, h); */
break;
case 't':
case 'T':
if (op[1] != 'w' && op[1] != 'W' &&
op[1] != 'b' && op[1] != 'B') {
fprintf(stderr,
"*** op = %s; arg %c must be 'w' or 'b'\n", op, op[1]);
valid = FALSE;
break;
}
sscanf(&op[2], "%d.%d", &w, &h);
if (w < 1 || (w & 1) == 0 || h < 1 || (h & 1) == 0 ) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be odd\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s", op); */
break;
default:
fprintf(stderr, "*** nonexistent op = %s\n", op);
valid = FALSE;
}
LEPT_FREE(op);
}
if (!valid) {
sarrayDestroy(&sa);
return (PIX *)ERROR_PTR("sequence invalid", procName, NULL);
}
/* Parse and operate */
pixa = NULL;
if (pdfout) {
pixa = pixaCreate(0);
pixaAddPix(pixa, pixs, L_CLONE);
snprintf(buf, sizeof(buf), "/tmp/seq_output_%d.pdf", L_ABS(dispsep));
fname = genPathname(buf, NULL);
}
pixt1 = pixCopy(NULL, pixs);
pixt2 = NULL;
x = 0;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, L_NOCOPY);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixDilateGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixOpenGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixCloseGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 't':
case 'T':
sscanf(&op[2], "%d.%d", &w, &h);
if (op[1] == 'w' || op[1] == 'W')
pixt2 = pixTophat(pixt1, w, h, L_TOPHAT_WHITE);
else /* 'b' or 'B' */
pixt2 = pixTophat(pixt1, w, h, L_TOPHAT_BLACK);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
default:
/* All invalid ops are caught in the first pass */
break;
}
LEPT_FREE(op);
/* Debug output */
if (dispsep > 0) {
pixDisplay(pixt1, x, dispy);
x += dispsep;
}
if (pdfout)
pixaAddPix(pixa, pixt1, L_COPY);
}
if (pdfout) {
pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, fname, fname);
LEPT_FREE(fname);
pixaDestroy(&pixa);
}
sarrayDestroy(&sa);
return pixt1;
}
/*!
* \brief pixMorphCompSequenceDwa()
*
* \param[in] pixs
* \param[in] sequence string specifying sequence
* \param[in] dispsep controls debug display of each result in the sequence:
* 0: no output
* > 0: gives horizontal separation in pixels between
* successive displays
* < 0: pdf output; abs(dispsep) is used for naming
* \return pixd, or NULL on error
*
* <pre>
* Notes:
* (1) This does dwa morphology on binary images, using brick Sels.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) It implements all brick Sels that have dimensions up to 63
* on each side, using a composite (linear + comb) when useful.
* (4) A new image is always produced; the input image is not changed.
* (5) This contains an interpreter, allowing sequences to be
* generated and run.
* (6) See pixMorphSequence() for further information about usage.
* </pre>
*/
PIX *
pixMorphCompSequenceDwa(PIX *pixs,
const char *sequence,
l_int32 dispsep)
{
char *rawop, *op, *fname;
char buf[256];
l_int32 nops, i, j, nred, fact, w, h, x, y, border, pdfout;
l_int32 level[4];
PIX *pixt1, *pixt2;
PIXA *pixa;
SARRAY *sa;
PROCNAME("pixMorphCompSequenceDwa");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (!sequence)
return (PIX *)ERROR_PTR("sequence not defined", procName, NULL);
/* Split sequence into individual operations */
sa = sarrayCreate(0);
sarraySplitString(sa, sequence, "+");
nops = sarrayGetCount(sa);
pdfout = (dispsep < 0) ? 1 : 0;
if (!morphSequenceVerify(sa)) {
sarrayDestroy(&sa);
return (PIX *)ERROR_PTR("sequence not valid", procName, NULL);
}
/* Parse and operate */
pixa = NULL;
if (pdfout) {
pixa = pixaCreate(0);
pixaAddPix(pixa, pixs, L_CLONE);
snprintf(buf, sizeof(buf), "/tmp/seq_output_%d.pdf", L_ABS(dispsep));
fname = genPathname(buf, NULL);
}
border = 0;
pixt1 = pixCopy(NULL, pixs);
pixt2 = NULL;
x = y = 0;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, L_NOCOPY);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixDilateCompBrickDwa(NULL, pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeCompBrickDwa(NULL, pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixOpenCompBrickDwa(pixt1, pixt1, w, h);
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixCloseCompBrickDwa(pixt1, pixt1, w, h);
break;
case 'r':
case 'R':
nred = strlen(op) - 1;
for (j = 0; j < nred; j++)
level[j] = op[j + 1] - '0';
for (j = nred; j < 4; j++)
level[j] = 0;
pixt2 = pixReduceRankBinaryCascade(pixt1, level[0], level[1],
level[2], level[3]);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'x':
case 'X':
sscanf(&op[1], "%d", &fact);
pixt2 = pixExpandReplicate(pixt1, fact);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'b':
case 'B':
sscanf(&op[1], "%d", &border);
pixt2 = pixAddBorder(pixt1, border, 0);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
default:
/* All invalid ops are caught in the first pass */
break;
}
LEPT_FREE(op);
/* Debug output */
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
if (pdfout)
pixaAddPix(pixa, pixt1, L_COPY);
}
if (border > 0) {
pixt2 = pixRemoveBorder(pixt1, border);
pixSwapAndDestroy(&pixt1, &pixt2);
}
if (pdfout) {
pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, fname, fname);
LEPT_FREE(fname);
pixaDestroy(&pixa);
}
sarrayDestroy(&sa);
return pixt1;
}
int main(int argc,
char **argv) {
#if 1
l_int32 i, pageno, w, h, left, right;
NUMA *nar, *naro, *narl, *nart, *nai, *naio, *nait;
PIX *pixs, *pixr, *pixg, *pixgi, *pixd, *pix1, *pix2;
PIXA *pixa1, *pixa2;
static char mainName[] = "croptest";
if (argc != 1)
return ERROR_INT("syntax: croptest", mainName, 1);
pixa1 = pixaCreate(2);
for (i = 0; i < 2; i++) {
pageno = extractNumberFromFilename(fnames[i], 5, 0);
fprintf(stderr, "Page %d\n", pageno);
pixs = pixRead(fnames[i]);
pixr = pixRotate90(pixs, (pageno % 2) ? 1 : -1);
pixg = pixConvertTo8(pixr, 0);
pixGetDimensions(pixg, &w, &h, NULL);
/* Get info on vertical reversal profile */
nar = pixReversalProfile(pixg, 0.8, L_VERTICAL_LINE,
0, h - 1, mindif, 1, 1);
naro = numaOpen(nar, 11);
gplotSimple1(naro, GPLOT_PNG, "/tmp/root1", "Reversals Opened");
narl = numaLowPassIntervals(naro, 0.1, 0.0);
fprintf(stderr, "narl:");
numaWriteStream(stderr, narl);
nart = numaThresholdEdges(naro, 0.1, 0.5, 0.0);
fprintf(stderr, "nart:");
numaWriteStream(stderr, nart);
numaDestroy(&nar);
numaDestroy(&naro);
/* Get info on vertical intensity profile */
pixgi = pixInvert(NULL, pixg);
nai = pixAverageIntensityProfile(pixgi, 0.8, L_VERTICAL_LINE,
0, h - 1, 1, 1);
naio = numaOpen(nai, 11);
gplotSimple1(naio, GPLOT_PNG, "/tmp/root2", "Intensities Opened");
nait = numaThresholdEdges(naio, 0.4, 0.6, 0.0);
fprintf(stderr, "nait:");
numaWriteStream(stderr, nait);
numaDestroy(&nai);
numaDestroy(&naio);
/* Analyze profiles for left/right edges */
GetLeftCut(narl, nart, nait, w, &left);
GetRightCut(narl, nart, nait, w, &right);
fprintf(stderr, "left = %d, right = %d\n", left, right);
/* Output visuals */
#ifndef _WIN32
sleep(1);
#else
Sleep(1000);
#endif /* _WIN32 */
pixa2 = pixaCreate(3);
pixSaveTiled(pixr, pixa2, 1.0, 1, 25, 32);
pix1 = pixRead("/tmp/root1.png");
pix2 = pixRead("/tmp/root2.png");
pixSaveTiled(pix1, pixa2, 1.0, 1, 25, 32);
pixSaveTiled(pix2, pixa2, 1.0, 0, 25, 32);
pixd = pixaDisplay(pixa2, 0, 0);
pixaDestroy(&pixa2);
pixaAddPix(pixa1, pixd, L_INSERT);
pixDisplay(pixd, 100, 100);
pixDestroy(&pixs);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixgi);
pixDestroy(&pix1);
pixDestroy(&pix2);
numaDestroy(&narl);
numaDestroy(&nart);
numaDestroy(&nait);
}
pixaConvertToPdf(pixa1, 75, 1.0, L_JPEG_ENCODE, 0, "Profiles",
"/tmp/croptest.pdf");
pixaDestroy(&pixa1);
return 0;
}
int main(int argc,
char **argv)
{
BOX *box;
PIX *pixs, *pixs8, *pixm, *pixt1, *pixt2, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Start with a 32 bpp image and a mask. Use the
* same mask for all clip/masked operations. */
pixs = pixRead("test24.jpg");
pixt1 = pixRead("rabi.png");
box = boxCreate(303, 1983, 800, 500);
pixm = pixClipRectangle(pixt1, box, NULL);
pixInvert(pixm, pixm);
boxDestroy(&box);
box = boxCreate(100, 100, 800, 500); /* clips on pixs and derivatives */
pixt2 = pixClipRectangle(pixs, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 0 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixDestroy(&pixt1);
/* Clip 32 bpp RGB */
pixd = pixClipMasked(pixs, pixm, 100, 100, 0x03c08000);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 1 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Clip 8 bpp colormapped */
pixt1 = pixMedianCutQuant(pixs, 0);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 2 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x03c08000);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 3 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 4 bpp colormapped */
pixt1 = pixOctreeQuantNumColors(pixs, 16, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 4 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x03c08000);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 5 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 2 bpp colormapped */
pixt1 = pixMedianCutQuantGeneral(pixs, 0, 2, 4, 5, 1, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 6 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x03608000);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 7 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 8 bpp gray */
pixs8 = pixConvertRGBToLuminance(pixs);
pixt2 = pixClipRectangle(pixs8, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 8 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixs8, pixm, 100, 100, 90);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixaAddPix(pixa, pixd, L_INSERT);
/* Clip 4 bpp gray */
pixt1 = pixThresholdTo4bpp(pixs8, 16, 0);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 10 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 11 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 5);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 12 */
pixaAddPix(pixa, pixd, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 13 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 4 bpp gray, colormapped */
pixt1 = pixThresholdTo4bpp(pixs8, 16, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 14 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x55555500);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 15 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 2 bpp gray */
pixt1 = pixThresholdTo2bpp(pixs8, 4, 0);
pixt2 = pixClipRectangle(pixt1, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 16 */
pixaAddPix(pixa, pixt2, L_INSERT);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 1);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 17 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
/* Clip 2 bpp gray, colormapped */
pixt1 = pixThresholdTo2bpp(pixs8, 4, 1);
pixt2 = pixClipRectangle(pixt1, box, NULL);
pixd = pixClipMasked(pixt1, pixm, 100, 100, 0x55555500);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 18 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixm);
pixDestroy(&pixs);
pixDestroy(&pixs8);
boxDestroy(&box);
/* Finally, do the 1 bpp painting through clipped region.
* We start with two 1 bpp text sources, use the inverse
* of the 2nd for the mask (so we take all of the 1st
* pixels under this mask), and for the remainder, which
* are the fg pixels in the 2nd, we paint them black (1).
* So this is a simple and fast blending of two 1 bpp pix. */
pixs = pixRead("feyn.tif");
box = boxCreate(670, 827, 800, 500);
pixt2 = pixClipRectangle(pixs, box, NULL);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 19 */
pixaAddPix(pixa, pixt2, L_INSERT);
boxDestroy(&box);
pixt1 = pixRead("rabi.png");
box = boxCreate(303, 1983, 800, 500);
pixm = pixClipRectangle(pixt1, box, NULL);
pixInvert(pixm, pixm);
regTestWritePixAndCheck(rp, pixm, IFF_PNG); /* 20 */
pixaAddPix(pixa, pixm, L_INSERT);
pixd = pixClipMasked(pixs, pixm, 670, 827, 1);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 21 */
pixaAddPix(pixa, pixd, L_INSERT);
pixDestroy(&pixs);
pixDestroy(&pixt1);
boxDestroy(&box);
/* If in testing mode, make a pdf */
if (rp->display) {
pixaConvertToPdf(pixa, 100, 1.0, L_FLATE_ENCODE, 0,
"Paint through mask", "/tmp/lept/regout/paintmask.pdf");
L_INFO("Output pdf: /tmp/lept/regout/paintmask.pdf\n", rp->testname);
}
pixaDestroy(&pixa);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
l_int32 irval, igval, ibval;
l_float32 rval, gval, bval, fract, fgfract;
L_BMF *bmf;
BOX *box;
BOXA *boxa;
FPIX *fpix;
PIX *pixs, *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7;
PIX *pix8, *pix9, *pix10, *pix11, *pix12, *pix13, *pix14, *pix15;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
pixs = pixRead("breviar38.150.jpg");
/* pixs = pixRead("breviar32.150.jpg"); */
pixaAddPix(pixa, pixs, L_CLONE);
regTestWritePixAndCheck(rp, pixs, IFF_JFIF_JPEG); /* 0 */
pixDisplayWithTitle(pixs, 0, 0, "Input image", rp->display);
/* Extract the blue component, which is small in all the text
* regions, including in the highlight color region */
pix1 = pixGetRGBComponent(pixs, COLOR_BLUE);
pixaAddPix(pixa, pix1, L_CLONE);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 1 */
pixDisplayWithTitle(pix1, 200, 0, "Blue component", rp->display);
/* Do a background normalization, with the background set to
* approximately 200 */
pix2 = pixBackgroundNormSimple(pix1, NULL, NULL);
pixaAddPix(pixa, pix2, L_COPY);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 2 */
pixDisplayWithTitle(pix2, 400, 0, "BG normalized to 200", rp->display);
/* Do a linear transform on the gray pixels, with 50 going to
* black and 160 going to white. 50 is sufficiently low to
* make both the red and black print quite dark. Quantize
* to a few equally spaced gray levels. This is the image
* to which highlight color will be applied. */
pixGammaTRC(pix2, pix2, 1.0, 50, 160);
pix3 = pixThresholdOn8bpp(pix2, 7, 1);
pixaAddPix(pixa, pix3, L_CLONE);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 3 */
pixDisplayWithTitle(pix3, 600, 0, "Basic quantized with white bg",
rp->display);
/* Identify the regions of red text. First, make a mask
* consisting of all pixels such that (R-B)/B is larger
* than 2.0. This will have all the red, plus a lot of
* the dark pixels. */
fpix = pixComponentFunction(pixs, 1.0, 0.0, -1.0, 0.0, 0.0, 1.0);
pix4 = fpixThresholdToPix(fpix, 2.0);
pixInvert(pix4, pix4); /* red plus some dark text */
pixaAddPix(pixa, pix4, L_CLONE);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 800, 0, "Red plus dark pixels", rp->display);
/* Make a mask consisting of all the red and background pixels */
pix5 = pixGetRGBComponent(pixs, COLOR_RED);
pix6 = pixThresholdToBinary(pix5, 128);
pixInvert(pix6, pix6); /* red plus background (white) */
/* Intersect the two masks to get a mask consisting of pixels
* that are almost certainly red. This is the seed. */
pix7 = pixAnd(NULL, pix4, pix6); /* red only (seed) */
pixaAddPix(pixa, pix7, L_COPY);
regTestWritePixAndCheck(rp, pix7, IFF_PNG); /* 5 */
pixDisplayWithTitle(pix7, 0, 600, "Seed for red color", rp->display);
/* Make the clipping mask by thresholding the image with
* the background cleaned to white. */
pix8 = pixThresholdToBinary(pix2, 230); /* mask */
pixaAddPix(pixa, pix8, L_CLONE);
regTestWritePixAndCheck(rp, pix8, IFF_PNG); /* 6 */
pixDisplayWithTitle(pix8, 200, 600, "Clipping mask for red components",
rp->display);
/* Fill into the mask from the seed */
pixSeedfillBinary(pix7, pix7, pix8, 8); /* filled: red plus touching */
regTestWritePixAndCheck(rp, pix7, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix7, 400, 600, "Red component mask filled",
rp->display);
/* Remove long horizontal and vertical lines from the filled result */
pix9 = pixMorphSequence(pix7, "o40.1", 0);
pixSubtract(pix7, pix7, pix9); /* remove long horizontal lines */
pixDestroy(&pix9);
pix9 = pixMorphSequence(pix7, "o1.40", 0);
pixSubtract(pix7, pix7, pix9); /* remove long vertical lines */
/* Close the regions to be colored */
pix10 = pixMorphSequence(pix7, "c5.1", 0);
pixaAddPix(pixa, pix10, L_CLONE);
regTestWritePixAndCheck(rp, pix10, IFF_PNG); /* 8 */
pixDisplayWithTitle(pix10, 600, 600,
"Components defining regions allowing coloring",
rp->display);
/* Sanity check on amount to be colored. Only accept images
* with less than 10% of all the pixels with highlight color */
pixForegroundFraction(pix10, &fgfract);
if (fgfract >= 0.10) {
L_INFO("too much highlighting: fract = %6.3f; removing it\n",
rp->testname, fgfract);
pixClearAll(pix10);
pixSetPixel(pix10, 0, 0, 1);
}
/* Get the bounding boxes of the regions to be colored */
boxa = pixConnCompBB(pix10, 8);
/* Get a color to paint that is representative of the
* actual highlight color in the image. Scale each
* color component up from the average by an amount necessary
* to saturate the red. Then divide the green and
* blue components by 2.0. */
pixGetAverageMaskedRGB(pixs, pix7, 0, 0, 1, L_MEAN_ABSVAL,
&rval, &gval, &bval);
fract = 255.0 / rval;
irval = lept_roundftoi(fract * rval);
igval = lept_roundftoi(fract * gval / 2.0);
ibval = lept_roundftoi(fract * bval / 2.0);
fprintf(stderr, "(r,g,b) = (%d,%d,%d)\n", irval, igval, ibval);
/* Color the quantized gray version in the selected regions */
pix11 = pixColorGrayRegions(pix3, boxa, L_PAINT_DARK, 220, irval,
igval, ibval);
pixaAddPix(pixa, pix11, L_CLONE);
regTestWritePixAndCheck(rp, pix11, IFF_PNG); /* 9 */
pixDisplayWithTitle(pix11, 800, 600, "Final colored result", rp->display);
pixaAddPix(pixa, pixs, L_CLONE);
/* Test colorization on gray and cmapped gray */
pix12 = pixColorGrayRegions(pix2, boxa, L_PAINT_DARK, 220, 0, 255, 0);
pixaAddPix(pixa, pix12, L_CLONE);
regTestWritePixAndCheck(rp, pix12, IFF_PNG); /* 10 */
pixDisplayWithTitle(pix12, 900, 600, "Colorizing boxa gray", rp->display);
box = boxCreate(200, 200, 250, 350);
pix13 = pixCopy(NULL, pix2);
pixColorGray(pix13, box, L_PAINT_DARK, 220, 0, 0, 255);
pixaAddPix(pixa, pix13, L_CLONE);
regTestWritePixAndCheck(rp, pix13, IFF_PNG); /* 11 */
pixDisplayWithTitle(pix13, 1000, 600, "Colorizing box gray", rp->display);
pix14 = pixThresholdTo4bpp(pix2, 6, 1);
pix15 = pixColorGrayRegions(pix14, boxa, L_PAINT_DARK, 220, 0, 0, 255);
pixaAddPix(pixa, pix15, L_CLONE);
regTestWritePixAndCheck(rp, pix15, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix15, 1100, 600, "Colorizing boxa cmap", rp->display);
pixColorGrayCmap(pix14, box, L_PAINT_DARK, 0, 255, 255);
pixaAddPix(pixa, pix14, L_CLONE);
regTestWritePixAndCheck(rp, pix14, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix14, 1200, 600, "Colorizing box cmap", rp->display);
boxDestroy(&box);
/* Generate a pdf of the intermediate results */
lept_mkdir("lept");
L_INFO("Writing to /tmp/lept/colorize.pdf\n", rp->testname);
pixaConvertToPdf(pixa, 90, 1.0, 0, 0, "Colorizing highlighted text",
"/tmp/lept/colorize.pdf");
pixaDestroy(&pixa);
fpixDestroy(&fpix);
boxDestroy(&box);
boxaDestroy(&boxa);
pixDestroy(&pixs);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pix9);
pixDestroy(&pix10);
pixDestroy(&pix11);
pixDestroy(&pix12);
pixDestroy(&pix13);
pixDestroy(&pix14);
pixDestroy(&pix15);
/* Test the color detector */
pixa = pixaCreate(7);
bmf = bmfCreate("./fonts", 4);
pix1 = TestForRedColor(rp, "brev06.75.jpg", 1, bmf); /* 14 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev10.75.jpg", 0, bmf); /* 15 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev14.75.jpg", 1, bmf); /* 16 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev20.75.jpg", 1, bmf); /* 17 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev36.75.jpg", 0, bmf); /* 18 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev53.75.jpg", 1, bmf); /* 19 */
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = TestForRedColor(rp, "brev56.75.jpg", 1, bmf); /* 20 */
pixaAddPix(pixa, pix1, L_INSERT);
/* Generate a pdf of the color detector results */
L_INFO("Writing to /tmp/lept/colordetect.pdf\n", rp->testname);
pixaConvertToPdf(pixa, 45, 1.0, 0, 0, "Color detection",
"/tmp/lept/colordetect.pdf");
pixaDestroy(&pixa);
bmfDestroy(&bmf);
return regTestCleanup(rp);
}
/*!
* \brief pixItalicWords()
*
* \param[in] pixs 1 bpp
* \param[in] boxaw [optional] word bounding boxes; can be NULL
* \param[in] pixw [optional] word box mask; can be NULL
* \param[out] pboxa boxa of italic words
* \param[in] debugflag 1 for debug output; 0 otherwise
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) You can input the bounding boxes for the words in one of
* two forms: as bounding boxes (%boxaw) or as a word mask with
* the word bounding boxes filled (%pixw). For example,
* to compute %pixw, you can use pixWordMaskByDilation().
* (2) Alternatively, you can set both of these inputs to NULL,
* in which case the word mask is generated here. This is
* done by dilating and closing the input image to connect
* letters within a word, while leaving the words separated.
* The parameters are chosen under the assumption that the
* input is 10 to 12 pt text, scanned at about 300 ppi.
* (3) sel_ital1 and sel_ital2 detect the right edges that are
* nearly vertical, at approximately the angle of italic
* strokes. We use the right edge to avoid getting seeds
* from lower-case 'y'. The typical italic slant has a smaller
* angle with the vertical than the 'W', so in most cases we
* will not trigger on the slanted lines in the 'W'.
* (4) Note that sel_ital2 is shorter than sel_ital1. It is
* more appropriate for a typical font scanned at 200 ppi.
* </pre>
*/
l_int32
pixItalicWords(PIX *pixs,
BOXA *boxaw,
PIX *pixw,
BOXA **pboxa,
l_int32 debugflag)
{
char opstring[32];
l_int32 size;
BOXA *boxa;
PIX *pixsd, *pixm, *pixd;
SEL *sel_ital1, *sel_ital2, *sel_ital3;
PROCNAME("pixItalicWords");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!pboxa)
return ERROR_INT("&boxa not defined", procName, 1);
if (boxaw && pixw)
return ERROR_INT("both boxaw and pixw are defined", procName, 1);
sel_ital1 = selCreateFromString(str_ital1, 13, 6, NULL);
sel_ital2 = selCreateFromString(str_ital2, 10, 6, NULL);
sel_ital3 = selCreateFromString(str_ital3, 4, 2, NULL);
/* Make the italic seed: extract with HMT; remove noise.
* The noise removal close/open is important to exclude
* situations where a small slanted line accidentally
* matches sel_ital1. */
pixsd = pixHMT(NULL, pixs, sel_ital1);
pixClose(pixsd, pixsd, sel_ital3);
pixOpen(pixsd, pixsd, sel_ital3);
/* Make the word mask. Use input boxes or mask if given. */
size = 0; /* init */
if (boxaw) {
pixm = pixCreateTemplate(pixs);
pixMaskBoxa(pixm, pixm, boxaw, L_SET_PIXELS);
} else if (pixw) {
pixm = pixClone(pixw);
} else {
pixWordMaskByDilation(pixs, NULL, &size, NULL);
L_INFO("dilation size = %d\n", procName, size);
snprintf(opstring, sizeof(opstring), "d1.5 + c%d.1", size);
pixm = pixMorphSequence(pixs, opstring, 0);
}
/* Binary reconstruction to fill in those word mask
* components for which there is at least one seed pixel. */
pixd = pixSeedfillBinary(NULL, pixsd, pixm, 8);
boxa = pixConnComp(pixd, NULL, 8);
*pboxa = boxa;
if (debugflag) {
/* Save results at at 2x reduction */
lept_mkdir("lept/ital");
l_int32 res, upper;
BOXA *boxat;
GPLOT *gplot;
NUMA *na;
PIXA *pad;
PIX *pix1, *pix2, *pix3;
pad = pixaCreate(0);
boxat = pixConnComp(pixm, NULL, 8);
boxaWrite("/tmp/lept/ital/ital.ba", boxat);
pixSaveTiledOutline(pixs, pad, 0.5, 1, 20, 2, 32); /* orig */
pixSaveTiledOutline(pixsd, pad, 0.5, 1, 20, 2, 0); /* seed */
pix1 = pixConvertTo32(pixm);
pixRenderBoxaArb(pix1, boxat, 3, 255, 0, 0);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* mask + outline */
pixDestroy(&pix1);
pixSaveTiledOutline(pixd, pad, 0.5, 1, 20, 2, 0); /* ital mask */
pix1 = pixConvertTo32(pixs);
pixRenderBoxaArb(pix1, boxa, 3, 255, 0, 0);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* orig + outline */
pixDestroy(&pix1);
pix1 = pixCreateTemplate(pixs);
pix2 = pixSetBlackOrWhiteBoxa(pix1, boxa, L_SET_BLACK);
pixCopy(pix1, pixs);
pix3 = pixDilateBrick(NULL, pixs, 3, 3);
pixCombineMasked(pix1, pix3, pix2);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* ital bolded */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pix2 = pixaDisplay(pad, 0, 0);
pixWrite("/tmp/lept/ital/ital.png", pix2, IFF_PNG);
pixDestroy(&pix2);
/* Assuming the image represents 6 inches of actual page width,
* the pixs resolution is approximately
* (width of pixs in pixels) / 6
* and the images have been saved at half this resolution. */
res = pixGetWidth(pixs) / 12;
L_INFO("resolution = %d\n", procName, res);
l_pdfSetDateAndVersion(0);
pixaConvertToPdf(pad, res, 1.0, L_FLATE_ENCODE, 75, "Italic Finder",
"/tmp/lept/ital/ital.pdf");
l_pdfSetDateAndVersion(1);
pixaDestroy(&pad);
boxaDestroy(&boxat);
/* Plot histogram of horizontal white run sizes. A small
* initial vertical dilation removes most runs that are neither
* inter-character nor inter-word. The larger first peak is
* from inter-character runs, and the smaller second peak is
* from inter-word runs. */
pix1 = pixDilateBrick(NULL, pixs, 1, 15);
upper = L_MAX(30, 3 * size);
na = pixRunHistogramMorph(pix1, L_RUN_OFF, L_HORIZ, upper);
pixDestroy(&pix1);
gplot = gplotCreate("/tmp/lept/ital/runhisto", GPLOT_PNG,
"Histogram of horizontal runs of white pixels, vs length",
"run length", "number of runs");
gplotAddPlot(gplot, NULL, na, GPLOT_LINES, "plot1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&na);
}
selDestroy(&sel_ital1);
selDestroy(&sel_ital2);
selDestroy(&sel_ital3);
pixDestroy(&pixsd);
pixDestroy(&pixm);
pixDestroy(&pixd);
return 0;
}
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, pageno, w, h, left, right;
NUMA *na1, *nar, *naro, *narl, *nart, *nai, *naio, *nait;
PIX *pixs, *pixr, *pixg, *pixgi, *pixd, *pix1, *pix2;
PIXA *pixa1, *pixa2;
static char mainName[] = "croptest";
if (argc != 1)
return ERROR_INT("syntax: croptest", mainName, 1);
setLeptDebugOK(1);
lept_mkdir("lept/crop");
pixa1 = pixaCreate(2);
for (i = 0; i < 2; i++) {
pageno = extractNumberFromFilename(fnames[i], 5, 0);
fprintf(stderr, "Page %d\n", pageno);
pixs = pixRead(fnames[i]);
pixr = pixRotate90(pixs, (pageno % 2) ? 1 : -1);
pixg = pixConvertTo8(pixr, 0);
pixGetDimensions(pixg, &w, &h, NULL);
/* Get info on vertical reversal profile */
nar = pixReversalProfile(pixg, 0.8, L_VERTICAL_LINE,
0, h - 1, mindif, 1, 1);
naro = numaOpen(nar, 11);
gplotSimple1(naro, GPLOT_PNG, "/tmp/lept/crop/reversals",
"Reversals Opened");
narl = numaLowPassIntervals(naro, 0.1, 0.0);
fprintf(stderr, "narl:");
numaWriteStream(stderr, narl);
nart = numaThresholdEdges(naro, 0.1, 0.5, 0.0);
fprintf(stderr, "nart:");
numaWriteStream(stderr, nart);
numaDestroy(&nar);
numaDestroy(&naro);
/* Get info on vertical intensity profile */
pixgi = pixInvert(NULL, pixg);
nai = pixAverageIntensityProfile(pixgi, 0.8, L_VERTICAL_LINE,
0, h - 1, 1, 1);
naio = numaOpen(nai, 11);
gplotSimple1(naio, GPLOT_PNG, "/tmp/lept/crop/intensities",
"Intensities Opened");
nait = numaThresholdEdges(naio, 0.4, 0.6, 0.0);
fprintf(stderr, "nait:");
numaWriteStream(stderr, nait);
numaDestroy(&nai);
numaDestroy(&naio);
/* Analyze profiles for left/right edges */
GetLeftCut(narl, nart, nait, w, &left);
GetRightCut(narl, nart, nait, w, &right);
fprintf(stderr, "left = %d, right = %d\n", left, right);
/* Output visuals */
pixa2 = pixaCreate(3);
pixSaveTiled(pixr, pixa2, 1.0, 1, 25, 32);
pix1 = pixRead("/tmp/lept/crop/reversals.png");
pix2 = pixRead("/tmp/lept/crop/intensities.png");
pixSaveTiled(pix1, pixa2, 1.0, 1, 25, 32);
pixSaveTiled(pix2, pixa2, 1.0, 0, 25, 32);
pixd = pixaDisplay(pixa2, 0, 0);
pixaDestroy(&pixa2);
pixaAddPix(pixa1, pixd, L_INSERT);
pixDisplay(pixd, 100, 100);
pixDestroy(&pixs);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixgi);
pixDestroy(&pix1);
pixDestroy(&pix2);
numaDestroy(&narl);
numaDestroy(&nart);
numaDestroy(&nait);
}
fprintf(stderr, "Writing profiles to /tmp/lept/crop/croptest.pdf\n");
pixaConvertToPdf(pixa1, 75, 1.0, L_JPEG_ENCODE, 0, "Profiles",
"/tmp/lept/crop/croptest.pdf");
pixaDestroy(&pixa1);
/* Now plot the profiles from text lines */
pixs = pixRead("1555.007.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
na1 = pixReversalProfile(pixs, 0.98, L_HORIZONTAL_LINE,
0, h - 1, 40, 3, 3);
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/crop/rev", "Reversals");
numaDestroy(&na1);
na1 = pixAverageIntensityProfile(pixs, 0.98, L_HORIZONTAL_LINE,
0, h - 1, 1, 1);
gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/crop/inten", "Intensities");
numaDestroy(&na1);
pixa1 = pixaCreate(3);
pixaAddPix(pixa1, pixScale(pixs, 0.5, 0.5), L_INSERT);
pix1 = pixRead("/tmp/lept/crop/rev.png");
pixaAddPix(pixa1, pix1, L_INSERT);
pix1 = pixRead("/tmp/lept/crop/inten.png");
pixaAddPix(pixa1, pix1, L_INSERT);
pixd = pixaDisplayTiledInRows(pixa1, 32, 1000, 1.0, 0, 30, 2);
pixWrite("/tmp/lept/crop/profiles.png", pixd, IFF_PNG);
pixDisplay(pixd, 100, 100);
pixDestroy(&pixs);
pixDestroy(&pixd);
pixaDestroy(&pixa1);
return 0;
}
