main(int argc,
char **argv)
{
l_int32 index, maxiters, type;
BOX *box;
PIX *pix, *pixs, *pixd, *pixt;
PIXA *pixa;
static char mainName[] = "ccthin2_reg";
if (argc != 1 && argc != 3)
exit(ERROR_INT(" Syntax: ccthin2_reg [index maxiters]", mainName, 1));
pixDisplayWrite(NULL, 0);
if ((pix = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
box = boxCreate(683, 799, 970, 479);
pixs = pixClipRectangle(pix, box, NULL);
pixDisplayWrite(pixs, 1);
/* Just do one of the examples */
if (argc == 3) {
index = atoi(argv[1]);
maxiters = atoi(argv[2]);
if (index <= 7)
type = L_THIN_FG;
else
type = L_THIN_BG;
pixt = pixThinExamples(pixs, type, index, maxiters,
"/tmp/junksels.png");
pixDisplay(pixt, 100, 100);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}
/* Do all the examples */
pixt = pixThinExamples(pixs, L_THIN_FG, 1, 0, "/tmp/junksel_example1.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 2, 0, "/tmp/junksel_example2.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 3, 0, "/tmp/junksel_example3.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 4, 0, "/tmp/junksel_example4.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 5, 0, "/tmp/junksel_example5.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 6, 0, "/tmp/junksel_example6.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 7, 0, "/tmp/junksel_example7.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_BG, 8, 5, "/tmp/junksel_example8.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_BG, 9, 5, "/tmp/junksel_example9.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Display the thinning results */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 500, 1, 0, 25, 2);
pixWrite("/tmp/junktiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Display the sels used in the examples */
pixa = pixaReadFiles("/tmp", "junksel_example");
pixd = pixaDisplayTiledInRows(pixa, 1, 500, 1.0, 0, 50, 2);
pixWrite("/tmp/junksels.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pix);
pixDestroy(&pixs);
boxDestroy(&box);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}
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, *pixt, *pixt2, *pixd;
static char mainName[] = "warpertest";
if (argc != 1)
exit(ERROR_INT("syntax: warpertest", mainName, 1));
/* -------- Stereoscopic warping --------------*/
#if RUN_WARP
pixs = pixRead("german.png");
pixGetDimensions(pixs, &w, &h, NULL);
l_jpegSetNoChromaSampling(1);
for (i = 0; i < 50; i++) { /* need to test > 2 widths ! */
j = 7 * i;
box = boxCreate(0, 0, w - j, h - j);
pixt = pixClipRectangle(pixs, box, NULL);
pixd = pixWarpStereoscopic(pixt, 15, 22, 8, 30, -20, 1);
snprintf(buf, sizeof(buf), "/tmp/junkpixw.%02d.jpg", i);
pixWrite(buf, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixDestroy(&pixt);
boxDestroy(&box);
}
pixDestroy(&pixs);
pixDisplayMultiple("/tmp/junkpixw*.jpg");
#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);
bmf = bmfCreate("./fonts", 6);
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 *box = boxCreate(0, 0, w - j, h - j);
pixt = pixClipRectangle(pixs, box, NULL);
pixt2 = pixQuadraticVShear(pixt, dir, 60, -20, op, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%s, %s", dirstr[dir], opstr[op]);
pixd = pixAddSingleTextblock(pixt2, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
snprintf(buf, sizeof(buf), "/tmp/junkpixvs.%02d.png", i);
pixWrite(buf, pixd, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixt);
pixDestroy(&pixt2);
boxDestroy(&box);
}
pixDestroy(&pixs);
bmfDestroy(&bmf);
pixDisplayMultiple("/tmp/junkpixvs*.png");
#endif
/* -------- Linear Horizontal stretching --------------*/
#if RUN_LIN_HORIZ_STRETCH
pixs = pixRead("german.png");
bmf = bmfCreate("./fonts", 6);
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;
pixt = pixStretchHorizontal(pixs, dir, L_LINEAR_WARP,
stretch, op, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%s, %s", dirstr[dir], opstr[op]);
pixd = pixAddSingleTextblock(pixt, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
snprintf(buf, sizeof(buf), "/tmp/junkpixlhs.%02d.jpg", index);
pixWrite(buf, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixDestroy(&pixt);
}
}
pixDestroy(&pixs);
bmfDestroy(&bmf);
pixDisplayMultiple("/tmp/junkpixlhs*.jpg");
#endif
/* -------- Quadratic Horizontal stretching --------------*/
#if RUN_QUAD_HORIZ_STRETCH
pixs = pixRead("german.png");
bmf = bmfCreate("./fonts", 6);
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;
pixt = pixStretchHorizontal(pixs, dir, L_QUADRATIC_WARP,
stretch, op, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%s, %s", dirstr[dir], opstr[op]);
pixd = pixAddSingleTextblock(pixt, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
snprintf(buf, sizeof(buf), "/tmp/junkpixqhs.%02d.jpg", index);
pixWrite(buf, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixDestroy(&pixt);
}
}
pixDestroy(&pixs);
bmfDestroy(&bmf);
pixDisplayMultiple("/tmp/junkpixqhs*.jpg");
#endif
/* -------- Horizontal Shear --------------*/
#if RUN_HORIZ_SHEAR
pixs = pixRead("german.png");
pixGetDimensions(pixs, &w, &h, NULL);
bmf = bmfCreate("./fonts", 6);
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)
pixt = pixHShear(NULL, pixs, h / 2, angle, L_BRING_IN_WHITE);
else
pixt = pixHShearLI(pixs, h / 2, angle, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%6.2f degree, %s", angledeg, opstr[op]);
pixd = pixAddSingleTextblock(pixt, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
snprintf(buf, sizeof(buf), "/tmp/junkpixsh.%02d.jpg", i);
pixWrite(buf, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixDestroy(&pixt);
}
pixDestroy(&pixs);
bmfDestroy(&bmf);
pixDisplayMultiple("/tmp/junkpixsh*.jpg");
#endif
/* -------- Vertical Shear --------------*/
#if RUN_VERT_SHEAR
pixs = pixRead("german.png");
pixGetDimensions(pixs, &w, &h, NULL);
bmf = bmfCreate("./fonts", 6);
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)
pixt = pixVShear(NULL, pixs, w / 2, angle, L_BRING_IN_WHITE);
else
pixt = pixVShearLI(pixs, w / 2, angle, L_BRING_IN_WHITE);
snprintf(buf, sizeof(buf), "%6.2f degree, %s", angledeg, opstr[op]);
pixd = pixAddSingleTextblock(pixt, bmf, buf, 0xff000000,
L_ADD_BELOW, 0);
snprintf(buf, sizeof(buf), "/tmp/junkpixsv.%02d.jpg", i);
pixWrite(buf, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixDestroy(&pixt);
}
pixDestroy(&pixs);
bmfDestroy(&bmf);
pixDisplayMultiple("/tmp/junkpixsv*.jpg");
#endif
return 0;
}
main(int argc,
char **argv)
{
l_int32 ws, hs;
BOX *box;
BOXA *boxa;
PIX *pixs, *pixc, *pix32, *pixt, *pixd;
PIXA *pixat, *pixas, *pixac;
static char mainName[] = "pixadisp_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: pixadisp_reg", mainName, 1));
if ((pixs = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
box = boxCreate(683, 799, 970, 479);
pixc = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
pixDisplayWrite(pixc, 1);
if ((pix32 = pixRead("marge.jpg")) == NULL)
exit(ERROR_INT("pix32 not made", mainName, 1));
/* Generate pixas from pixs and pixac from pixc */
boxa = pixConnComp(pixs, &pixat, 8);
pixas = pixaSelectBySize(pixat, 60, 60, L_SELECT_IF_BOTH,
L_SELECT_IF_LTE, NULL);
pixaDestroy(&pixat);
boxaDestroy(&boxa);
boxa = pixConnComp(pixc, &pixac, 8);
boxaDestroy(&boxa);
/* pixaDisplay() */
pixGetDimensions(pixs, &ws, &hs, NULL);
pixd = pixaDisplay(pixas, ws, hs);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayRandomCmap() */
pixd = pixaDisplayRandomCmap(pixas, ws, hs); /* black bg */
pixDisplayWrite(pixd, 1);
pixcmapResetColor(pixGetColormap(pixd), 0, 255, 255, 255); /* white bg */
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayOnLattice() */
pixd = pixaDisplayOnLattice(pixac, 50, 50);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayUnsplit() */
pixat = pixaSplitPix(pix32, 5, 7, 10, 0x0000ff00);
pixd = pixaDisplayUnsplit(pixat, 5, 7, 10, 0x00ff0000);
pixDisplayWrite(pixd, 1);
pixaDestroy(&pixat);
pixDestroy(&pixd);
/* pixaDisplayTiled() */
pixd = pixaDisplayTiled(pixac, 1000, 0, 10);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayTiledInRows() */
pixd = pixaDisplayTiledInRows(pixac, 1, 1000, 1.0, 0, 10, 2);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
/* pixaDisplayTiledAndScaled() */
pixd = pixaDisplayTiledAndScaled(pixac, 1, 25, 20, 0, 5, 0);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
pixat = pixaCreate(10);
pixd = pixRankFilter(pix32, 8, 8, 0.5);
pixaAddPix(pixat, pixd, L_INSERT);
pixt = pixScale(pix32, 0.5, 0.5);
pixd = pixRankFilter(pixt, 8, 8, 0.5);
pixaAddPix(pixat, pixd, L_INSERT);
pixDestroy(&pixt);
pixt = pixScale(pix32, 0.25, 0.25);
pixd = pixRankFilter(pixt, 8, 8, 0.5);
pixaAddPix(pixat, pixd, L_INSERT);
pixDestroy(&pixt);
pixd = pixaDisplayTiledAndScaled(pixat, 32, 500, 1, 0, 25, 0);
pixDisplayWrite(pixd, 1);
pixaDestroy(&pixat);
pixDestroy(&pixd);
pixaDestroy(&pixas);
pixaDestroy(&pixac);
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pix32);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}
main(int argc,
char **argv)
{
char label[512];
l_int32 w, h, i, j, rwhite, gwhite, bwhite, count;
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;
PIXCMAP *cmap;
static char mainName[] = "colorspacetest";
if (argc != 2)
exit(ERROR_INT(" Syntax: colorspacetest filein", mainName, 1));
if ((pixs = pixRead(argv[1])) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
/* Colorspace conversion in rgb */
pixDisplayWrite(pixs, 1);
pixt = pixConvertRGBToHSV(NULL, pixs);
pixDisplayWrite(pixt, 1);
pixConvertHSVToRGB(pixt, pixt);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Colorspace conversion on a colormap */
pixt = pixOctreeQuantNumColors(pixs, 25, 0);
pixDisplayWrite(pixt, 1);
cmap = pixGetColormap(pixt);
pixcmapWriteStream(stderr, cmap);
pixcmapConvertRGBToHSV(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixcmapConvertHSVToRGB(cmap);
pixcmapWriteStream(stderr, cmap);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Color content extraction */
pixColorContent(pixs, 0, 0, 0, 0, &pixr, &pixg, &pixb);
pixDisplayWrite(pixr, 1);
pixDisplayWrite(pixg, 1);
pixDisplayWrite(pixb, 1);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
/* Color content measurement */
pixa = 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(pixa, 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/junkplot1", GPLOT_X11,
"Fraction with given color (diff from average)",
"white point space for red", "amount of color");
gplot2 = gplotCreate("/tmp/junkplot2", GPLOT_X11,
"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(pixa, 32, 250, 4, 0, 10, 2);
pixWrite("/tmp/junkcolormag", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 0, 100, "Color magnitude", 1);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
numaDestroy(&naseq);
numaaDestroy(&naa1);
numaaDestroy(&naa2);
pixDisplayMultiple("/tmp/junk_write_display*");
pixDestroy(&pixs);
return 0;
}
