main(int argc,
char **argv)
{
char *filein, *fileout;
l_int32 d;
BOX *box1, *box2, *box3, *box4;
BOXA *boxa;
PIX *pixs, *pixt1, *pixt2, *pixt3;
PTA *pta;
static char mainName[] = "graphicstest";
if (argc != 3)
exit(ERROR_INT(" Syntax: graphicstest filein fileout", mainName, 1));
filein = argv[1];
fileout = argv[2];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT(" Syntax: pixs not made", mainName, 1));
d = pixGetDepth(pixs);
if (d <= 8)
pixt1 = pixConvertTo32(pixs);
else
pixt1 = pixClone(pixs);
/* Paint on RGB */
pixRenderLineArb(pixt1, 450, 20, 850, 320, 5, 200, 50, 125);
pixRenderLineArb(pixt1, 30, 40, 440, 40, 5, 100, 200, 25);
pixRenderLineBlend(pixt1, 30, 60, 440, 70, 5, 115, 200, 120, 0.3);
pixRenderLineBlend(pixt1, 30, 600, 440, 670, 9, 215, 115, 30, 0.5);
pixRenderLineBlend(pixt1, 130, 700, 540, 770, 9, 255, 255, 250, 0.4);
pixRenderLineBlend(pixt1, 130, 800, 540, 870, 9, 0, 0, 0, 0.4);
box1 = boxCreate(70, 80, 300, 245);
box2 = boxCreate(470, 180, 150, 205);
box3 = boxCreate(520, 220, 160, 220);
box4 = boxCreate(570, 260, 160, 220);
boxa = boxaCreate(3);
boxaAddBox(boxa, box2, L_INSERT);
boxaAddBox(boxa, box3, L_INSERT);
boxaAddBox(boxa, box4, L_INSERT);
pixRenderBoxArb(pixt1, box1, 3, 200, 200, 25);
pixRenderBoxaBlend(pixt1, boxa, 17, 200, 200, 25, 0.4, 1);
pta = ptaCreate(5);
ptaAddPt(pta, 250, 300);
ptaAddPt(pta, 350, 450);
ptaAddPt(pta, 400, 600);
ptaAddPt(pta, 212, 512);
ptaAddPt(pta, 180, 375);
pixRenderPolylineBlend(pixt1, pta, 17, 25, 200, 200, 0.5, 1, 1);
pixWrite(fileout, pixt1, IFF_JFIF_JPEG);
pixDisplay(pixt1, 200, 200);
pixDestroy(&pixs);
pixDestroy(&pixt1);
boxDestroy(&box1);
boxaDestroy(&boxa);
ptaDestroy(&pta);
pixDestroy(&pixs);
return 0;
}
/*!
* \brief pixFindBaselines()
*
* \param[in] pixs 1 bpp, 300 ppi
* \param[out] ppta [optional] pairs of pts corresponding to
* approx. ends of each text line
* \param[in] pixadb for debug output; use NULL to skip
* \return na of baseline y values, or NULL on error
*
* <pre>
* Notes:
* (1) Input binary image must have text lines already aligned
* horizontally. This can be done by either rotating the
* image with pixDeskew(), or, if a projective transform
* is required, by doing pixDeskewLocal() first.
* (2) Input null for &pta if you don't want this returned.
* The pta will come in pairs of points (left and right end
* of each baseline).
* (3) Caution: this will not work properly on text with multiple
* columns, where the lines are not aligned between columns.
* If there are multiple columns, they should be extracted
* separately before finding the baselines.
* (4) This function constructs different types of output
* for baselines; namely, a set of raster line values and
* a set of end points of each baseline.
* (5) This function was designed to handle short and long text lines
* without using dangerous thresholds on the peak heights. It does
* this by combining the differential signal with a morphological
* analysis of the locations of the text lines. One can also
* combine this data to normalize the peak heights, by weighting
* the differential signal in the region of each baseline
* by the inverse of the width of the text line found there.
* </pre>
*/
NUMA *
pixFindBaselines(PIX *pixs,
PTA **ppta,
PIXA *pixadb)
{
l_int32 h, i, j, nbox, val1, val2, ndiff, bx, by, bw, bh;
l_int32 imaxloc, peakthresh, zerothresh, inpeak;
l_int32 mintosearch, max, maxloc, nloc, locval;
l_int32 *array;
l_float32 maxval;
BOXA *boxa1, *boxa2, *boxa3;
GPLOT *gplot;
NUMA *nasum, *nadiff, *naloc, *naval;
PIX *pix1, *pix2;
PTA *pta;
PROCNAME("pixFindBaselines");
if (ppta) *ppta = NULL;
if (!pixs || pixGetDepth(pixs) != 1)
return (NUMA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
/* Close up the text characters, removing noise */
pix1 = pixMorphSequence(pixs, "c25.1 + e15.1", 0);
/* Estimate the resolution */
if (pixadb) pixaAddPix(pixadb, pixScale(pix1, 0.25, 0.25), L_INSERT);
/* Save the difference of adjacent row sums.
* The high positive-going peaks are the baselines */
if ((nasum = pixCountPixelsByRow(pix1, NULL)) == NULL) {
pixDestroy(&pix1);
return (NUMA *)ERROR_PTR("nasum not made", procName, NULL);
}
h = pixGetHeight(pixs);
nadiff = numaCreate(h);
numaGetIValue(nasum, 0, &val2);
for (i = 0; i < h - 1; i++) {
val1 = val2;
numaGetIValue(nasum, i + 1, &val2);
numaAddNumber(nadiff, val1 - val2);
}
numaDestroy(&nasum);
if (pixadb) { /* show the difference signal */
lept_mkdir("lept/baseline");
gplotSimple1(nadiff, GPLOT_PNG, "/tmp/lept/baseline/diff", "Diff Sig");
pix2 = pixRead("/tmp/lept/baseline/diff.png");
pixaAddPix(pixadb, pix2, L_INSERT);
}
/* Use the zeroes of the profile to locate each baseline. */
array = numaGetIArray(nadiff);
ndiff = numaGetCount(nadiff);
numaGetMax(nadiff, &maxval, &imaxloc);
numaDestroy(&nadiff);
/* Use this to begin locating a new peak: */
peakthresh = (l_int32)maxval / PEAK_THRESHOLD_RATIO;
/* Use this to begin a region between peaks: */
zerothresh = (l_int32)maxval / ZERO_THRESHOLD_RATIO;
naloc = numaCreate(0);
naval = numaCreate(0);
inpeak = FALSE;
for (i = 0; i < ndiff; i++) {
if (inpeak == FALSE) {
if (array[i] > peakthresh) { /* transition to in-peak */
inpeak = TRUE;
mintosearch = i + MIN_DIST_IN_PEAK; /* accept no zeros
* between i and mintosearch */
max = array[i];
maxloc = i;
}
} else { /* inpeak == TRUE; look for max */
if (array[i] > max) {
max = array[i];
maxloc = i;
mintosearch = i + MIN_DIST_IN_PEAK;
} else if (i > mintosearch && array[i] <= zerothresh) { /* leave */
inpeak = FALSE;
numaAddNumber(naval, max);
numaAddNumber(naloc, maxloc);
}
}
}
LEPT_FREE(array);
/* If array[ndiff-1] is max, eg. no descenders, baseline at bottom */
if (inpeak) {
numaAddNumber(naval, max);
numaAddNumber(naloc, maxloc);
}
if (pixadb) { /* show the raster locations for the peaks */
gplot = gplotCreate("/tmp/lept/baseline/loc", GPLOT_PNG, "Peak locs",
"rasterline", "height");
gplotAddPlot(gplot, naloc, naval, GPLOT_POINTS, "locs");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
pix2 = pixRead("/tmp/lept/baseline/loc.png");
pixaAddPix(pixadb, pix2, L_INSERT);
}
numaDestroy(&naval);
/* Generate an approximate profile of text line width.
* First, filter the boxes of text, where there may be
* more than one box for a given textline. */
pix2 = pixMorphSequence(pix1, "r11 + c20.1 + o30.1 +c1.3", 0);
if (pixadb) pixaAddPix(pixadb, pix2, L_COPY);
boxa1 = pixConnComp(pix2, NULL, 4);
pixDestroy(&pix1);
pixDestroy(&pix2);
if (boxaGetCount(boxa1) == 0) {
numaDestroy(&naloc);
boxaDestroy(&boxa1);
L_INFO("no compnents after filtering\n", procName);
return NULL;
}
boxa2 = boxaTransform(boxa1, 0, 0, 4., 4.);
boxa3 = boxaSort(boxa2, L_SORT_BY_Y, L_SORT_INCREASING, NULL);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Optionally, find the baseline segments */
pta = NULL;
if (ppta) {
pta = ptaCreate(0);
*ppta = pta;
}
if (pta) {
nloc = numaGetCount(naloc);
nbox = boxaGetCount(boxa3);
for (i = 0; i < nbox; i++) {
boxaGetBoxGeometry(boxa3, i, &bx, &by, &bw, &bh);
for (j = 0; j < nloc; j++) {
numaGetIValue(naloc, j, &locval);
if (L_ABS(locval - (by + bh)) > 25)
continue;
ptaAddPt(pta, bx, locval);
ptaAddPt(pta, bx + bw, locval);
break;
}
}
}
boxaDestroy(&boxa3);
if (pixadb && pta) { /* display baselines */
l_int32 npts, x1, y1, x2, y2;
pix1 = pixConvertTo32(pixs);
npts = ptaGetCount(pta);
for (i = 0; i < npts; i += 2) {
ptaGetIPt(pta, i, &x1, &y1);
ptaGetIPt(pta, i + 1, &x2, &y2);
pixRenderLineArb(pix1, x1, y1, x2, y2, 2, 255, 0, 0);
}
pixWrite("/tmp/lept/baseline/baselines.png", pix1, IFF_PNG);
pixaAddPix(pixadb, pixScale(pix1, 0.25, 0.25), L_INSERT);
pixDestroy(&pix1);
}
return naloc;
}
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 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);
}
l_int32 main(int argc,
char **argv)
{
L_BMF *bmf;
PIX *pixs1, *pixs2, *pixg, *pixt, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
bmf = bmfCreate("./fonts", 8);
pixs1 = pixCreate(301, 301, 32);
pixs2 = pixCreate(601, 601, 32);
pixSetAll(pixs1);
pixSetAll(pixs2);
pixRenderLineArb(pixs1, 0, 20, 300, 20, 5, 0, 0, 255);
pixRenderLineArb(pixs1, 0, 70, 300, 70, 5, 0, 255, 0);
pixRenderLineArb(pixs1, 0, 120, 300, 120, 5, 0, 255, 255);
pixRenderLineArb(pixs1, 0, 170, 300, 170, 5, 255, 0, 0);
pixRenderLineArb(pixs1, 0, 220, 300, 220, 5, 255, 0, 255);
pixRenderLineArb(pixs1, 0, 270, 300, 270, 5, 255, 255, 0);
pixRenderLineArb(pixs2, 0, 20, 300, 20, 5, 0, 0, 255);
pixRenderLineArb(pixs2, 0, 70, 300, 70, 5, 0, 255, 0);
pixRenderLineArb(pixs2, 0, 120, 300, 120, 5, 0, 255, 255);
pixRenderLineArb(pixs2, 0, 170, 300, 170, 5, 255, 0, 0);
pixRenderLineArb(pixs2, 0, 220, 300, 220, 5, 255, 0, 255);
pixRenderLineArb(pixs2, 0, 270, 300, 270, 5, 255, 255, 0);
/* Color, small pix */
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_LEFT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_RIGHT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_LEFT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixs1, L_WARP_TO_RIGHT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 50, 50, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Grayscale, small pix */
pixg = pixConvertTo8(pixs1, 0);
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 250, 50, NULL, rp->display);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Color, larger pix */
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_LEFT,
120, -40, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_RIGHT,
120, -40, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_LEFT,
120, -40, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixs2, L_WARP_TO_RIGHT,
120, -40, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 550, 50, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Grayscale, larger pix */
pixg = pixConvertTo8(pixs2, 0);
pixa = pixaCreate(0);
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "sampled-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_SAMPLED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "sampled-right");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_LEFT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 1, bmf, "interpolated-left");
pixt = pixQuadraticVShear(pixg, L_WARP_TO_RIGHT,
60, -20, L_INTERPOLATED, L_BRING_IN_WHITE);
PixSave(&pixt, pixa, 0, bmf, "interpolated-right");
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_PNG);
pixDisplayWithTitle(pixd, 850, 50, NULL, rp->display);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
bmfDestroy(&bmf);
return regTestCleanup(rp);
}
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;
}
