l_int32 main(int argc,
char **argv)
{
l_int32 index;
L_BMF *bmf;
PROCNAME("adaptmap_dark");
bmf = bmfCreate("fonts", 10);
index = 0;
lept_mkdir("lept");
/* Using a variety of different thresholds */
GenCleans("cavalerie.29.jpg", &index, 80, bmf);
GenCleans("cavalerie.29.jpg", &index, 60, bmf);
GenCleans("cavalerie.29.jpg", &index, 40, bmf);
GenCleans("cavalerie.11.jpg", &index, 80, bmf);
GenCleans("cavalerie.11.jpg", &index, 60, bmf);
GenCleans("cavalerie.11.jpg", &index, 40, bmf);
/* Write the nup files in /tmp/adapt2 */
convertToNUpFiles("/tmp/lept", "adapt_", 2, 1, 500, 6, 2, NULL, "adapt2");
/* Gather up into a pdf */
L_INFO("Writing to /tmp/lept/adapt_cleaning.pdf\n", procName);
convertFilesToPdf("/tmp/lept", "adapt_", 100, 1.0, L_JPEG_ENCODE,
75, "Adaptive cleaning", "/tmp/lept/adapt_cleaning.pdf");
bmfDestroy(&bmf);
lept_rmdir("adapt2");
return 0;
}
int main(int argc,
char **argv)
{
L_REGPARAMS *rp;
#if !HAVE_LIBWEBP
fprintf(stderr, "webpio is not enabled\n"
"libwebp is required for webpio_reg\n"
"See environ.h: #define HAVE_LIBWEBP\n"
"See prog/Makefile: link in -lwebp\n\n");
return 0;
#endif /* abort */
/* This test uses libjpeg */
#if !HAVE_LIBJPEG
fprintf(stderr, "libjpeg is required for webpio_reg\n\n");
return 0;
#endif /* abort */
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmdir("lept/webp");
lept_mkdir("lept/webp");
DoWebpTest1(rp, "weasel2.4c.png");
DoWebpTest1(rp, "weasel8.240c.png");
DoWebpTest1(rp, "karen8.jpg");
DoWebpTest1(rp, "test24.jpg");
DoWebpTest2(rp, "test24.jpg", 50, 0, 43.50, 1.0);
DoWebpTest2(rp, "test24.jpg", 75, 0, 46.07, 1.0);
DoWebpTest2(rp, "test24.jpg", 90, 0, 51.09, 2.0);
DoWebpTest2(rp, "test24.jpg", 100, 0, 54.979, 5.0);
DoWebpTest2(rp, "test24.jpg", 0, 1, 1000.0, 0.1);
return regTestCleanup(rp);
}
/*!
* dewarpaShowArrays()
*
* Input: dewa
* scalefact (on contour images; typ. 0.5)
* first (first page model to render)
* last (last page model to render; use 0 to go to end)
* fontdir (for text bitmap fonts)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Generates a pdf of contour plots of the disparity arrays.
* (2) This only shows actual models; not ref models
*/
l_int32
dewarpaShowArrays(L_DEWARPA *dewa,
l_float32 scalefact,
l_int32 first,
l_int32 last,
const char *fontdir)
{
char buf[256];
char *pathname;
l_int32 i, svd, shd;
L_BMF *bmf;
L_DEWARP *dew;
PIX *pixv, *pixvs, *pixh, *pixhs, *pixt, *pixd;
PIXA *pixa;
PROCNAME("dewarpaShowArrays");
if (!dewa)
return ERROR_INT("dew not defined", procName, 1);
if (first < 0 || first > dewa->maxpage)
return ERROR_INT("first out of bounds", procName, 1);
if (last <= 0 || last > dewa->maxpage) last = dewa->maxpage;
if (last < first)
return ERROR_INT("last < first", procName, 1);
lept_rmdir("lept");
lept_mkdir("lept");
if ((bmf = bmfCreate(fontdir, 8)) == NULL)
L_ERROR("bmf not made; page info not displayed", procName);
fprintf(stderr, "Generating contour plots\n");
for (i = first; i <= last; i++) {
if (i && ((i % 10) == 0))
fprintf(stderr, " .. %d", i);
dew = dewarpaGetDewarp(dewa, i);
if (!dew) continue;
if (dew->hasref == 1) continue;
svd = shd = 0;
if (dew->sampvdispar) svd = 1;
if (dew->samphdispar) shd = 1;
if (!svd) {
L_ERROR("sampvdispar not made for page %d!\n", procName, i);
continue;
}
/* Generate contour plots at reduced resolution */
dewarpPopulateFullRes(dew, NULL, 0, 0);
pixv = fpixRenderContours(dew->fullvdispar, 3.0, 0.15);
pixvs = pixScaleBySampling(pixv, scalefact, scalefact);
pixDestroy(&pixv);
if (shd) {
pixh = fpixRenderContours(dew->fullhdispar, 3.0, 0.15);
pixhs = pixScaleBySampling(pixh, scalefact, scalefact);
pixDestroy(&pixh);
}
dewarpMinimize(dew);
/* Save side-by-side */
pixa = pixaCreate(2);
pixaAddPix(pixa, pixvs, L_INSERT);
if (shd)
pixaAddPix(pixa, pixhs, L_INSERT);
pixt = pixaDisplayTiledInRows(pixa, 32, 1500, 1.0, 0, 30, 2);
snprintf(buf, sizeof(buf), "Page %d", i);
pixd = pixAddSingleTextblock(pixt, bmf, buf, 0x0000ff00,
L_ADD_BELOW, NULL);
snprintf(buf, sizeof(buf), "arrays_%04d.png", i);
pathname = genPathname("/tmp/lept", buf);
pixWrite(pathname, pixd, IFF_PNG);
pixaDestroy(&pixa);
pixDestroy(&pixt);
pixDestroy(&pixd);
FREE(pathname);
}
bmfDestroy(&bmf);
fprintf(stderr, "\n");
fprintf(stderr, "Generating pdf of contour plots\n");
convertFilesToPdf("/tmp/lept", "arrays_", 90, 1.0, L_FLATE_ENCODE,
0, "Disparity arrays", "/tmp/lept/disparity_arrays.pdf");
fprintf(stderr, "Output written to: /tmp/lept/disparity_arrays.pdf\n");
return 0;
}
/*!
* dewarpShowResults()
*
* Input: dewa
* sarray (of indexed input images)
* boxa (crop boxes for input images; can be null)
* firstpage, lastpage
* fontdir (for text bitmap fonts)
* pdfout (filename)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This generates a pdf of image pairs (before, after) for
* the designated set of input pages.
* (2) If the boxa exists, its elements are aligned with numbers
* in the filenames in @sa. It is used to crop the input images.
* It is assumed that the dewa was generated from the cropped
* images. No undercropping is applied before rendering.
*/
l_int32
dewarpShowResults(L_DEWARPA *dewa,
SARRAY *sa,
BOXA *boxa,
l_int32 firstpage,
l_int32 lastpage,
const char *fontdir,
const char *pdfout)
{
char bufstr[256];
char *outpath;
l_int32 i, modelpage;
L_BMF *bmf;
BOX *box;
L_DEWARP *dew;
PIX *pixs, *pixc, *pixd, *pixt1, *pixt2;
PIXA *pixa;
PROCNAME("dewarpShowResults");
if (!dewa)
return ERROR_INT("dewa not defined", procName, 1);
if (!sa)
return ERROR_INT("sa not defined", procName, 1);
if (!pdfout)
return ERROR_INT("pdfout not defined", procName, 1);
if (firstpage > lastpage)
return ERROR_INT("invalid first/last page numbers", procName, 1);
lept_rmdir("dewarp_pdfout");
lept_mkdir("dewarp_pdfout");
if ((bmf = bmfCreate(fontdir, 6)) == NULL)
L_ERROR("bmf not made; page info not displayed", procName);
fprintf(stderr, "Dewarping and generating s/by/s view\n");
for (i = firstpage; i <= lastpage; i++) {
if (i && (i % 10 == 0)) fprintf(stderr, ".. %d ", i);
pixs = pixReadIndexed(sa, i);
if (boxa) {
box = boxaGetBox(boxa, i, L_CLONE);
pixc = pixClipRectangle(pixs, box, NULL);
boxDestroy(&box);
}
else
pixc = pixClone(pixs);
dew = dewarpaGetDewarp(dewa, i);
pixd = NULL;
if (dew) {
dewarpaApplyDisparity(dewa, dew->pageno, pixc,
GRAYIN_VALUE, 0, 0, &pixd, NULL);
dewarpMinimize(dew);
}
pixa = pixaCreate(2);
pixaAddPix(pixa, pixc, L_INSERT);
if (pixd)
pixaAddPix(pixa, pixd, L_INSERT);
pixt1 = pixaDisplayTiledAndScaled(pixa, 32, 500, 2, 0, 35, 2);
if (dew) {
modelpage = (dew->hasref) ? dew->refpage : dew->pageno;
snprintf(bufstr, sizeof(bufstr), "Page %d; using %d\n",
i, modelpage);
}
else
snprintf(bufstr, sizeof(bufstr), "Page %d; no dewarp\n", i);
pixt2 = pixAddSingleTextblock(pixt1, bmf, bufstr, 0x0000ff00,
L_ADD_BELOW, 0);
snprintf(bufstr, sizeof(bufstr), "/tmp/dewarp_pdfout/%05d", i);
pixWrite(bufstr, pixt2, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
fprintf(stderr, "\n");
fprintf(stderr, "Generating pdf of result\n");
convertFilesToPdf("/tmp/dewarp_pdfout", NULL, 100, 1.0, L_JPEG_ENCODE,
0, "Dewarp sequence", pdfout);
outpath = genPathname(pdfout, NULL);
fprintf(stderr, "Output written to: %s\n", outpath);
FREE(outpath);
bmfDestroy(&bmf);
return 0;
}
/*!
* \brief pixDisplayWriteFormat()
*
* \param[in] pix 1, 2, 4, 8, 16, 32 bpp
* \param[in] reduction -1 to erase and reset; 0 to disable;
* otherwise this is a reduction factor
* \param[in] format IFF_DEFAULT or IFF_PNG
* \return 0 if OK; 1 on error
*
* <pre>
* Notes:
* (1) This writes files with pathnames "/tmp/lept/display/file.*"
* if reduction \> 0. These can be collected into a pdf using
* pixDisplayMultiple();
* (2) Before writing a set of files, call
* pixDisplayWrite(NULL, -1);
* This erases any previously written files in that directory.
* (3) If reduction \> 1 and depth == 1, this does a scale-to-gray
* reduction.
* (4) This function uses a static internal variable to number
* output files written by a single process. Behavior
* with a shared library may be unpredictable.
* (5) Output file format is as follows:
* format == IFF_DEFAULT:
* png if d \< 8 or d == 16 or if the output pix
* has a colormap. Otherwise, output is jpg.
* format == IFF_PNG:
* png (lossless) on all images.
* (6) For 16 bpp, the choice of full dynamic range with log scale
* is the best for displaying these images. Alternative outputs are
* pix8 = pixMaxDynamicRange(pixt, L_LINEAR_SCALE);
* pix8 = pixConvert16To8(pixt, 0); // low order byte
* pix8 = pixConvert16To8(pixt, 1); // high order byte
* </pre>
*/
l_int32
pixDisplayWriteFormat(PIX *pixs,
l_int32 reduction,
l_int32 format)
{
char buf[L_BUF_SIZE];
char *fname;
l_float32 scale;
PIX *pix1, *pix2;
static l_int32 index = 0; /* caution: not .so or thread safe */
PROCNAME("pixDisplayWriteFormat");
if (reduction == 0) return 0;
if (reduction < 0) { /* initialize */
lept_rmdir("lept/display");
index = 0;
return 0;
}
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (format != IFF_DEFAULT && format != IFF_PNG) {
L_INFO("invalid format; using default\n", procName);
format = IFF_DEFAULT;
}
if (index == 0)
lept_mkdir("lept/display");
index++;
if (reduction == 1) {
pix1 = pixClone(pixs);
} else {
scale = 1. / (l_float32)reduction;
if (pixGetDepth(pixs) == 1)
pix1 = pixScaleToGray(pixs, scale);
else
pix1 = pixScale(pixs, scale, scale);
}
if (pixGetDepth(pix1) == 16) {
pix2 = pixMaxDynamicRange(pix1, L_LOG_SCALE);
snprintf(buf, L_BUF_SIZE, "file.%03d.png", index);
fname = genPathname("/tmp/lept/display", buf);
pixWrite(fname, pix2, IFF_PNG);
pixDestroy(&pix2);
} else if (pixGetDepth(pix1) < 8 || pixGetColormap(pix1) ||
format == IFF_PNG) {
snprintf(buf, L_BUF_SIZE, "file.%03d.png", index);
fname = genPathname("/tmp/lept/display", buf);
pixWrite(fname, pix1, IFF_PNG);
} else {
snprintf(buf, L_BUF_SIZE, "file.%03d.jpg", index);
fname = genPathname("/tmp/lept/display", buf);
pixWrite(fname, pix1, format);
}
LEPT_FREE(fname);
pixDestroy(&pix1);
return 0;
}
/*!
* pixDisplayWithTitle()
*
* Input: pix (1, 2, 4, 8, 16, 32 bpp)
* x, y (location of display frame)
* title (<optional> on frame; can be NULL);
* dispflag (1 to write, else disabled)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) See notes for pixDisplay().
* (2) This displays the image if dispflag == 1.
*/
l_int32
pixDisplayWithTitle(PIX *pixs,
l_int32 x,
l_int32 y,
const char *title,
l_int32 dispflag)
{
char *tempname;
char buffer[L_BUF_SIZE];
static l_int32 index = 0; /* caution: not .so or thread safe */
l_int32 w, h, d, ignore;
l_float32 ratw, rath, ratmin;
PIX *pixt;
#ifndef _WIN32
l_int32 wt, ht;
#else
char *pathname;
char fullpath[_MAX_PATH];
#endif /* _WIN32 */
PROCNAME("pixDisplayWithTitle");
if (dispflag != 1) return 0;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (var_DISPLAY_PROG != L_DISPLAY_WITH_XV &&
var_DISPLAY_PROG != L_DISPLAY_WITH_XLI &&
var_DISPLAY_PROG != L_DISPLAY_WITH_XZGV &&
var_DISPLAY_PROG != L_DISPLAY_WITH_IV)
return ERROR_INT("no program chosen for display", procName, 1);
pixGetDimensions(pixs, &w, &h, &d);
if (w <= MAX_DISPLAY_WIDTH && h <= MAX_DISPLAY_HEIGHT) {
if (d == 16) /* take MSB */
pixt = pixConvert16To8(pixs, 1);
else
pixt = pixClone(pixs);
}
else {
ratw = (l_float32)MAX_DISPLAY_WIDTH / (l_float32)w;
rath = (l_float32)MAX_DISPLAY_HEIGHT / (l_float32)h;
ratmin = L_MIN(ratw, rath);
if (ratmin < 0.125 && d == 1)
pixt = pixScaleToGray8(pixs);
else if (ratmin < 0.25 && d == 1)
pixt = pixScaleToGray4(pixs);
else if (ratmin < 0.33 && d == 1)
pixt = pixScaleToGray3(pixs);
else if (ratmin < 0.5 && d == 1)
pixt = pixScaleToGray2(pixs);
else
pixt = pixScale(pixs, ratmin, ratmin);
if (!pixt)
return ERROR_INT("pixt not made", procName, 1);
}
if (index == 0) {
lept_rmdir("display");
lept_mkdir("display");
}
index++;
if (pixGetDepth(pixt) < 8 ||
(w < MAX_SIZE_FOR_PNG && h < MAX_SIZE_FOR_PNG)) {
snprintf(buffer, L_BUF_SIZE, "/tmp/display/write.%03d.png", index);
pixWrite(buffer, pixt, IFF_PNG);
}
else {
snprintf(buffer, L_BUF_SIZE, "/tmp/display/write.%03d.jpg", index);
pixWrite(buffer, pixt, IFF_JFIF_JPEG);
}
tempname = stringNew(buffer);
#ifndef _WIN32
/* Unix */
if (var_DISPLAY_PROG == L_DISPLAY_WITH_XV) {
if (title)
snprintf(buffer, L_BUF_SIZE,
"xv -quit -geometry +%d+%d -name \"%s\" %s &",
x, y, title, tempname);
else
snprintf(buffer, L_BUF_SIZE,
"xv -quit -geometry +%d+%d %s &", x, y, tempname);
}
else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XLI) {
if (title)
snprintf(buffer, L_BUF_SIZE,
"xli -dispgamma 1.0 -quiet -geometry +%d+%d -title \"%s\" %s &",
x, y, title, tempname);
else
snprintf(buffer, L_BUF_SIZE,
"xli -dispgamma 1.0 -quiet -geometry +%d+%d %s &",
x, y, tempname);
}
else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XZGV) {
/* no way to display title */
pixGetDimensions(pixt, &wt, &ht, NULL);
snprintf(buffer, L_BUF_SIZE,
"xzgv --geometry %dx%d+%d+%d %s &", wt + 10, ht + 10,
x, y, tempname);
}
ignore = system(buffer);
#else /* _WIN32 */
/* Windows: L_DISPLAY_WITH_IV */
pathname = genPathname(tempname, NULL);
_fullpath(fullpath, pathname, sizeof(fullpath));
if (title)
snprintf(buffer, L_BUF_SIZE,
"i_view32.exe \"%s\" /pos=(%d,%d) /title=\"%s\"",
fullpath, x, y, title);
else
snprintf(buffer, L_BUF_SIZE, "i_view32.exe \"%s\" /pos=(%d,%d)",
fullpath, x, y);
ignore = system(buffer);
FREE(pathname);
#endif /* _WIN32 */
pixDestroy(&pixt);
FREE(tempname);
return 0;
}
/*!
* dewarpaApplyDisparity()
*
* Input: dewa
* pageno (of page model to be used; may be a ref model)
* pixs (image to be modified; can be 1, 8 or 32 bpp)
* grayin (gray value, from 0 to 255, for pixels brought in;
* use -1 to use pixels on the boundary of pixs)
* x, y (origin for generation of disparity arrays)
* &pixd (<return> disparity corrected image)
* debugfile (use null to skip writing this)
* Return: 0 if OK, 1 on error (no models or ref models available)
*
* Notes:
* (1) This applies the disparity arrays to the specified image.
* (2) Specify gray color for pixels brought in from the outside:
* 0 is black, 255 is white. Use -1 to select pixels from the
* boundary of the source image.
* (3) If the models and ref models have not been validated, this
* will do so by calling dewarpaInsertRefModels().
* (4) This works with both stripped and full resolution page models.
* If the full res disparity array(s) are missing, they are remade.
* (5) The caller must handle errors that are returned because there
* are no valid models or ref models for the page -- typically
* by using the input pixs.
* (6) If there is no model for @pageno, this will use the model for
* 'refpage' and put the result in the dew for @pageno.
* (7) This populates the full resolution disparity arrays if
* necessary. If x and/or y are positive, they are used,
* in conjunction with pixs, to determine the required
* slope-based extension of the full resolution disparity
* arrays in each direction. When (x,y) == (0,0), all
* extension is to the right and down. Nonzero values of (x,y)
* are useful for dewarping when pixs is deliberately undercropped.
* (8) Important: when applying disparity to a number of images,
* after calling this function and saving the resulting pixd,
* you should call dewarpMinimize(dew) on the dew for @pageno.
* This will remove pixs and pixd (or their clones) stored in dew,
* as well as the full resolution disparity arrays. Together,
* these hold approximately 16 bytes for each pixel in pixs.
*/
l_int32
dewarpaApplyDisparity(L_DEWARPA *dewa,
l_int32 pageno,
PIX *pixs,
l_int32 grayin,
l_int32 x,
l_int32 y,
PIX **ppixd,
const char *debugfile)
{
L_DEWARP *dew1, *dew;
PIX *pixv, *pixh;
PROCNAME("dewarpaApplyDisparity");
/* Initialize the output with the input, so we'll have that
* in case we can't apply the page model. */
if (!ppixd)
return ERROR_INT("&pixd not defined", procName, 1);
*ppixd = pixClone(pixs);
if (grayin > 255) {
L_WARNING("invalid grayin = %d; clipping at 255\n", procName, grayin);
grayin = 255;
}
/* Find the appropriate dew to use and fully populate its array(s) */
if (dewarpaApplyInit(dewa, pageno, pixs, x, y, &dew, debugfile))
return ERROR_INT("no model available", procName, 1);
/* Correct for vertical disparity and save the result */
if ((pixv = pixApplyVertDisparity(dew, pixs, grayin)) == NULL) {
dewarpMinimize(dew);
return ERROR_INT("pixv not made", procName, 1);
}
pixDestroy(ppixd);
*ppixd = pixv;
if (debugfile) {
pixDisplayWithTitle(pixv, 300, 0, "pixv", 1);
lept_rmdir("lept/dewapply"); /* remove previous images */
lept_mkdir("lept/dewapply");
pixWrite("/tmp/lept/dewapply/001.png", pixs, IFF_PNG);
pixWrite("/tmp/lept/dewapply/002.png", pixv, IFF_PNG);
}
/* Optionally, correct for horizontal disparity */
if (dewa->useboth && dew->hsuccess) {
if (dew->hvalid == FALSE) {
L_INFO("invalid horiz model for page %d\n", procName, pageno);
} else {
if ((pixh = pixApplyHorizDisparity(dew, pixv, grayin)) != NULL) {
pixDestroy(ppixd);
*ppixd = pixh;
if (debugfile) {
pixDisplayWithTitle(pixh, 600, 0, "pixh", 1);
pixWrite("/tmp/lept/dewapply/003.png", pixh, IFF_PNG);
}
} else {
L_ERROR("horiz disparity failed on page %d\n",
procName, pageno);
}
}
}
if (debugfile) {
dew1 = dewarpaGetDewarp(dewa, pageno);
dewarpDebug(dew1, "lept/dewapply", 0);
convertFilesToPdf("/tmp/lept/dewapply", NULL, 135, 1.0, 0, 0,
"Dewarp Apply Disparity", debugfile);
fprintf(stderr, "pdf file: %s\n", debugfile);
}
/* Get rid of the large full res disparity arrays */
dewarpMinimize(dew);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 success;
PIX *pix;
PIXA *pixa;
L_REGPARAMS *rp;
#if !HAVE_LIBGIF && !HAVE_LIBUNGIF
fprintf(stderr, "gifio is not enabled\n"
"libgif or libungif are required for gifio_reg\n"
"See environ.h: #define HAVE_LIBGIF or HAVE_LIBUNGIF 1\n"
"See prog/Makefile: link in -lgif or -lungif\n\n");
return 0;
#endif /* abort */
if (regTestSetup(argc, argv, &rp))
return 1;
/* Set up for display output */
pixa = (rp->display) ? pixaCreate(0) : NULL;
lept_rmdir("lept/gif");
lept_mkdir("lept/gif");
/* ------------ Part 1: Test lossless r/w to file ------------*/
test_gif(FILE_1BPP, pixa, rp);
test_gif(FILE_2BPP, pixa, rp);
test_gif(FILE_4BPP, pixa, rp);
test_gif(FILE_8BPP_1, pixa, rp);
test_gif(FILE_8BPP_2, pixa, rp);
test_gif(FILE_8BPP_3, pixa, rp);
test_gif(FILE_16BPP, pixa, rp);
test_gif(FILE_32BPP, pixa, rp);
if (rp->success) {
fprintf(stderr,
"\n ****** Success on lossless r/w to file *****\n\n");
} else {
fprintf(stderr,
"\n ******* Failure on at least one r/w to file ******\n\n");
}
if (rp->display) {
pix = pixaDisplayTiledAndScaled(pixa, 32, 450, 3, 0, 20, 2);
pixWrite("/tmp/lept/gif/giftest.jpg", pix, IFF_JFIF_JPEG);
pixDisplay(pix, 100, 100);
pixDestroy(&pix);
pixaDestroy(&pixa);
}
/* ------------ Part 2: Test lossless r/w to memory ------------ */
success = TRUE;
if (test_mem_gif(FILE_1BPP, 0)) success = FALSE;
if (test_mem_gif(FILE_2BPP, 1)) success = FALSE;
if (test_mem_gif(FILE_4BPP, 2)) success = FALSE;
if (test_mem_gif(FILE_8BPP_1, 3)) success = FALSE;
if (test_mem_gif(FILE_8BPP_2, 4)) success = FALSE;
if (test_mem_gif(FILE_8BPP_3, 5)) success = FALSE;
if (test_mem_gif(FILE_16BPP, 6)) success = FALSE;
if (test_mem_gif(FILE_32BPP, 7)) success = FALSE;
if (success) {
fprintf(stderr,
"\n ****** Success on lossless r/w to memory *****\n\n");
} else {
fprintf(stderr,
"\n ******* Failure on at least one r/w to memory ******\n\n");
}
/* Success only if all tests are passed */
if (rp->success == TRUE) rp->success = success;
return regTestCleanup(rp);
}
/*!
* pixDisplayWithTitle()
*
* Input: pix (1, 2, 4, 8, 16, 32 bpp)
* x, y (location of display frame)
* title (<optional> on frame; can be NULL);
* dispflag (1 to write, else disabled)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) See notes for pixDisplay().
* (2) This displays the image if dispflag == 1.
*/
l_int32
pixDisplayWithTitle(PIX *pixs,
l_int32 x,
l_int32 y,
const char *title,
l_int32 dispflag)
{
char *tempname;
char buffer[L_BUF_SIZE];
static l_int32 index = 0; /* caution: not .so or thread safe */
l_int32 w, h, d, spp, maxheight, opaque, threeviews, ignore;
l_float32 ratw, rath, ratmin;
PIX *pix0, *pix1, *pix2;
PIXCMAP *cmap;
#ifndef _WIN32
l_int32 wt, ht;
#else
char *pathname;
char fullpath[_MAX_PATH];
#endif /* _WIN32 */
PROCNAME("pixDisplayWithTitle");
if (dispflag != 1) return 0;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (var_DISPLAY_PROG != L_DISPLAY_WITH_XZGV &&
var_DISPLAY_PROG != L_DISPLAY_WITH_XLI &&
var_DISPLAY_PROG != L_DISPLAY_WITH_XV &&
var_DISPLAY_PROG != L_DISPLAY_WITH_IV &&
var_DISPLAY_PROG != L_DISPLAY_WITH_OPEN) {
return ERROR_INT("no program chosen for display", procName, 1);
}
/* Display with three views if either spp = 4 or if colormapped
* and the alpha component is not fully opaque */
opaque = TRUE;
if ((cmap = pixGetColormap(pixs)) != NULL)
pixcmapIsOpaque(cmap, &opaque);
spp = pixGetSpp(pixs);
threeviews = (spp == 4 || !opaque) ? TRUE : FALSE;
/* If colormapped and not opaque, remove the colormap to RGBA */
if (!opaque)
pix0 = pixRemoveColormap(pixs, REMOVE_CMAP_WITH_ALPHA);
else
pix0 = pixClone(pixs);
/* Scale if necessary; this will also remove a colormap */
pixGetDimensions(pix0, &w, &h, &d);
maxheight = (threeviews) ? MAX_DISPLAY_HEIGHT / 3 : MAX_DISPLAY_HEIGHT;
if (w <= MAX_DISPLAY_WIDTH && h <= maxheight) {
if (d == 16) /* take MSB */
pix1 = pixConvert16To8(pix0, 1);
else
pix1 = pixClone(pix0);
} else {
ratw = (l_float32)MAX_DISPLAY_WIDTH / (l_float32)w;
rath = (l_float32)maxheight / (l_float32)h;
ratmin = L_MIN(ratw, rath);
if (ratmin < 0.125 && d == 1)
pix1 = pixScaleToGray8(pix0);
else if (ratmin < 0.25 && d == 1)
pix1 = pixScaleToGray4(pix0);
else if (ratmin < 0.33 && d == 1)
pix1 = pixScaleToGray3(pix0);
else if (ratmin < 0.5 && d == 1)
pix1 = pixScaleToGray2(pix0);
else
pix1 = pixScale(pix0, ratmin, ratmin);
}
pixDestroy(&pix0);
if (!pix1)
return ERROR_INT("pix1 not made", procName, 1);
/* Generate the three views if required */
if (threeviews)
pix2 = pixDisplayLayersRGBA(pix1, 0xffffff00, 0);
else
pix2 = pixClone(pix1);
if (index == 0) {
lept_rmdir("disp");
lept_mkdir("disp");
}
index++;
if (pixGetDepth(pix2) < 8 ||
(w < MAX_SIZE_FOR_PNG && h < MAX_SIZE_FOR_PNG)) {
snprintf(buffer, L_BUF_SIZE, "/tmp/disp/write.%03d.png", index);
pixWrite(buffer, pix2, IFF_PNG);
} else {
snprintf(buffer, L_BUF_SIZE, "/tmp/disp/write.%03d.jpg", index);
pixWrite(buffer, pix2, IFF_JFIF_JPEG);
}
tempname = stringNew(buffer);
#ifndef _WIN32
/* Unix */
if (var_DISPLAY_PROG == L_DISPLAY_WITH_XZGV) {
/* no way to display title */
pixGetDimensions(pix2, &wt, &ht, NULL);
snprintf(buffer, L_BUF_SIZE,
"xzgv --geometry %dx%d+%d+%d %s &", wt + 10, ht + 10,
x, y, tempname);
} else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XLI) {
if (title) {
snprintf(buffer, L_BUF_SIZE,
"xli -dispgamma 1.0 -quiet -geometry +%d+%d -title \"%s\" %s &",
x, y, title, tempname);
} else {
snprintf(buffer, L_BUF_SIZE,
"xli -dispgamma 1.0 -quiet -geometry +%d+%d %s &",
x, y, tempname);
}
} else if (var_DISPLAY_PROG == L_DISPLAY_WITH_XV) {
if (title) {
snprintf(buffer, L_BUF_SIZE,
"xv -quit -geometry +%d+%d -name \"%s\" %s &",
x, y, title, tempname);
} else {
snprintf(buffer, L_BUF_SIZE,
"xv -quit -geometry +%d+%d %s &", x, y, tempname);
}
} else if (var_DISPLAY_PROG == L_DISPLAY_WITH_OPEN) {
snprintf(buffer, L_BUF_SIZE, "open %s &", tempname);
}
ignore = system(buffer);
#else /* _WIN32 */
/* Windows: L_DISPLAY_WITH_IV */
pathname = genPathname(tempname, NULL);
_fullpath(fullpath, pathname, sizeof(fullpath));
if (title) {
snprintf(buffer, L_BUF_SIZE,
"i_view32.exe \"%s\" /pos=(%d,%d) /title=\"%s\"",
fullpath, x, y, title);
} else {
snprintf(buffer, L_BUF_SIZE, "i_view32.exe \"%s\" /pos=(%d,%d)",
fullpath, x, y);
}
ignore = system(buffer);
FREE(pathname);
#endif /* _WIN32 */
pixDestroy(&pix1);
pixDestroy(&pix2);
FREE(tempname);
return 0;
}
/*!
* pixaGenerateFont()
*
* Input: pix (of 95 characters in 3 rows)
* fontsize (4, 6, 8, ... , 20, in pts at 300 ppi)
* &bl1 (<return> baseline of row 1)
* &bl2 (<return> baseline of row 2)
* &bl3 (<return> baseline of row 3)
* Return: pixa of font bitmaps for 95 characters, or null on error
*
* Notes:
* (1) This does all the work. See pixaGenerateFontFromFile()
* for an overview.
* (2) The pix is for one of the 9 fonts. @fontsize is only
* used here for debugging.
*/
PIXA *
pixaGenerateFont(PIX *pixs,
l_int32 fontsize,
l_int32 *pbl0,
l_int32 *pbl1,
l_int32 *pbl2)
{
l_int32 i, j, nrows, nrowchars, nchars, h, yval;
l_int32 width, height;
l_int32 baseline[3];
l_int32 *tab = NULL;
BOX *box, *box1, *box2;
BOXA *boxar, *boxac, *boxacs;
PIX *pix1, *pix2, *pixr, *pixrc, *pixc;
PIXA *pixa;
l_int32 n, w, inrow, top;
l_int32 *ia;
NUMA *na;
PROCNAME("pixaGenerateFont");
if (!pbl0 || !pbl1 || !pbl2)
return (PIXA *)ERROR_PTR("&bl not all defined", procName, NULL);
*pbl0 = *pbl1 = *pbl2 = 0;
if (!pixs)
return (PIXA *)ERROR_PTR("pixs not defined", procName, NULL);
/* Locate the 3 rows of characters */
w = pixGetWidth(pixs);
na = pixCountPixelsByRow(pixs, NULL);
boxar = boxaCreate(0);
n = numaGetCount(na);
ia = numaGetIArray(na);
inrow = 0;
for (i = 0; i < n; i++) {
if (!inrow && ia[i] > 0) {
inrow = 1;
top = i;
} else if (inrow && ia[i] == 0) {
inrow = 0;
box = boxCreate(0, top, w, i - top);
boxaAddBox(boxar, box, L_INSERT);
}
}
FREE(ia);
numaDestroy(&na);
nrows = boxaGetCount(boxar);
#if DEBUG_FONT_GEN
L_INFO("For fontsize %s, have %d rows\n", procName, fontsize, nrows);
#endif /* DEBUG_FONT_GEN */
if (nrows != 3) {
L_INFO("nrows = %d; skipping fontsize %d\n", procName, nrows, fontsize);
return (PIXA *)ERROR_PTR("3 rows not generated", procName, NULL);
}
/* Grab the character images and baseline data */
#if DEBUG_BASELINE
lept_rmdir("baseline");
lept_mkdir("baseline");
#endif /* DEBUG_BASELINE */
tab = makePixelSumTab8();
pixa = pixaCreate(95);
for (i = 0; i < nrows; i++) {
box = boxaGetBox(boxar, i, L_CLONE);
pixr = pixClipRectangle(pixs, box, NULL); /* row of chars */
pixGetTextBaseline(pixr, tab, &yval);
baseline[i] = yval;
#if DEBUG_BASELINE
L_INFO("Baseline info: row %d, yval = %d, h = %d\n", procName,
i, yval, pixGetHeight(pixr));
pix1 = pixCopy(NULL, pixr);
pixRenderLine(pix1, 0, yval, pixGetWidth(pix1), yval, 1,
L_FLIP_PIXELS);
if (i == 0 )
pixWrite("/tmp/baseline/row0.png", pix1, IFF_PNG);
else if (i == 1)
pixWrite("/tmp/baseline/row1.png", pix1, IFF_PNG);
else
pixWrite("/tmp/baseline/row2.png", pix1, IFF_PNG);
pixDestroy(&pix1);
#endif /* DEBUG_BASELINE */
boxDestroy(&box);
pixrc = pixCloseSafeBrick(NULL, pixr, 1, 35);
boxac = pixConnComp(pixrc, NULL, 8);
boxacs = boxaSort(boxac, L_SORT_BY_X, L_SORT_INCREASING, NULL);
if (i == 0) { /* consolidate the two components of '"' */
box1 = boxaGetBox(boxacs, 1, L_CLONE);
box2 = boxaGetBox(boxacs, 2, L_CLONE);
box1->w = box2->x + box2->w - box1->x; /* increase width */
boxDestroy(&box1);
boxDestroy(&box2);
boxaRemoveBox(boxacs, 2);
}
h = pixGetHeight(pixr);
nrowchars = boxaGetCount(boxacs);
for (j = 0; j < nrowchars; j++) {
box = boxaGetBox(boxacs, j, L_COPY);
if (box->w <= 2 && box->h == 1) { /* skip 1x1, 2x1 components */
boxDestroy(&box);
continue;
}
box->y = 0;
box->h = h - 1;
pixc = pixClipRectangle(pixr, box, NULL);
boxDestroy(&box);
if (i == 0 && j == 0) /* add a pix for the space; change later */
pixaAddPix(pixa, pixc, L_COPY);
if (i == 2 && j == 0) /* add a pix for the '\'; change later */
pixaAddPix(pixa, pixc, L_COPY);
pixaAddPix(pixa, pixc, L_INSERT);
}
pixDestroy(&pixr);
pixDestroy(&pixrc);
boxaDestroy(&boxac);
boxaDestroy(&boxacs);
}
FREE(tab);
nchars = pixaGetCount(pixa);
if (nchars != 95)
return (PIXA *)ERROR_PTR("95 chars not generated", procName, NULL);
*pbl0 = baseline[0];
*pbl1 = baseline[1];
*pbl2 = baseline[2];
/* Fix the space character up; it should have no ON pixels,
* and be about twice as wide as the '!' character. */
pix1 = pixaGetPix(pixa, 0, L_CLONE);
width = 2 * pixGetWidth(pix1);
height = pixGetHeight(pix1);
pixDestroy(&pix1);
pix1 = pixCreate(width, height, 1);
pixaReplacePix(pixa, 0, pix1, NULL);
/* Fix up the '\' character; use a LR flip of the '/' char */
pix1 = pixaGetPix(pixa, 15, L_CLONE);
pix2 = pixFlipLR(NULL, pix1);
pixDestroy(&pix1);
pixaReplacePix(pixa, 60, pix2, NULL);
#if DEBUG_CHARS
pix1 = pixaDisplayTiled(pixa, 1500, 0, 10);
pixDisplay(pix1, 100 * i, 200);
pixDestroy(&pix1);
#endif /* DEBUG_CHARS */
boxaDestroy(&boxar);
return pixa;
}
l_int32 main(int argc,
char **argv)
{
l_int32 exists;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
fprintf(stderr, " ===================================================\n");
fprintf(stderr, " =================== Test pathJoin() ===============\n");
fprintf(stderr, " ===================================================\n");
TestPathJoin(rp, "/a/b//c///d//", "//e//f//g//", "/a/b/c/d/e/f/g"); /* 0 */
TestPathJoin(rp, "/tmp/", "junk//", "/tmp/junk"); /* 1 */
TestPathJoin(rp, "//tmp/", "junk//", "/tmp/junk"); /* 2 */
TestPathJoin(rp, "tmp/", "//junk//", "tmp/junk"); /* 3 */
TestPathJoin(rp, "tmp/", "junk/////", "tmp/junk"); /* 4 */
TestPathJoin(rp, "/tmp/", "///", "/tmp"); /* 5 */
TestPathJoin(rp, "////", NULL, "/"); /* 6 */
TestPathJoin(rp, "//", "/junk//", "/junk"); /* 7 */
TestPathJoin(rp, NULL, "/junk//", "/junk"); /* 8 */
TestPathJoin(rp, NULL, "//junk//", "/junk"); /* 9 */
TestPathJoin(rp, NULL, "junk//", "junk"); /* 10 */
TestPathJoin(rp, NULL, "//", "/"); /* 11 */
TestPathJoin(rp, NULL, NULL, ""); /* 12 */
TestPathJoin(rp, "", "", ""); /* 13 */
TestPathJoin(rp, "/", "", "/"); /* 14 */
TestPathJoin(rp, "", "//", "/"); /* 15 */
TestPathJoin(rp, "", "a", "a"); /* 16 */
fprintf(stderr, "The next 3 joins properly give error messages:\n");
fprintf(stderr, "join: .. + a --> NULL\n");
pathJoin("..", "a"); /* returns NULL */
fprintf(stderr, "join: %s + .. --> NULL\n", "/tmp");
pathJoin("/tmp", ".."); /* returns NULL */
fprintf(stderr, "join: ./ + .. --> NULL\n");
pathJoin("./", ".."); /* returns NULL */
fprintf(stderr, "\n ===================================================\n");
fprintf(stderr, " ======= Test lept_rmdir() and lept_mkdir()) =======\n");
fprintf(stderr, " ===================================================\n");
lept_rmdir("junkfiles");
lept_direxists("/tmp/junkfiles", &exists);
if (rp->display) fprintf(stderr, "directory removed?: %d\n", !exists);
regTestCompareValues(rp, 0, exists, 0.0); /* 17 */
lept_mkdir("junkfiles");
lept_direxists("/tmp/junkfiles", &exists);
if (rp->display) fprintf(stderr, "directory made?: %d\n", exists);
regTestCompareValues(rp, 1, exists, 0.0); /* 18 */
fprintf(stderr, "\n ===================================================\n");
fprintf(stderr, " ======= Test lept_mv(), lept_cp(), lept_rm() ======\n");
fprintf(stderr, " ===================================================");
TestLeptCpRm(rp, "weasel2.png", NULL, NULL); /* 19 - 22 */
TestLeptCpRm(rp, "weasel2.png", "junkfiles", NULL); /* 23 - 26 */
TestLeptCpRm(rp, "weasel2.png", NULL, "new_weasel2.png"); /* 27 - 30 */
TestLeptCpRm(rp, "weasel2.png", "junkfiles", "new_weasel2.png"); /* 31-34 */
fprintf(stderr, "\n ===================================================\n");
fprintf(stderr, " =============== Test genPathname() ================\n");
fprintf(stderr, " ===================================================\n");
TestGenPathname(rp, "what/", NULL, "what"); /* 35 */
TestGenPathname(rp, "what", "abc", "what/abc"); /* 36 */
TestGenPathname(rp, NULL, "abc/def", "abc/def"); /* 37 */
TestGenPathname(rp, "", "abc/def", "abc/def"); /* 38 */
#ifndef _WIN32 /* unix only */
TestGenPathname(rp, "/tmp", NULL, "/tmp"); /* 39 */
TestGenPathname(rp, "/tmp/", NULL, "/tmp"); /* 40 */
TestGenPathname(rp, "/tmp/junk", NULL, "/tmp/junk"); /* 41 */
TestGenPathname(rp, "/tmp/junk/abc", NULL, "/tmp/junk/abc"); /* 42 */
TestGenPathname(rp, "/tmp/junk/", NULL, "/tmp/junk"); /* 43 */
TestGenPathname(rp, "/tmp/junk", "abc", "/tmp/junk/abc"); /* 44 */
#endif /* !_WIN32 */
return regTestCleanup(rp);
}
void TestLeptCpRm(L_REGPARAMS *rp,
const char *srctail,
const char *newdir,
const char *newtail)
{
char realnewdir[256], newnewdir[256];
char *realtail, *newsrc, *fname;
l_int32 nfiles1, nfiles2, nfiles3;
SARRAY *sa;
/* Remove old version if it exists */
realtail = (newtail) ? stringNew(newtail) : stringNew(srctail);
lept_rm(newdir, realtail);
makeTempDirname(realnewdir, 256, newdir);
if (rp->display) {
fprintf(stderr, "\nInput: srctail = %s, newdir = %s, newtail = %s\n",
srctail, newdir, newtail);
fprintf(stderr, " realnewdir = %s, realtail = %s\n",
realnewdir, realtail);
}
sa = getFilenamesInDirectory(realnewdir);
nfiles1 = sarrayGetCount(sa);
sarrayDestroy(&sa);
/* Copy */
lept_cp(srctail, newdir, newtail, &fname);
sa = getFilenamesInDirectory(realnewdir);
nfiles2 = sarrayGetCount(sa);
if (rp->display) {
fprintf(stderr, " File copied to directory: %s\n", realnewdir);
fprintf(stderr, " ... with this filename: %s\n", fname);
fprintf(stderr, " delta files should be 1: %d\n", nfiles2 - nfiles1);
}
regTestCompareValues(rp, 1, nfiles2 - nfiles1, 0.0); /* '1' */
sarrayDestroy(&sa);
lept_free(fname);
/* Remove it */
lept_rm(newdir, realtail);
sa = getFilenamesInDirectory(realnewdir);
nfiles2 = sarrayGetCount(sa);
if (rp->display) {
fprintf(stderr, " File removed from directory: %s\n", realnewdir);
fprintf(stderr, " delta files should be 0: %d\n", nfiles2 - nfiles1);
}
regTestCompareValues(rp, 0, nfiles2 - nfiles1, 0.0); /* '2' */
sarrayDestroy(&sa);
/* Copy it again ... */
lept_cp(srctail, newdir, newtail, &fname);
if (rp->display)
fprintf(stderr, " File copied to: %s\n", fname);
/* move it elsewhere ... */
lept_rmdir("junko"); /* clear out this directory */
lept_mkdir("junko");
newsrc = pathJoin(realnewdir, realtail);
lept_mv(newsrc, "junko", NULL, &fname);
if (rp->display) {
fprintf(stderr, " Move file at: %s\n", newsrc);
fprintf(stderr, " ... to: %s\n", fname);
}
lept_free(fname);
lept_free(newsrc);
makeTempDirname(newnewdir, 256, "junko");
if (rp->display) fprintf(stderr, " In this directory: %s\n", newnewdir);
sa = getFilenamesInDirectory(newnewdir); /* check if it landed ok */
nfiles3 = sarrayGetCount(sa);
if (rp->display) fprintf(stderr, " num files should be 1: %d\n", nfiles3);
regTestCompareValues(rp, 1, nfiles3, 0.0); /* '3' */
sarrayDestroy(&sa);
/* and verify it was removed from the original location */
sa = getFilenamesInDirectory(realnewdir); /* check if it was removed */
nfiles2 = sarrayGetCount(sa);
if (rp->display) {
fprintf(stderr, " In this directory: %s\n", realnewdir);
fprintf(stderr, " delta files should be 0: %d\n", nfiles2 - nfiles1);
}
regTestCompareValues(rp, 0, nfiles2 - nfiles1, 0.0); /* '4' */
sarrayDestroy(&sa);
lept_free(realtail);
}
main(int argc,
char **argv)
{
l_int32 h;
l_float32 scalefactor;
BOX *box;
BOXA *boxa1, *boxa2;
BOXAA *baa;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmdir("segtest");
lept_mkdir("segtest");
baa = boxaaCreate(5);
/* Image region input. */
pix1 = pixRead("wet-day.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/0.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/0.jpg"); /* 0 */
box = boxCreate(105, 161, 620, 872); /* image region */
boxa1 = boxaCreate(1);
boxaAddBox(boxa1, box, L_INSERT);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Compute image region at w = 2 * WIDTH */
pix1 = pixRead("candelabrum-11.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pix3 = pixConvertTo1(pix2, 100);
pix4 = pixExpandBinaryPower2(pix3, 2); /* w = 2 * WIDTH */
pix5 = pixGenHalftoneMask(pix4, NULL, NULL, 1);
pix6 = pixMorphSequence(pix5, "c20.1 + c1.20", 0);
pix7 = pixMaskConnComp(pix6, 8, &boxa1);
pix8 = pixReduceBinary2(pix7, NULL); /* back to w = WIDTH */
pix9 = pixBackgroundNormSimple(pix2, pix8, NULL);
pixWrite("/tmp/segtest/1.jpg", pix9, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/1.jpg"); /* 1 */
boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5); /* back to w = WIDTH */
boxaaAddBoxa(baa, boxa2, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
pixDestroy(&pix7);
pixDestroy(&pix8);
pixDestroy(&pix9);
boxaDestroy(&boxa1);
/* Use mask to find image region */
pix1 = pixRead("lion-page.00016.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/2.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/2.jpg"); /* 2 */
pix3 = pixRead("lion-mask.00016.tif");
pix4 = pixScaleToSize(pix3, WIDTH, 0);
boxa1 = pixConnComp(pix4, NULL, 8);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* Compute image region at full res */
pix1 = pixRead("rabi.png");
scalefactor = (l_float32)WIDTH / (l_float32)pixGetWidth(pix1);
pix2 = pixScaleToGray(pix1, scalefactor);
pixWrite("/tmp/segtest/3.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/3.jpg"); /* 3 */
pix3 = pixGenHalftoneMask(pix1, NULL, NULL, 0);
pix4 = pixMorphSequence(pix3, "c20.1 + c1.20", 0);
boxa1 = pixConnComp(pix4, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, scalefactor, scalefactor);
boxaaAddBoxa(baa, boxa2, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
boxaDestroy(&boxa1);
/* Page with no image regions */
pix1 = pixRead("lucasta-47.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
boxa1 = boxaCreate(1);
pixWrite("/tmp/segtest/4.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/4.jpg"); /* 4 */
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Page that is all image */
pix1 = pixRead("map1.jpg");
pix2 = pixScaleToSize(pix1, WIDTH, 0);
pixWrite("/tmp/segtest/5.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/segtest/5.jpg"); /* 5 */
h = pixGetHeight(pix2);
box = boxCreate(0, 0, WIDTH, h);
boxa1 = boxaCreate(1);
boxaAddBox(boxa1, box, L_INSERT);
boxaaAddBoxa(baa, boxa1, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Save the boxaa file */
boxaaWrite("/tmp/segtest/seg.baa", baa);
regTestCheckFile(rp, "/tmp/segtest/seg.baa"); /* 6 */
/* Do the conversion */
l_pdfSetDateAndVersion(FALSE);
convertSegmentedFilesToPdf("/tmp/segtest", ".jpg", 100, L_G4_ENCODE,
140, baa, 75, 0.6, "Segmentation Test",
"/tmp/pdfseg.7.pdf");
regTestCheckFile(rp, "/tmp/pdfseg.7.pdf"); /* 7 */
boxaaDestroy(&baa);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char *filein, *fname, *printer;
char buf[512];
l_int32 nx, ny, i, w, h, ws, hs, n, ignore;
l_float32 scale;
FILE *fp;
PIX *pixs, *pixt, *pixr;
PIXA *pixa;
SARRAY *sa;
static char mainName[] = "printsplitimage";
if (argc != 4 && argc != 5)
return ERROR_INT(" Syntax: printsplitimage filein nx ny [printer]",
mainName, 1);
filein = argv[1];
nx = atoi(argv[2]);
ny = atoi(argv[3]);
if (argc == 5)
printer = argv[4];
lept_rmdir("split");
lept_mkdir("split");
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &ws, &hs, NULL);
if (ny * ws > nx * hs) {
pixr = pixRotate90(pixs, 1);
pixa = pixaSplitPix(pixr, ny, nx, 0, 0);
} else {
pixr = pixClone(pixs);
pixa = pixaSplitPix(pixr, nx, ny, 0, 0);
}
pixDestroy(&pixr);
n = pixaGetCount(pixa);
sa = sarrayCreate(n);
for (i = 0; i < n; i++) {
pixt = pixaGetPix(pixa, i, L_CLONE);
pixGetDimensions(pixt, &w, &h, NULL);
scale = L_MIN(FILL_FACTOR * 2550 / w, FILL_FACTOR * 3300 / h);
sprintf(buf, "image%d.ps", i);
fname = genPathname("/tmp/split", buf);
fprintf(stderr, "fname: %s\n", fname);
sarrayAddString(sa, fname, L_INSERT);
fp = lept_fopen(fname, "wb+");
pixWriteStreamPS(fp, pixt, NULL, 300, scale);
lept_fclose(fp);
pixDestroy(&pixt);
}
if (argc == 5) {
for (i = 0; i < n; i++) {
fname = sarrayGetString(sa, i, L_NOCOPY);
sprintf(buf, "lpr -P%s %s &", printer, fname);
ignore = system(buf);
}
}
sarrayDestroy(&sa);
pixaDestroy(&pixa);
pixDestroy(&pixs);
return 0;
}
/*!
* dewarpaApplyDisparityBoxa()
*
* Input: dewa
* pageno (of page model to be used; may be a ref model)
* pixs (initial pix reference; for alignment and debugging)
* boxas (boxa to be mapped)
* mapdir (1 if mapping forward from original to dewarped;
* 0 if backward)
* x, y (origin for generation of disparity arrays with
* respect to the source region)
* &boxad (<return> disparity corrected boxa)
* debugfile (use null to skip writing this)
* Return: 0 if OK, 1 on error (no models or ref models available)
*
* Notes:
* (1) This applies the disparity arrays in one of two mapping directions
* to the specified boxa. It can be used in the backward direction
* to locate a box in the original coordinates that would have
* been dewarped to to the specified image.
* (2) If there is no model for @pageno, this will use the model for
* 'refpage' and put the result in the dew for @pageno.
* (3) This works with both stripped and full resolution page models.
* If the full res disparity array(s) are missing, they are remade.
* (4) If an error occurs, a copy of the input boxa is returned.
*/
l_int32
dewarpaApplyDisparityBoxa(L_DEWARPA *dewa,
l_int32 pageno,
PIX *pixs,
BOXA *boxas,
l_int32 mapdir,
l_int32 x,
l_int32 y,
BOXA **pboxad,
const char *debugfile)
{
l_int32 debug_out;
L_DEWARP *dew1, *dew;
BOXA *boxav, *boxah;
PIX *pixv, *pixh;
PROCNAME("dewarpaApplyDisparityBoxa");
/* Initialize the output with the input, so we'll have that
* in case we can't apply the page model. */
if (!pboxad)
return ERROR_INT("&boxad not defined", procName, 1);
*pboxad = boxaCopy(boxas, L_CLONE);
/* Find the appropriate dew to use and fully populate its array(s) */
if (dewarpaApplyInit(dewa, pageno, pixs, x, y, &dew, debugfile))
return ERROR_INT("no model available", procName, 1);
/* Correct for vertical disparity and save the result */
if ((boxav = boxaApplyDisparity(dew, boxas, L_VERT, mapdir)) == NULL) {
dewarpMinimize(dew);
return ERROR_INT("boxa1 not made", procName, 1);
}
boxaDestroy(pboxad);
*pboxad = boxav;
pixv = NULL;
pixh = NULL;
if (debugfile && mapdir != 1)
L_INFO("Reverse map direction; no debug output\n", procName);
debug_out = debugfile && (mapdir == 1);
if (debug_out) {
PIX *pix1;
lept_rmdir("lept/dewboxa"); /* remove previous images */
lept_mkdir("lept/dewboxa");
pix1 = pixConvertTo32(pixs);
pixRenderBoxaArb(pix1, boxas, 2, 255, 0, 0);
pixWrite("/tmp/lept/dewboxa/01.png", pix1, IFF_PNG);
pixDestroy(&pix1);
pixv = pixApplyVertDisparity(dew, pixs, 255);
pix1 = pixConvertTo32(pixv);
pixRenderBoxaArb(pix1, boxav, 2, 0, 255, 0);
pixWrite("/tmp/lept/dewboxa/02.png", pix1, IFF_PNG);
pixDestroy(&pix1);
}
/* Optionally, correct for horizontal disparity */
if (dewa->useboth && dew->hsuccess) {
if (dew->hvalid == FALSE) {
L_INFO("invalid horiz model for page %d\n", procName, pageno);
} else {
boxah = boxaApplyDisparity(dew, boxav, L_HORIZ, mapdir);
if (!boxah) {
L_ERROR("horiz disparity fails on page %d\n", procName, pageno);
} else {
boxaDestroy(pboxad);
*pboxad = boxah;
if (debug_out) {
PIX *pix1;
pixh = pixApplyHorizDisparity(dew, pixv, 255);
pix1 = pixConvertTo32(pixh);
pixRenderBoxaArb(pix1, boxah, 2, 0, 0, 255);
pixWrite("/tmp/lept/dewboxa/03.png", pix1, IFF_PNG);
pixDestroy(&pixh);
pixDestroy(&pix1);
}
}
}
}
if (debug_out) {
pixDestroy(&pixv);
dew1 = dewarpaGetDewarp(dewa, pageno);
dewarpDebug(dew1, "lept/dewapply", 0);
convertFilesToPdf("/tmp/lept/dewboxa", NULL, 135, 1.0, 0, 0,
"Dewarp Apply Disparity Boxa", debugfile);
fprintf(stderr, "Dewarp Apply Disparity Boxa pdf file: %s\n",
debugfile);
}
/* Get rid of the large full res disparity arrays */
dewarpMinimize(dew);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 success;
L_REGPARAMS *rp;
#if !HAVE_LIBGIF && !HAVE_LIBUNGIF
fprintf(stderr, "gifio is not enabled\n"
"libgif or libungif are required for gifio_reg\n"
"See environ.h: #define HAVE_LIBGIF or HAVE_LIBUNGIF 1\n"
"See prog/Makefile: link in -lgif or -lungif\n\n");
return 0;
#endif /* abort */
if (regTestSetup(argc, argv, &rp))
return 1;
pixDisplayWrite(NULL, -1);
lept_rmdir("lept/gif");
lept_mkdir("lept/gif");
/* ------------ Part 1: Test lossless r/w to file ------------*/
test_gif(FILE_1BPP, rp);
test_gif(FILE_2BPP, rp);
test_gif(FILE_4BPP, rp);
test_gif(FILE_8BPP_1, rp);
test_gif(FILE_8BPP_2, rp);
test_gif(FILE_8BPP_3, rp);
test_gif(FILE_16BPP, rp);
test_gif(FILE_32BPP, rp);
if (rp->success) {
fprintf(stderr,
"\n ****** Success on lossless r/w to file *****\n\n");
} else {
fprintf(stderr,
"\n ******* Failure on at least one r/w to file ******\n\n");
}
if (rp->display) {
fprintf(stderr, "Writing to: /tmp/lept/gif/giftest.pdf\n");
pixDisplayMultiple(150, 1.0, "/tmp/lept/gif/giftest.pdf");
}
/* ------------ Part 2: Test lossless r/w to memory ------------ */
success = TRUE;
#if HAVE_FMEMOPEN
pixDisplayWrite(NULL, -1);
if (test_mem_gif(FILE_1BPP, 0)) success = FALSE;
if (test_mem_gif(FILE_2BPP, 1)) success = FALSE;
if (test_mem_gif(FILE_4BPP, 2)) success = FALSE;
if (test_mem_gif(FILE_8BPP_1, 3)) success = FALSE;
if (test_mem_gif(FILE_8BPP_2, 4)) success = FALSE;
if (test_mem_gif(FILE_8BPP_3, 5)) success = FALSE;
if (test_mem_gif(FILE_16BPP, 6)) success = FALSE;
if (test_mem_gif(FILE_32BPP, 7)) success = FALSE;
if (success) {
fprintf(stderr,
"\n ****** Success on lossless r/w to memory *****\n\n");
} else {
fprintf(stderr,
"\n ******* Failure on at least one r/w to memory ******\n\n");
}
#else
fprintf(stderr,
"\n ***** r/w to memory not enabled *****\n\n");
#endif /* HAVE_FMEMOPEN */
/* Success only if all tests are passed */
if (rp->success == TRUE) rp->success = success;
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
char buffer[512];
char *tempfile1, *tempfile2;
l_uint8 *data;
l_int32 i, j, w, h, seq, ret, same;
size_t nbytes;
const char *title;
BOX *box;
BOXA *boxa1, *boxa2;
L_BYTEA *ba;
L_PDF_DATA *lpd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixt, *pixg, *pixgc, *pixc;
static char mainName[] = "pdfiotest";
if (argc != 1)
return ERROR_INT("syntax: pdfiotest", mainName, 1);
l_pdfSetDateAndVersion(0);
lept_mkdir("lept/pdf");
#if 1
/* --------------- Single image tests ------------------- */
fprintf(stderr, "\n*** Writing single images as pdf files\n");
convertToPdf("weasel2.4c.png", L_FLATE_ENCODE, 0, "/tmp/lept/pdf/file01.pdf",
0, 0, 72, "weasel2.4c.png", NULL, 0);
convertToPdf("test24.jpg", L_JPEG_ENCODE, 0, "/tmp/lept/pdf/file02.pdf",
0, 0, 72, "test24.jpg", NULL, 0);
convertToPdf("feyn.tif", L_G4_ENCODE, 0, "/tmp/lept/pdf/file03.pdf",
0, 0, 300, "feyn.tif", NULL, 0);
pixs = pixRead("feyn.tif");
pixConvertToPdf(pixs, L_G4_ENCODE, 0, "/tmp/lept/pdf/file04.pdf", 0, 0, 300,
"feyn.tif", NULL, 0);
pixDestroy(&pixs);
pixs = pixRead("test24.jpg");
pixConvertToPdf(pixs, L_JPEG_ENCODE, 5, "/tmp/lept/pdf/file05.pdf",
0, 0, 72, "test24.jpg", NULL, 0);
pixDestroy(&pixs);
pixs = pixRead("feyn.tif");
pixt = pixScaleToGray2(pixs);
pixWrite("/tmp/lept/pdf/feyn8.png", pixt, IFF_PNG);
convertToPdf("/tmp/lept/pdf/feyn8.png", L_JPEG_ENCODE, 0,
"/tmp/lept/pdf/file06.pdf", 0, 0, 150, "feyn8.png", NULL, 0);
pixDestroy(&pixs);
pixDestroy(&pixt);
convertToPdf("weasel4.16g.png", L_FLATE_ENCODE, 0,
"/tmp/lept/pdf/file07.pdf", 0, 0, 30,
"weasel4.16g.png", NULL, 0);
pixs = pixRead("test24.jpg");
pixg = pixConvertTo8(pixs, 0);
box = boxCreate(100, 100, 100, 100);
pixc = pixClipRectangle(pixs, box, NULL);
pixgc = pixClipRectangle(pixg, box, NULL);
pixWrite("/tmp/lept/pdf/pix32.jpg", pixc, IFF_JFIF_JPEG);
pixWrite("/tmp/lept/pdf/pix8.jpg", pixgc, IFF_JFIF_JPEG);
convertToPdf("/tmp/lept/pdf/pix32.jpg", L_FLATE_ENCODE, 0,
"/tmp/lept/pdf/file08.pdf", 0, 0, 72, "pix32.jpg", NULL, 0);
convertToPdf("/tmp/lept/pdf/pix8.jpg", L_FLATE_ENCODE, 0,
"/tmp/lept/pdf/file09.pdf", 0, 0, 72, "pix8.jpg", NULL, 0);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixc);
pixDestroy(&pixgc);
boxDestroy(&box);
#endif
#if 1
/* --------------- Multiple image tests ------------------- */
fprintf(stderr, "\n*** Writing multiple images as single page pdf files\n");
pix1 = pixRead("feyn-fract.tif");
pix2 = pixRead("weasel8.240c.png");
/* l_pdfSetDateAndVersion(0); */
/* First, write the 1 bpp image through the mask onto the weasels */
for (i = 0; i < 5; i++) {
for (j = 0; j < 10; j++) {
seq = (i == 0 && j == 0) ? L_FIRST_IMAGE : L_NEXT_IMAGE;
title = (i == 0 && j == 0) ? "feyn-fract.tif" : NULL;
pixConvertToPdf(pix2, L_FLATE_ENCODE, 0, NULL, 100 * j,
100 * i, 70, title, &lpd, seq);
}
}
pixConvertToPdf(pix1, L_G4_ENCODE, 0, "/tmp/lept/pdf/file10.pdf", 0, 0, 80,
NULL, &lpd, L_LAST_IMAGE);
/* Now, write the 1 bpp image over the weasels */
l_pdfSetG4ImageMask(0);
for (i = 0; i < 5; i++) {
for (j = 0; j < 10; j++) {
seq = (i == 0 && j == 0) ? L_FIRST_IMAGE : L_NEXT_IMAGE;
title = (i == 0 && j == 0) ? "feyn-fract.tif" : NULL;
pixConvertToPdf(pix2, L_FLATE_ENCODE, 0, NULL, 100 * j,
100 * i, 70, title, &lpd, seq);
}
}
pixConvertToPdf(pix1, L_G4_ENCODE, 0, "/tmp/lept/pdf/file11.pdf", 0, 0, 80,
NULL, &lpd, L_LAST_IMAGE);
l_pdfSetG4ImageMask(1);
pixDestroy(&pix1);
pixDestroy(&pix2);
#endif
#if 1
/* -------- pdf convert segmented with no image regions -------- */
fprintf(stderr, "\n*** Writing segmented images without image regions\n");
pix1 = pixRead("rabi.png");
pix2 = pixScaleToGray2(pix1);
pixWrite("/tmp/lept/pdf/rabi8.jpg", pix2, IFF_JFIF_JPEG);
pix3 = pixThresholdTo4bpp(pix2, 16, 1);
pixWrite("/tmp/lept/pdf/rabi4.png", pix3, IFF_PNG);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 1 bpp input */
convertToPdfSegmented("rabi.png", 300, L_G4_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/lept/pdf/file12.pdf");
convertToPdfSegmented("rabi.png", 300, L_JPEG_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/lept/pdf/file13.pdf");
convertToPdfSegmented("rabi.png", 300, L_FLATE_ENCODE, 128, NULL, 0, 0,
NULL, "/tmp/lept/pdf/file14.pdf");
/* 8 bpp input, no cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_G4_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file15.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_JPEG_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file16.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_FLATE_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file17.pdf");
/* 4 bpp input, cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_G4_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file18.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_JPEG_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file19.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_FLATE_ENCODE, 128,
NULL, 0, 0, NULL, "/tmp/lept/pdf/file20.pdf");
#endif
#if 1
/* ---------- pdf convert segmented with image regions ---------- */
fprintf(stderr, "\n*** Writing segmented images with image regions\n");
/* Get the image region(s) for rabi.png. There are two
* small bogus regions at the top, but we'll keep them for
* the demonstration. */
pix1 = pixRead("rabi.png");
pixSetResolution(pix1, 300, 300);
pixGetDimensions(pix1, &w, &h, NULL);
pix2 = pixGenerateHalftoneMask(pix1, NULL, NULL, NULL);
pix3 = pixMorphSequence(pix2, "c20.1 + c1.20", 0);
boxa1 = pixConnComp(pix3, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, 0.5, 0.5);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
/* 1 bpp input */
convertToPdfSegmented("rabi.png", 300, L_G4_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/lept/pdf/file21.pdf");
convertToPdfSegmented("rabi.png", 300, L_JPEG_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/lept/pdf/file22.pdf");
convertToPdfSegmented("rabi.png", 300, L_FLATE_ENCODE, 128, boxa1,
0, 0.25, NULL, "/tmp/lept/pdf/file23.pdf");
/* 8 bpp input, no cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_G4_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file24.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_JPEG_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file25.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi8.jpg", 150, L_FLATE_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file26.pdf");
/* 4 bpp input, cmap */
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_G4_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file27.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_JPEG_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file28.pdf");
convertToPdfSegmented("/tmp/lept/pdf/rabi4.png", 150, L_FLATE_ENCODE, 128,
boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file29.pdf");
/* 4 bpp input, cmap, data output */
data = NULL;
convertToPdfDataSegmented("/tmp/lept/pdf/rabi4.png", 150, L_G4_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/lept/pdf/file30.pdf", "w", data, nbytes);
lept_free(data);
convertToPdfDataSegmented("/tmp/lept/pdf/rabi4.png", 150, L_JPEG_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/lept/pdf/file31.pdf", "w", data, nbytes);
lept_free(data);
convertToPdfDataSegmented("/tmp/lept/pdf/rabi4.png", 150, L_FLATE_ENCODE,
128, boxa2, 0, 0.5, NULL, &data, &nbytes);
l_binaryWrite("/tmp/lept/pdf/file32.pdf", "w", data, nbytes);
lept_free(data);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
/* -------- pdf convert segmented from color image -------- */
fprintf(stderr, "\n*** Writing color segmented images\n");
pix1 = pixRead("candelabrum.011.jpg");
pix2 = pixScale(pix1, 3.0, 3.0);
pixWrite("/tmp/lept/pdf/candelabrum3.jpg", pix2, IFF_JFIF_JPEG);
GetImageMask(pix2, 200, &boxa1, "/tmp/lept/pdf/seg1.jpg");
convertToPdfSegmented("/tmp/lept/pdf/candelabrum3.jpg", 200, L_G4_ENCODE,
100, boxa1, 0, 0.25, NULL,
"/tmp/lept/pdf/file33.pdf");
convertToPdfSegmented("/tmp/lept/pdf/candelabrum3.jpg", 200, L_JPEG_ENCODE,
100, boxa1, 0, 0.25, NULL,
"/tmp/lept/pdf/file34.pdf");
convertToPdfSegmented("/tmp/lept/pdf/candelabrum3.jpg", 200, L_FLATE_ENCODE,
100, boxa1, 0, 0.25, NULL,
"/tmp/lept/pdf/file35.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
pix1 = pixRead("lion-page.00016.jpg");
pix2 = pixScale(pix1, 3.0, 3.0);
pixWrite("/tmp/lept/pdf/lion16.jpg", pix2, IFF_JFIF_JPEG);
pix3 = pixRead("lion-mask.00016.tif");
boxa1 = pixConnComp(pix3, NULL, 8);
boxa2 = boxaTransform(boxa1, 0, 0, 3.0, 3.0);
convertToPdfSegmented("/tmp/lept/pdf/lion16.jpg", 200, L_G4_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file36.pdf");
convertToPdfSegmented("/tmp/lept/pdf/lion16.jpg", 200, L_JPEG_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file37.pdf");
convertToPdfSegmented("/tmp/lept/pdf/lion16.jpg", 200, L_FLATE_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file38.pdf");
/* Quantize the non-image part and flate encode.
* This is useful because it results in a smaller file than
* when you flate-encode the un-quantized non-image regions. */
pix4 = pixScale(pix3, 3.0, 3.0); /* higher res mask, for combining */
pix5 = QuantizeNonImageRegion(pix2, pix4, 12);
pixWrite("/tmp/lept/pdf/lion16-quant.png", pix5, IFF_PNG);
convertToPdfSegmented("/tmp/lept/pdf/lion16-quant.png", 200, L_FLATE_ENCODE,
190, boxa2, 0, 0.5, NULL, "/tmp/lept/pdf/file39.pdf");
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
/* ------------------ Test multipage pdf generation ----------------- */
fprintf(stderr, "\n*** Writing multipage pdfs from single page pdfs\n");
/* Generate a multi-page pdf from all these files */
startTimer();
concatenatePdf("/tmp/lept/pdf", "file", "/tmp/lept/pdf/cat_lept.pdf");
fprintf(stderr,
"All files have been concatenated: /tmp/lept/pdf/cat_lept.pdf\n"
"Concatenation time: %7.3f\n", stopTimer());
#endif
#if 1
/* ----------- Test corruption recovery by concatenation ------------ */
/* Put two good pdf files in a directory */
lept_rmdir("lept/good");
lept_mkdir("lept/good");
lept_cp("testfile1.pdf", "lept/good", NULL, NULL);
lept_cp("testfile2.pdf", "lept/good", NULL, NULL);
concatenatePdf("/tmp/lept/good", "file", "/tmp/lept/pdf/good.pdf");
/* Make a bad version with the pdf id removed, so that it is not
* recognized as a pdf */
lept_rmdir("lept/bad");
lept_mkdir("lept/bad");
ba = l_byteaInitFromFile("testfile2.pdf");
data = l_byteaGetData(ba, &nbytes);
l_binaryWrite("/tmp/lept/bad/testfile0.notpdf.pdf", "w",
data + 10, nbytes - 10);
/* Make a version with a corrupted trailer */
if (data)
data[2297] = '2'; /* munge trailer object 6: change 458 --> 428 */
l_binaryWrite("/tmp/lept/bad/testfile2.bad.pdf", "w", data, nbytes);
l_byteaDestroy(&ba);
/* Copy testfile1.pdf to the /tmp/lept/bad directory. Then
* run concat on the bad files. The "not pdf" file should be
* ignored, and the corrupted pdf file should be properly parsed,
* so the resulting concatenated pdf files should be identical. */
fprintf(stderr, "\nWe attempt to build from the bad directory\n");
lept_cp("testfile1.pdf", "lept/bad", NULL, NULL);
concatenatePdf("/tmp/lept/bad", "file", "/tmp/lept/pdf/bad.pdf");
filesAreIdentical("/tmp/lept/pdf/good.pdf", "/tmp/lept/pdf/bad.pdf", &same);
if (same)
fprintf(stderr, "Fixed: files are the same\n"
"Attempt succeeded\n");
else
fprintf(stderr, "Busted: files are different\n");
#endif
#if 0
fprintf(stderr, "\n*** pdftk writes multipage pdfs from images\n");
tempfile1 = genPathname("/tmp/lept/pdf", "file*.pdf");
tempfile2 = genPathname("/tmp/lept/pdf", "cat_pdftk.pdf");
snprintf(buffer, sizeof(buffer), "pdftk %s output %s",
tempfile1, tempfile2);
ret = system(buffer); /* pdftk */
lept_free(tempfile1);
lept_free(tempfile2);
#endif
#if 1
/* -- Test simple interface for generating multi-page pdf from images -- */
fprintf(stderr, "\n*** Writing multipage pdfs from images\n");
/* Put four image files in a directory. They will be encoded thus:
* file1.png: flate (8 bpp, only 10 colors)
* file2.jpg: dct (8 bpp, 256 colors because of the jpeg encoding)
* file3.tif: g4 (1 bpp)
* file4.jpg: dct (32 bpp) */
lept_mkdir("lept/image");
pix1 = pixRead("feyn.tif");
pix2 = pixRead("rabi.png");
pix3 = pixScaleToGray3(pix1);
pix4 = pixScaleToGray3(pix2);
pix5 = pixScale(pix1, 0.33, 0.33);
pix6 = pixRead("test24.jpg");
pixWrite("/tmp/lept/image/file1.png", pix3, IFF_PNG); /* 10 colors */
pixWrite("/tmp/lept/image/file2.jpg", pix4, IFF_JFIF_JPEG); /* 256 colors */
pixWrite("/tmp/lept/image/file3.tif", pix5, IFF_TIFF_G4);
pixWrite("/tmp/lept/image/file4.jpg", pix6, IFF_JFIF_JPEG);
startTimer();
convertFilesToPdf("/tmp/lept/image", "file", 100, 0.8, 0, 75, "4 file test",
"/tmp/lept/pdf/fourimages.pdf");
fprintf(stderr, "4-page pdf generated: /tmp/lept/pdf/fourimages.pdf\n"
"Time: %7.3f\n", stopTimer());
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
#endif
return 0;
}
l_int32 main(int argc,
char **argv)
{
char buf[256], rootname[256];
char *dir, *pattern, *psdir, *imagedir;
char *fname, *tail, *filename;
l_int32 i, n, ret;
SARRAY *sa, *saps;
static char mainName[] = "concatpdf";
if (argc != 2 && argc != 3)
return ERROR_INT("Syntax: concatpdf dir [pattern]", mainName, 1);
dir = argv[1];
pattern = (argc == 3) ? argv[2] : NULL;
/* Get the names of the pdf files */
sa = getSortedPathnamesInDirectory(dir, pattern, 0, 0);
sarrayWriteStream(stderr, sa);
n = sarrayGetCount(sa);
#if 1
/* Convert to ps */
psdir = genPathname("/tmp/ps", NULL);
lept_rmdir("ps");
lept_mkdir("ps");
saps = sarrayCreate(n);
for (i = 0; i < n; i++) {
fname = sarrayGetString(sa, i, L_NOCOPY);
splitPathAtDirectory(fname, NULL, &tail);
splitPathAtExtension(tail, &filename, NULL);
snprintf(buf, sizeof(buf), "acroread -toPostScript -annotsOff %s %s",
fname, psdir);
fprintf(stderr, "%s\n", buf);
ret = system(buf); /* acroread -toPostScript -annotsOff */
snprintf(buf, sizeof(buf), "%s/%s.ps", psdir, filename);
sarrayAddString(saps, buf, L_COPY);
lept_free(tail);
lept_free(filename);
}
sarrayDestroy(&sa);
#endif
#if 1
/* Rasterize */
imagedir = genPathname("/tmp/image", NULL);
lept_rmdir("image");
lept_mkdir("image");
sarrayWriteStream(stderr, saps);
n = sarrayGetCount(saps);
for (i = 0; i < n; i++) {
fname = sarrayGetString(saps, i, L_NOCOPY);
snprintf(rootname, sizeof(rootname), "%s/r%d", imagedir, i);
snprintf(buf, sizeof(buf), "ps2png-gray %s %s", fname, rootname);
fprintf(stderr, "%s\n", buf);
ret = system(buf); /* ps2png-gray */
}
#endif
#if 1
/* Generate the pdf */
convertFilesToPdf(imagedir, "png", RESOLUTION, 1.0, L_FLATE_ENCODE,
0, "", "/tmp/output.pdf");
#endif
return 0;
}
/*!
* pixDisplayWriteFormat()
*
* Input: pix (1, 2, 4, 8, 16, 32 bpp)
* reduction (-1 to reset/erase; 0 to disable;
* otherwise this is a reduction factor)
* format (IFF_PNG or IFF_JFIF_JPEG)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) This writes files if reduction > 0. These can be displayed using
* pixDisplayMultiple("/tmp/display/file*");
* (2) All previously written files can be erased by calling with
* reduction < 0; the value of pixs is ignored.
* (3) If reduction > 1 and depth == 1, this does a scale-to-gray
* reduction.
* (4) This function uses a static internal variable to number
* output files written by a single process. Behavior
* with a shared library may be unpredictable.
* (5) Output file format is as follows:
* format == IFF_JFIF_JPEG:
* png if d < 8 or d == 16 or if the output pix
* has a colormap. Otherwise, output is jpg.
* format == IFF_PNG:
* png (lossless) on all images.
* (6) For 16 bpp, the choice of full dynamic range with log scale
* is the best for displaying these images. Alternative outputs are
* pix8 = pixMaxDynamicRange(pixt, L_LINEAR_SCALE);
* pix8 = pixConvert16To8(pixt, 0); // low order byte
* pix8 = pixConvert16To8(pixt, 1); // high order byte
*/
l_int32
pixDisplayWriteFormat(PIX *pixs,
l_int32 reduction,
l_int32 format)
{
char buf[L_BUF_SIZE];
char *fname;
l_float32 scale;
PIX *pixt, *pix8;
static l_int32 index = 0; /* caution: not .so or thread safe */
PROCNAME("pixDisplayWriteFormat");
if (reduction == 0) return 0;
if (reduction < 0) {
index = 0; /* reset; this will cause erasure at next call to write */
return 0;
}
if (format != IFF_JFIF_JPEG && format != IFF_PNG)
return ERROR_INT("invalid format", procName, 1);
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (index == 0) {
lept_rmdir("display");
lept_mkdir("display");
}
index++;
if (reduction == 1) {
pixt = pixClone(pixs);
} else {
scale = 1. / (l_float32)reduction;
if (pixGetDepth(pixs) == 1)
pixt = pixScaleToGray(pixs, scale);
else
pixt = pixScale(pixs, scale, scale);
}
if (pixGetDepth(pixt) == 16) {
pix8 = pixMaxDynamicRange(pixt, L_LOG_SCALE);
snprintf(buf, L_BUF_SIZE, "file.%03d.png", index);
fname = genPathname("/tmp/display", buf);
pixWrite(fname, pix8, IFF_PNG);
pixDestroy(&pix8);
} else if (pixGetDepth(pixt) < 8 || pixGetColormap(pixt) ||
format == IFF_PNG) {
snprintf(buf, L_BUF_SIZE, "file.%03d.png", index);
fname = genPathname("/tmp/display", buf);
pixWrite(fname, pixt, IFF_PNG);
} else {
snprintf(buf, L_BUF_SIZE, "file.%03d.jpg", index);
fname = genPathname("/tmp/display", buf);
pixWrite(fname, pixt, format);
}
FREE(fname);
pixDestroy(&pixt);
return 0;
}
int main(int argc,
char **argv)
{
char buf[512];
char *pathname, *datastr, *formstr;
l_uint8 *data1, *data2;
l_int32 i, bl1, bl2, bl3, sbytes, formbytes, fontsize, rbytes;
size_t nbytes;
PIX *pix1, *pix2, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Generate pixa char bitmap files from file ----------- */
lept_rmdir("filefonts");
lept_mkdir("filefonts");
for (i = 0; i < 9; i++) {
pixaSaveFont("fonts", "/tmp/filefonts", sizes[i]);
pathname = genPathname("/tmp/filefonts", outputfonts[i]);
pixa = pixaRead(pathname);
if (rp->display) {
fprintf(stderr, "Found %d chars in font size %d\n",
pixaGetCount(pixa), sizes[i]);
}
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 - 8 */
if (i == 2) pixDisplayWithTitle(pixd, 100, 0, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
lept_free(pathname);
}
lept_rmdir("filefonts");
/* ---------- Generate pixa char bitmap files from string --------- */
lept_rmdir("strfonts");
lept_mkdir("strfonts");
for (i = 0; i < 9; i++) {
pixaSaveFont(NULL, "/tmp/strfonts", sizes[i]);
pathname = genPathname("/tmp/strfonts", outputfonts[i]);
pixa = pixaRead(pathname);
if (rp->display) {
fprintf(stderr, "Found %d chars in font size %d\n",
pixaGetCount(pixa), sizes[i]);
}
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 9 - 17 */
if (i == 2) pixDisplayWithTitle(pixd, 100, 150, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
lept_free(pathname);
}
/* ----- Use pixaGetFont() and write the result out -----*/
lept_rmdir("pafonts");
lept_mkdir("pafonts");
for (i = 0; i < 9; i++) {
pixa = pixaGetFont("/tmp/strfonts", sizes[i], &bl1, &bl2, &bl3);
fprintf(stderr, "Baselines are at: %d, %d, %d\n", bl1, bl2, bl3);
snprintf(buf, sizeof(buf), "/tmp/pafonts/chars-%d.pa", sizes[i]);
pixaWrite(buf, pixa);
if (i == 2) {
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
pixDisplayWithTitle(pixd, 100, 300, NULL, rp->display);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
}
lept_rmdir("pafonts");
/* ------- Generate 4/3 encoded ascii strings from tiff files ------ */
lept_rmdir("fontencode");
lept_mkdir("fontencode");
for (i = 0; i < 9; i++) {
fontsize = 2 * i + 4;
pathname = genPathname("fonts", inputfonts[i]);
data1 = l_binaryRead(pathname, &nbytes);
datastr = encodeBase64(data1, nbytes, &sbytes);
if (rp->display)
fprintf(stderr, "nbytes = %lu, sbytes = %d\n",
(unsigned long)nbytes, sbytes);
formstr = reformatPacked64(datastr, sbytes, 4, 72, 1, &formbytes);
snprintf(buf, sizeof(buf), "/tmp/fontencode/formstr_%d.txt", fontsize);
l_binaryWrite(buf, "w", formstr, formbytes);
regTestCheckFile(rp, buf); /* 18-26 */
if (i == 8)
pix1 = pixReadMem(data1, nbytes); /* original */
FREE(data1);
data2 = decodeBase64(datastr, sbytes, &rbytes);
snprintf(buf, sizeof(buf), "/tmp/fontencode/image_%d.tif", fontsize);
l_binaryWrite(buf, "w", data2, rbytes);
if (i == 8) {
pix2 = pixReadMem(data2, rbytes); /* encode/decode */
regTestComparePix(rp, pix1, pix2); /* 27 */
pixDestroy(&pix1);
pixDestroy(&pix2);
}
FREE(data2);
FREE(pathname);
FREE(datastr);
FREE(formstr);
}
/* ------------ Get timing for font generation ----------- */
startTimer();
for (i = 0; i < 100; i++) {
pixa = pixaGenerateFontFromString(sizes[5], &bl1, &bl2, &bl3);
pixaDestroy(&pixa);
}
fprintf(stderr, "Time for font gen = %7.4f sec\n", stopTimer() / 100.0);
return regTestCleanup(rp);
}
int main(int argc,
char **argv)
{
l_uint8 *data;
l_int32 w, h, n1, n2, n, i, minval, maxval;
l_int32 ncolors, rval, gval, bval, equal;
l_int32 *rmap, *gmap, *bmap;
l_uint32 color;
l_float32 gamma;
BOX *box;
FILE *fp;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIX *pixs, *pixb, *pixg, *pixc, *pixd;
PIX *pixg2, *pixcs1, *pixcs2, *pixd1, *pixd2;
PIXA *pixa, *pixa2, *pixa3;
PIXCMAP *cmap, *cmap2;
RGBA_QUAD *cta;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------------------ (1) ----------------------------*/
/* Blend with a white background */
pix1 = pixRead("books_logo.png");
pixDisplayWithTitle(pix1, 100, 0, NULL, rp->display);
pix2 = pixAlphaBlendUniform(pix1, 0xffffff00);
pixDisplayWithTitle(pix2, 100, 150, NULL, rp->display);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 1 */
/* Generate an alpha layer based on the white background */
pix3 = pixSetAlphaOverWhite(pix2);
pixSetSpp(pix3, 3);
pixWrite("/tmp/alphaops.2.png", pix3, IFF_PNG); /* without alpha */
regTestCheckFile(rp, "/tmp/alphaops.2.png"); /* 2 */
pixSetSpp(pix3, 4);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 3, with alpha */
pixDisplayWithTitle(pix3, 100, 300, NULL, rp->display);
/* Render on a light yellow background */
pix4 = pixAlphaBlendUniform(pix3, 0xffffe000);
regTestWritePixAndCheck(rp, pix4, IFF_PNG); /* 4 */
pixDisplayWithTitle(pix4, 100, 450, NULL, rp->display);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
/* ------------------------ (2) ----------------------------*/
lept_rmdir("alpha");
lept_mkdir("alpha");
/* Make the transparency (alpha) layer.
* pixs is the mask. We turn it into a transparency (alpha)
* layer by converting to 8 bpp. A small convolution fuzzes
* the mask edges so that you don't see the pixels. */
pixs = pixRead("feyn-fract.tif");
pixGetDimensions(pixs, &w, &h, NULL);
pixg = pixConvert1To8(NULL, pixs, 0, 255);
pixg2 = pixBlockconvGray(pixg, NULL, 1, 1);
regTestWritePixAndCheck(rp, pixg2, IFF_JFIF_JPEG); /* 5 */
pixDisplayWithTitle(pixg2, 0, 0, "alpha", rp->display);
/* Make the viewable image.
* pixc is the image that we see where the alpha layer is
* opaque -- i.e., greater than 0. Scale it to the same
* size as the mask. To visualize what this will look like
* when displayed over a black background, create the black
* background image, pixb, and do the blending with pixcs1
* explicitly using the alpha layer pixg2. */
pixc = pixRead("tetons.jpg");
pixcs1 = pixScaleToSize(pixc, w, h);
regTestWritePixAndCheck(rp, pixcs1, IFF_JFIF_JPEG); /* 6 */
pixDisplayWithTitle(pixcs1, 300, 0, "viewable", rp->display);
pixb = pixCreateTemplate(pixcs1); /* black */
pixd1 = pixBlendWithGrayMask(pixb, pixcs1, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd1, IFF_JFIF_JPEG); /* 7 */
pixDisplayWithTitle(pixd1, 600, 0, "alpha-blended 1", rp->display);
/* Embed the alpha layer pixg2 into the color image pixc.
* Write it out as is. Then clean pixcs1 (to 0) under the fully
* transparent part of the alpha layer, and write that result
* out as well. */
pixSetRGBComponent(pixcs1, pixg2, L_ALPHA_CHANNEL);
pixWrite("/tmp/alpha/pixcs1.png", pixcs1, IFF_PNG);
pixcs2 = pixSetUnderTransparency(pixcs1, 0, 0);
pixWrite("/tmp/alpha/pixcs2.png", pixcs2, IFF_PNG);
/* What will this look like over a black background?
* Do the blending explicitly and display. It should
* look identical to the blended result pixd1 before cleaning. */
pixd2 = pixBlendWithGrayMask(pixb, pixcs2, pixg2, 0, 0);
regTestWritePixAndCheck(rp, pixd2, IFF_JFIF_JPEG); /* 8 */
pixDisplayWithTitle(pixd2, 0, 400, "alpha blended 2", rp->display);
/* Read the two images back, ignoring the transparency layer.
* The uncleaned image will come back identical to pixcs1.
* However, the cleaned image will be black wherever
* the alpha layer was fully transparent. It will
* look the same when viewed through the alpha layer,
* but have much better compression. */
pix1 = pixRead("/tmp/alpha/pixcs1.png"); /* just pixcs1 */
pix2 = pixRead("/tmp/alpha/pixcs2.png"); /* cleaned under transparent */
n1 = nbytesInFile("/tmp/alpha/pixcs1.png");
n2 = nbytesInFile("/tmp/alpha/pixcs2.png");
fprintf(stderr, " Original: %d bytes\n Cleaned: %d bytes\n", n1, n2);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 9 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 10 */
pixDisplayWithTitle(pix1, 300, 400, "without alpha", rp->display);
pixDisplayWithTitle(pix2, 600, 400, "cleaned under transparent",
rp->display);
pixa = pixaCreate(0);
pixSaveTiled(pixg2, pixa, 1.0, 1, 20, 32);
pixSaveTiled(pixcs1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pix1, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pixd1, pixa, 1.0, 1, 20, 0);
pixSaveTiled(pixd2, pixa, 1.0, 0, 20, 0);
pixSaveTiled(pix2, pixa, 1.0, 1, 20, 0);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 200, 200, "composite", rp->display);
pixWrite("/tmp/alpha/alpha.png", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixg);
pixDestroy(&pixg2);
pixDestroy(&pixc);
pixDestroy(&pixcs1);
pixDestroy(&pixcs2);
pixDestroy(&pixd);
pixDestroy(&pixd1);
pixDestroy(&pixd2);
pixDestroy(&pix1);
pixDestroy(&pix2);
/* ------------------------ (3) ----------------------------*/
color = 0xffffa000;
gamma = 1.0;
minval = 0;
maxval = 200;
box = boxCreate(0, 85, 600, 100);
pixa = pixaCreate(6);
pix1 = pixRead("blend-green1.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green2.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-green3.png");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-orange.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-yellow.jpg");
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = pixRead("blend-red.png");
pixaAddPix(pixa, pix1, L_INSERT);
n = pixaGetCount(pixa);
pixa2 = pixaCreate(n);
pixa3 = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 1);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 12, 14, ... 22 */
pixDisplayWithTitle(pix2, 150 * i, 0, NULL, rp->display);
pixaAddPix(pixa2, pix2, L_INSERT);
pix2 = DoBlendTest(pix1, box, color, gamma, minval, maxval, 2);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 13, 15, ... 23 */
pixDisplayWithTitle(pix2, 150 * i, 200, NULL, rp->display);
pixaAddPix(pixa3, pix2, L_INSERT);
pixDestroy(&pix1);
}
if (rp->display) {
pixaConvertToPdf(pixa2, 0, 0.75, L_FLATE_ENCODE, 0, "blend 1 test",
"/tmp/alpha/blending1.pdf");
pixaConvertToPdf(pixa3, 0, 0.75, L_FLATE_ENCODE, 0, "blend 2 test",
"/tmp/alpha/blending2.pdf");
}
pixaDestroy(&pixa);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
boxDestroy(&box);
/* ------------------------ (4) ----------------------------*/
/* Use one image as the alpha component for a second image */
pix1 = pixRead("test24.jpg");
pix2 = pixRead("marge.jpg");
pix3 = pixScale(pix2, 1.9, 2.2);
pix4 = pixConvertTo8(pix3, 0);
pixSetRGBComponent(pix1, pix4, L_ALPHA_CHANNEL);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 24 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
/* Set the alpha value in a colormap to bval */
pix5 = pixOctreeColorQuant(pix1, 128, 0);
cmap = pixGetColormap(pix5);
pixcmapToArrays(cmap, &rmap, &gmap, &bmap, NULL);
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
cta = (RGBA_QUAD *)cmap->array;
cta[i].alpha = bval;
}
/* Test binary serialization/deserialization of colormap with alpha */
pixcmapSerializeToMemory(cmap, 4, &ncolors, &data);
cmap2 = pixcmapDeserializeFromMemory(data, 4, ncolors);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 25 */
pixcmapDestroy(&cmap2);
lept_free(data);
/* Test ascii serialization/deserialization of colormap with alpha */
fp = fopenWriteStream("/tmp/alpha/cmap.4", "w");
pixcmapWriteStream(fp, cmap);
fclose(fp);
fp = fopenReadStream("/tmp/alpha/cmap.4");
cmap2 = pixcmapReadStream(fp);
fclose(fp);
CmapEqual(cmap, cmap2, &equal);
regTestCompareValues(rp, TRUE, equal, 0.0); /* 26 */
pixcmapDestroy(&cmap2);
/* Test r/w for cmapped pix with non-opaque alpha */
pixDisplayWithTitle(pix5, 900, 0, NULL, rp->display);
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 27 */
pixWrite("/tmp/alpha/fourcomp.png", pix5, IFF_PNG);
pix6 = pixRead("/tmp/alpha/fourcomp.png");
regTestComparePix(rp, pix5, pix6); /* 28 */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
lept_free(rmap);
lept_free(gmap);
lept_free(bmap);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
l_int32 i, n, ignore;
l_float32 a, b, c, d, e;
L_DEWARP *dew1, *dew2;
L_DEWARPA *dewa;
FILE *fp;
FPIX *fpix;
NUMA *nax, *nay, *nafit;
PIX *pixs, *pixn, *pixg, *pixb, *pixt1, *pixt2, *pixt3;
PIX *pixs2, *pixn2, *pixg2, *pixb2;
PTA *pta, *ptad;
PTAA *ptaa1, *ptaa2;
/* pixs = pixRead("1555-7.jpg"); */
pixs = pixRead("cat-35.jpg");
/* pixs = pixRead("cat-10.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);
/* Run the basic functions */
dewa = dewarpaCreate(2, 30, 1, 10, 30);
dew1 = dewarpCreate(pixb, 10);
dewarpaInsertDewarp(dewa, dew1);
dewarpBuildModel(dew1, "/tmp/dewarp_model1.pdf");
dewarpaApplyDisparity(dewa, 10, pixg, "/tmp/dewarp_apply1.pdf");
/* Write out some of the files to be imaged */
lept_rmdir("dewtest");
lept_mkdir("dewtest");
pixWrite("/tmp/dewtest/001.jpg", pixs, IFF_JFIF_JPEG);
pixWrite("/tmp/dewtest/002.jpg", pixn, IFF_JFIF_JPEG);
pixWrite("/tmp/dewtest/003.jpg", pixg, IFF_JFIF_JPEG);
pixWrite("/tmp/dewtest/004.png", pixb, IFF_TIFF_G4);
pixt1 = pixRead("/tmp/dewmod/002.png");
pixWrite("/tmp/dewtest/006.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewmod/003.png");
pixWrite("/tmp/dewtest/007.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewmod/006.png");
pixWrite("/tmp/dewtest/008.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewmod/007.png");
pixWrite("/tmp/dewtest/009.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewapply/002.png");
pixWrite("/tmp/dewtest/010.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewapply/003.png");
pixWrite("/tmp/dewtest/011.png", pixt1, IFF_PNG);
pixt2 = pixThresholdToBinary(pixt1, 130);
pixWrite("/tmp/dewtest/012.png", pixt2, IFF_TIFF_G4);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixt1 = pixRead("/tmp/dewmod/004a.png");
pixWrite("/tmp/dewtest/013.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewmod/004b.png");
pixWrite("/tmp/dewtest/014.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewmod/005a.png");
pixWrite("/tmp/dewtest/015.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewmod/005b.png");
pixWrite("/tmp/dewtest/016.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
/* Normalize another image, that may not have enough textlines
* to build an accurate model */
/* pixs2 = pixRead("1555-3.jpg"); */
pixs2 = pixRead("cat-7.jpg");
/* pixs2 = pixRead("cat-14.jpg"); */
pixn2 = pixBackgroundNormSimple(pixs2, NULL, NULL);
pixg2 = pixConvertRGBToGray(pixn2, 0.5, 0.3, 0.2);
pixb2 = pixThresholdToBinary(pixg2, 130);
/* Apply the previous disparity model to this image */
dew2 = dewarpCreate(pixb2, 14);
dewarpaInsertDewarp(dewa, dew2);
dewarpaInsertRefModels(dewa, 1);
/* dewarpaInfo(stderr, dewa); */
dewarpaApplyDisparity(dewa, 14, pixg2, "/tmp/dewarp_apply2.pdf");
dewarpaDestroy(&dewa);
/* Write out files for the second image */
pixWrite("/tmp/dewtest/017.jpg", pixs2, IFF_JFIF_JPEG);
pixWrite("/tmp/dewtest/018.jpg", pixg2, IFF_JFIF_JPEG);
pixWrite("/tmp/dewtest/019.png", pixb2, IFF_TIFF_G4);
pixt1 = pixRead("/tmp/dewmod/006.png");
pixWrite("/tmp/dewtest/020.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewapply/002.png");
pixWrite("/tmp/dewtest/021.png", pixt1, IFF_PNG);
pixt2 = pixThresholdToBinary(pixt1, 130);
pixWrite("/tmp/dewtest/022.png", pixt2, IFF_TIFF_G4);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixt1 = pixRead("/tmp/dewmod/007.png");
pixWrite("/tmp/dewtest/023.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixt1 = pixRead("/tmp/dewapply/003.png");
pixWrite("/tmp/dewtest/024.png", pixt1, IFF_PNG);
pixt2 = pixThresholdToBinary(pixt1, 130);
pixWrite("/tmp/dewtest/025.png", pixt2, IFF_TIFF_G4);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Generate the big pdf file */
convertFilesToPdf("/tmp/dewtest", NULL, 135, 1.0, 0, 0, "Dewarp Test",
"/tmp/dewarp.pdf");
fprintf(stderr, "pdf file made: /tmp/dewarp.pdf\n");
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixs2);
pixDestroy(&pixn2);
pixDestroy(&pixg2);
pixDestroy(&pixb2);
return 0;
}
