/*!
* regTestCheckFile()
*
* Input: rp (regtest parameters)
* localname (name of output file from reg test)
* Return: 0 if OK, 1 on error (a failure in comparison is not an error)
*
* Notes:
* (1) This function does one of three things, depending on the mode:
* * "generate": makes a "golden" file as a copy @localname.
* * "compare": compares @localname contents with the golden file
* * "display": makes the @localname file but does no comparison
* (2) The canonical format of the golden filenames is:
* /tmp/golden/<root of main name>_golden.<index>.<ext of localname>
* e.g.,
* /tmp/golden/maze_golden.0.png
* It is important to add an extension to the local name, because
* the extension is added to the name of the golden file.
*/
l_int32
regTestCheckFile(L_REGPARAMS *rp,
const char *localname)
{
char *ext;
char namebuf[256];
l_int32 ret, same;
PROCNAME("regTestCheckFile");
if (!rp)
return ERROR_INT("rp not defined", procName, 1);
if (!localname) {
rp->success = FALSE;
return ERROR_INT("local name not defined", procName, 1);
}
if (rp->mode != L_REG_GENERATE && rp->mode != L_REG_COMPARE &&
rp->mode != L_REG_DISPLAY) {
rp->success = FALSE;
return ERROR_INT("invalid mode", procName, 1);
}
rp->index++;
if (rp->mode == L_REG_DISPLAY) return 0;
/* Generate the golden file name; used in 'generate' and 'compare' */
splitPathAtExtension(localname, NULL, &ext);
snprintf(namebuf, sizeof(namebuf), "/tmp/golden/%s_golden.%d%s",
rp->testname, rp->index, ext);
FREE(ext);
if (rp->mode == L_REG_GENERATE) {
/* Save the file as a golden file */
/* fprintf(stderr, "%d: %s\n", rp->index, namebuf); */
ret = fileCopy(localname, namebuf);
if (!ret)
fprintf(stderr, "Copy: %s to %s\n", localname, namebuf);
return ret;
}
/* Compare mode: test and record on failure */
filesAreIdentical(localname, namebuf, &same);
if (!same) {
fprintf(rp->fp, "Failure in %s_reg, index %d: comparing %s with %s\n",
rp->testname, rp->index, localname, namebuf);
fprintf(stderr, "Failure in %s_reg, index %d: comparing %s with %s\n",
rp->testname, rp->index, localname, namebuf);
rp->success = FALSE;
}
return 0;
}
/*!
* regTestCheckFile()
*
* Input: stream (for output; use NULL to generate golden files)
* argv ([0] == name of reg test)
* localname (name of output file from reg test)
* index (of the output file under test; 0-based for the reg test)
* &success (<return> 0 on failure; input value on success)
* Return: 0 if OK, 1 on error (a failure in comparison is not an error)
*
* Notes:
* (1) This function either compares an input file with a "golden" file,
* or generates a "golden" file as a copy @localname.
* Call with @fp == NULL to generate a new golden file.
* (2) This function can be called repeatedly in a single reg test.
* (3) The value for @success is initialized to TRUE in the reg test
* setup before this function is called for the first time.
* A failure in any single file comparison is registered
* as a failure of the regression test.
* (4) The canonical format of the golden filenames is:
* /tmp/<root of main name>_golden.<index>.<ext of localname>
* e.g.,
* /tmp/maze_golden.0.png
*/
l_int32
regTestCheckFile(FILE *fp,
char **argv,
const char *localname,
l_int32 index,
l_int32 *psuccess)
{
char *root, *ext;
char namebuf[64];
l_int32 ret, same;
PROCNAME("regTestCheckFile");
if (!psuccess)
return ERROR_INT("&success not defined", procName, 1);
if (!localname)
return ERROR_INT("local name not defined", procName, 1);
if (index < 0)
return ERROR_INT("index is negative", procName, 1);
/* Generate the golden file name */
if ((root = getRootNameFromArgv0(argv[0])) == NULL)
return ERROR_INT("invalid root", procName, 1);
splitPathAtExtension(localname, NULL, &ext);
snprintf(namebuf, sizeof(namebuf), "/tmp/%s_golden.%d%s", root, index, ext);
FREE(root);
FREE(ext);
/* Save the file as a golden file */
if (!fp) {
ret = fileCopy(localname, namebuf);
if (!ret)
fprintf(stderr, "Copy: %s to %s\n", localname, namebuf);
return ret;
}
/* Test and record on failure */
filesAreIdentical(localname, namebuf, &same);
if (!same) {
fprintf(fp, "Failure in %s: comparing %s with %s\n", argv[0],
localname, namebuf);
fprintf(stderr, "Failure in %s: comparing %s with %s\n", argv[0],
localname, namebuf);
*psuccess = 0;
}
return 0;
}
/*!
* getImpliedFileFormat()
*
* Input: filename
* Return: output format, or IFF_UNKNOWN on error or invalid extension.
*
* Notes:
* (1) This determines the output file format from the extension
* of the input filename.
*/
l_int32
getImpliedFileFormat(const char *filename)
{
char *extension;
int i, numext;
l_int32 format = IFF_UNKNOWN;
if (splitPathAtExtension (filename, NULL, &extension))
return IFF_UNKNOWN;
numext = sizeof(extension_map) / sizeof(extension_map[0]);
for (i = 0; i < numext; i++) {
if (!strcmp(extension, extension_map[i].extension)) {
format = extension_map[i].format;
break;
}
}
FREE(extension);
return format;
}
/*!
* regTestCheckFile()
*
* Input: rp (regtest parameters)
* localname (name of output file from reg test)
* Return: 0 if OK, 1 on error (a failure in comparison is not an error)
*
* Notes:
* (1) This function does one of three things, depending on the mode:
* * "generate": makes a "golden" file as a copy @localname.
* * "compare": compares @localname contents with the golden file
* * "display": makes the @localname file but does no comparison
* (2) The canonical format of the golden filenames is:
* /tmp/golden/<root of main name>_golden.<index>.<ext of localname>
* e.g.,
* /tmp/golden/maze_golden.0.png
* It is important to add an extension to the local name, because
* the extension is added to the name of the golden file.
*/
l_int32
regTestCheckFile(L_REGPARAMS *rp,
const char *localname) {
char *ext;
char namebuf[256];
l_int32 ret, same, format;
PIX *pix1, *pix2;
PROCNAME("regTestCheckFile");
if (!rp)
return ERROR_INT("rp not defined", procName, 1);
if (!localname) {
rp->success = FALSE;
return ERROR_INT("local name not defined", procName, 1);
}
if (rp->mode != L_REG_GENERATE && rp->mode != L_REG_COMPARE &&
rp->mode != L_REG_DISPLAY) {
rp->success = FALSE;
return ERROR_INT("invalid mode", procName, 1);
}
rp->index++;
/* If display mode, no generation and no testing */
if (rp->mode == L_REG_DISPLAY) return 0;
/* Generate the golden file name; used in 'generate' and 'compare' */
splitPathAtExtension(localname, NULL, &ext);
snprintf(namebuf, sizeof(namebuf), "/tmp/golden/%s_golden.%02d%s",
rp->testname, rp->index, ext);
FREE(ext);
/* Generate mode. No testing. */
if (rp->mode == L_REG_GENERATE) {
/* Save the file as a golden file */
ret = fileCopy(localname, namebuf);
#if 0 /* Enable for details on writing of golden files */
if (!ret) {
char *local = genPathname(localname, NULL);
char *golden = genPathname(namebuf, NULL);
L_INFO("Copy: %s to %s\n", procName, local, golden);
FREE(local);
FREE(golden);
}
#endif
return ret;
}
/* Compare mode: test and record on failure. GIF compression
* is lossless for images with up to 8 bpp (but not for RGB
* because it must generate a 256 color palette). Although
* the read/write cycle for GIF is idempotent in the image
* pixels for bpp <= 8, it is not idempotent in the actual
* file bytes. Tests comparing file bytes before and after
* a GIF read/write cycle will fail. So for GIF we uncompress
* the two images and compare the actual pixels. From my tests,
* PNG, in addition to being lossless, is idempotent in file
* bytes on read/write, so comparing the pixels is not necessary.
* (It also increases the regression test time by an an average
* of about 8%.) JPEG is lossy and not idempotent in the image
* pixels, so no tests are constructed that would require it. */
findFileFormat(localname, &format);
if (format == IFF_GIF) {
same = 0;
pix1 = pixRead(localname);
pix2 = pixRead(namebuf);
pixEqual(pix1, pix2, &same);
pixDestroy(&pix1);
pixDestroy(&pix2);
} else {
filesAreIdentical(localname, namebuf, &same);
}
if (!same) {
fprintf(rp->fp, "Failure in %s_reg, index %d: comparing %s with %s\n",
rp->testname, rp->index, localname, namebuf);
fprintf(stderr, "Failure in %s_reg, index %d: comparing %s with %s\n",
rp->testname, rp->index, localname, namebuf);
rp->success = FALSE;
}
return 0;
}
/*!
* convertFilesTo1bpp()
*
* Input: dirin
* substr (<optional> substring filter on filenames; can be NULL)
* upscaling (1, 2 or 4; only for input color or grayscale)
* thresh (global threshold for binarization; use 0 for default)
* firstpage
* npages (use 0 to do all from @firstpage to the end)
* dirout
* outformat (IFF_PNG, IFF_TIFF_G4)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Images are sorted lexicographically, and the names in the
* output directory are retained except for the extension.
*/
l_int32
convertFilesTo1bpp(const char *dirin,
const char *substr,
l_int32 upscaling,
l_int32 thresh,
l_int32 firstpage,
l_int32 npages,
const char *dirout,
l_int32 outformat) {
l_int32 i, nfiles;
char buf[512];
char *fname, *tail, *basename;
PIX *pixs, *pixg1, *pixg2, *pixb;
SARRAY *safiles;
PROCNAME("convertFilesTo1bpp");
if (!dirin)
return ERROR_INT("dirin", procName, 1);
if (!dirout)
return ERROR_INT("dirout", procName, 1);
if (upscaling != 1 && upscaling != 2 && upscaling != 4)
return ERROR_INT("invalid upscaling factor", procName, 1);
if (thresh <= 0) thresh = 180;
if (firstpage < 0) firstpage = 0;
if (npages < 0) npages = 0;
if (outformat != IFF_TIFF_G4)
outformat = IFF_PNG;
safiles = getSortedPathnamesInDirectory(dirin, substr, firstpage, npages);
if (!safiles)
return ERROR_INT("safiles not made", procName, 1);
if ((nfiles = sarrayGetCount(safiles)) == 0) {
sarrayDestroy(&safiles);
return ERROR_INT("no matching files in the directory", procName, 1);
}
for (i = 0; i < nfiles; i++) {
fname = sarrayGetString(safiles, i, L_NOCOPY);
if ((pixs = pixRead(fname)) == NULL) {
L_WARNING("Couldn't read file %s\n", procName, fname);
continue;
}
if (pixGetDepth(pixs) == 32)
pixg1 = pixConvertRGBToLuminance(pixs);
else
pixg1 = pixClone(pixs);
pixg2 = pixRemoveColormap(pixg1, REMOVE_CMAP_TO_GRAYSCALE);
if (pixGetDepth(pixg2) == 1) {
pixb = pixClone(pixg2);
} else {
if (upscaling == 1)
pixb = pixThresholdToBinary(pixg2, thresh);
else if (upscaling == 2)
pixb = pixScaleGray2xLIThresh(pixg2, thresh);
else /* upscaling == 4 */
pixb = pixScaleGray4xLIThresh(pixg2, thresh);
}
pixDestroy(&pixs);
pixDestroy(&pixg1);
pixDestroy(&pixg2);
splitPathAtDirectory(fname, NULL, &tail);
splitPathAtExtension(tail, &basename, NULL);
if (outformat == IFF_TIFF_G4) {
snprintf(buf, sizeof(buf), "%s/%s.tif", dirout, basename);
pixWrite(buf, pixb, IFF_TIFF_G4);
} else {
snprintf(buf, sizeof(buf), "%s/%s.png", dirout, basename);
pixWrite(buf, pixb, IFF_PNG);
}
pixDestroy(&pixb);
FREE(tail);
FREE(basename);
}
sarrayDestroy(&safiles);
return 0;
}
int main(int argc,
char **argv)
{
PIX *pixs;
char *filein, *fileout, *base, *ext;
const char *formatstr;
l_int32 format;
l_int32 d;
static char mainName[] = "convertformat";
if (argc != 3 && argc != 4) {
fprintf(stderr, "Syntax: convertformat filein fileout [format]\n"
"If you don't specify a format, the output file\n"
"needs one of these seven extensions:\n"
" bmp, jpg, png, tif, pnm, gif, webp\n");
return 1;
}
filein = argv[1];
fileout = argv[2];
if (argc == 3) {
splitPathAtExtension(fileout, NULL, &ext);
if (!strcmp(ext, ".bmp"))
format = IFF_BMP;
else if (!strcmp(ext, ".jpg"))
format = IFF_JFIF_JPEG;
else if (!strcmp(ext, ".png"))
format = IFF_PNG;
else if (!strcmp(ext, ".tif")) /* requesting g4-tiff binary comp */
format = IFF_TIFF_G4;
else if (!strcmp(ext, ".pnm"))
format = IFF_PNM;
else if (!strcmp(ext, ".gif"))
format = IFF_GIF;
else if (!strcmp(ext, ".webp"))
format = IFF_WEBP;
else {
return ERROR_INT(
"Valid extensions: bmp, jpg, png, tif, pnm, gif, webp",
mainName, 1);
}
lept_free(ext);
}
else {
formatstr = argv[3];
if (!strcmp(formatstr, "BMP"))
format = IFF_BMP;
else if (!strcmp(formatstr, "JPEG"))
format = IFF_JFIF_JPEG;
else if (!strcmp(formatstr, "PNG"))
format = IFF_PNG;
else if (!strcmp(formatstr, "TIFF"))
format = IFF_TIFF_G4;
else if (!strcmp(formatstr, "PNM"))
format = IFF_PNM;
else if (!strcmp(formatstr, "GIF"))
format = IFF_GIF;
else if (!strcmp(formatstr, "WEBP"))
format = IFF_WEBP;
else {
return ERROR_INT(
"Valid formats: BMP, JPEG, PNG, TIFF, PNM, GIF, WEBP",
mainName, 1);
}
}
if ((pixs = pixRead(filein)) == NULL) {
L_ERROR("read fail for %s\n", mainName, filein);
return 1;
}
d = pixGetDepth(pixs);
if (d != 1 && format == IFF_TIFF_G4) {
L_WARNING("can't convert to tiff_g4; converting to png\n", mainName);
format = IFF_PNG;
}
if (d < 8 && format == IFF_JFIF_JPEG) {
L_WARNING("can't convert to jpeg; converting to png\n", mainName);
splitPathAtExtension(fileout, &base, &ext);
fileout = stringJoin(base, ".png");
format = IFF_PNG;
}
if (d < 8 && format == IFF_WEBP) {
L_WARNING("can't convert to webp; converting to png\n", mainName);
splitPathAtExtension(fileout, &base, &ext);
fileout = stringJoin(base, ".png");
format = IFF_PNG;
}
pixWrite(fileout, pixs, format);
return 0;
}
/*!
* pixWrite()
*
* Input: filename
* pix
* format (defined in imageio.h)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) Open for write using binary mode (with the "b" flag)
* to avoid having Windows automatically translate the NL
* into CRLF, which corrupts image files. On non-windows
* systems this flag should be ignored, per ISO C90.
* Thanks to Dave Bryan for pointing this out.
* (2) If the default image format is requested, we use the input format;
* if the input format is unknown, a lossless format is assigned.
* (3) There are two modes with respect to file naming.
* (a) The default code writes to @filename.
* (b) If WRITE_AS_NAMED is defined to 0, it's a bit fancier.
* Then, if @filename does not have a file extension, one is
* automatically appended, depending on the requested format.
* The original intent for providing option (b) was to insure
* that filenames on Windows have an extension that matches
* the image compression. However, this is not the default.
*/
l_int32
pixWrite(const char *filename,
PIX *pix,
l_int32 format)
{
char *fname;
FILE *fp;
PROCNAME("pixWrite");
if (!pix)
return ERROR_INT("pix not defined", procName, 1);
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (format == IFF_JP2)
return ERROR_INT("jp2 not supported", procName, 1);
fname = genPathname(filename, NULL);
#if WRITE_AS_NAMED /* Default */
if ((fp = fopenWriteStream(fname, "wb+")) == NULL) {
FREE(fname);
return ERROR_INT("stream not opened", procName, 1);
}
#else /* Add an extension to the output name if none exists */
{l_int32 extlen;
char *extension, *filebuf;
splitPathAtExtension(fname, NULL, &extension);
extlen = strlen(extension);
FREE(extension);
if (extlen == 0) {
if (format == IFF_DEFAULT || format == IFF_UNKNOWN)
format = pixChooseOutputFormat(pix);
filebuf = (char *)CALLOC(strlen(fname) + 10, sizeof(char));
if (!filebuf) {
return ERROR_INT("filebuf not made", procName, 1);
FREE(fname);
}
strncpy(filebuf, fname, strlen(fname));
strcat(filebuf, ".");
strcat(filebuf, ImageFileFormatExtensions[format]);
} else {
filebuf = (char *)fname;
}
fp = fopenWriteStream(filebuf, "wb+");
if (filebuf != fname)
FREE(filebuf);
if (fp == NULL) {
FREE(fname);
return ERROR_INT("stream not opened", procName, 1);
}
}
#endif /* WRITE_AS_NAMED */
FREE(fname);
if (pixWriteStream(fp, pix, format)) {
fclose(fp);
return ERROR_INT("pix not written to stream", procName, 1);
}
/* Close the stream except if GIF under windows, because
* EGifCloseFile() closes the windows file stream! */
if (format != IFF_GIF)
fclose(fp);
#ifndef _WIN32
else /* gif file */
fclose(fp);
#endif /* ! _WIN32 */
return 0;
}
/*!
* \brief pixWrite()
*
* \param[in] filename
* \param[in] pix
* \param[in] format defined in imageio.h
* \return 0 if OK; 1 on error
*
* <pre>
* Notes:
* (1) Open for write using binary mode (with the "b" flag)
* to avoid having Windows automatically translate the NL
* into CRLF, which corrupts image files. On non-windows
* systems this flag should be ignored, per ISO C90.
* Thanks to Dave Bryan for pointing this out.
* (2) If the default image format IFF_DEFAULT is requested:
* use the input format if known; otherwise, use a lossless format.
* (3) There are two modes with respect to file naming.
* (a) The default code writes to %filename.
* (b) If WRITE_AS_NAMED is defined to 0, it's a bit fancier.
* Then, if %filename does not have a file extension, one is
* automatically appended, depending on the requested format.
* The original intent for providing option (b) was to insure
* that filenames on Windows have an extension that matches
* the image compression. However, this is not the default.
* </pre>
*/
l_int32
pixWrite(const char *filename,
PIX *pix,
l_int32 format)
{
char *fname;
FILE *fp;
PROCNAME("pixWrite");
if (!pix)
return ERROR_INT("pix not defined", procName, 1);
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
fname = genPathname(filename, NULL);
#if WRITE_AS_NAMED /* Default */
if ((fp = fopenWriteStream(fname, "wb+")) == NULL) {
LEPT_FREE(fname);
return ERROR_INT("stream not opened", procName, 1);
}
#else /* Add an extension to the output name if none exists */
{l_int32 extlen;
char *extension, *filebuf;
splitPathAtExtension(fname, NULL, &extension);
extlen = strlen(extension);
LEPT_FREE(extension);
if (extlen == 0) {
if (format == IFF_DEFAULT || format == IFF_UNKNOWN)
format = pixChooseOutputFormat(pix);
filebuf = (char *)LEPT_CALLOC(strlen(fname) + 10, sizeof(char));
if (!filebuf) {
return ERROR_INT("filebuf not made", procName, 1);
LEPT_FREE(fname);
}
strncpy(filebuf, fname, strlen(fname));
strcat(filebuf, ".");
strcat(filebuf, ImageFileFormatExtensions[format]);
} else {
filebuf = (char *)fname;
}
fp = fopenWriteStream(filebuf, "wb+");
if (filebuf != fname)
LEPT_FREE(filebuf);
if (fp == NULL) {
LEPT_FREE(fname);
return ERROR_INT("stream not opened", procName, 1);
}
}
#endif /* WRITE_AS_NAMED */
LEPT_FREE(fname);
if (pixWriteStream(fp, pix, format)) {
fclose(fp);
return ERROR_INT("pix not written to stream", procName, 1);
}
fclose(fp);
return 0;
}
l_int32 main(int argc,
char **argv)
{
char buf[256], dirname[256];
char *dirin, *pattern, *subdirout, *fname, *tail, *basename;
l_int32 thresh, i, n;
l_float32 scalefactor;
PIX *pix1, *pix2, *pix3, *pix4;
SARRAY *sa;
static char mainName[] = "binarizefiles.c";
if (argc != 6) {
fprintf(stderr,
"Syntax: binarizefiles dirin pattern thresh scalefact dirout\n"
" dirin: input directory for image files\n"
" pattern: use 'allfiles' to convert all files\n"
" in the directory\n"
" thresh: 0 for adaptive; > 0 for global thresh (e.g., 128)\n"
" scalefactor: in (0.0 ... 4.0]; use 1.0 to prevent scaling\n"
" subdirout: subdirectory of /tmp for output files\n");
return 1;
}
dirin = argv[1];
pattern = argv[2];
thresh = atoi(argv[3]);
scalefactor = atof(argv[4]);
subdirout = argv[5];
if (!strcmp(pattern, "allfiles"))
pattern = NULL;
if (scalefactor <= 0.0 || scalefactor > 4.0) {
L_WARNING("invalid scalefactor: setting to 1.0\n", mainName);
scalefactor = 1.0;
}
/* Get the input filenames */
sa = getSortedPathnamesInDirectory(dirin, pattern, 0, 0);
sarrayWriteStream(stderr, sa);
n = sarrayGetCount(sa);
/* Write the output files */
makeTempDirname(dirname, 256, subdirout);
fprintf(stderr, "dirname: %s\n", dirname);
lept_mkdir(subdirout);
for (i = 0; i < n; i++) {
fname = sarrayGetString(sa, i, L_NOCOPY);
if ((pix1 = pixRead(fname)) == NULL) {
L_ERROR("file %s not read as image", mainName, fname);
continue;
}
splitPathAtDirectory(fname, NULL, &tail);
splitPathAtExtension(tail, &basename, NULL);
snprintf(buf, sizeof(buf), "%s/%s.tif", dirname, basename);
FREE(tail);
FREE(basename);
fprintf(stderr, "fileout: %s\n", buf);
if (scalefactor != 1.0)
pix2 = pixScale(pix1, scalefactor, scalefactor);
else
pix2 = pixClone(pix1);
if (thresh == 0) {
pix4 = pixConvertTo8(pix2, 0);
pix3 = pixAdaptThresholdToBinary(pix4, NULL, 1.0);
pixDestroy(&pix4);
} else {
pix3 = pixConvertTo1(pix2, thresh);
}
pixWrite(buf, pix3, IFF_TIFF_G4);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
sarrayDestroy(&sa);
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;
}
main(int argc,
char **argv)
{
PIX *pixs;
char *filein, *fileout, *base, *ext;
const char *format;
char error_msg[] = "Valid formats: BMP, JPEG, PNG, TIFF, TIFF_G4, PNM";
l_int32 d;
static char mainName[] = "convertformat";
if (argc != 3 && argc != 4) {
fprintf(stderr, "Syntax: convertformat filein fileout [format]\n");
fprintf(stderr, "%s\n", error_msg);
fprintf(stderr, "If you don't specify a format, the output file needs");
fprintf(stderr, " an extension such as:\n");
fprintf(stderr, " .bmp, .jpg, .png, .tif or .pnm\n");
return 1;
}
filein = argv[1];
fileout = argv[2];
if (argc == 3) {
splitPathAtExtension(fileout, NULL, &ext);
if (!strcmp(ext, ".bmp"))
format = "BMP";
else if (!strcmp(ext, ".jpg"))
format = "JPEG";
else if (!strcmp(ext, ".png"))
format = "PNG";
else if (!strcmp(ext, ".tif"))
format = "TIFF_G4";
else if (!strcmp(ext, ".pnm"))
format = "PNM";
else
return ERROR_INT(error_msg, mainName, 1);
lept_free(ext);
}
else
format = argv[3];
pixs = pixRead(filein);
d = pixGetDepth(pixs);
if (d != 1 && !strcmp(format, "TIFF_G4")) {
L_WARNING("can't convert to tiff_g4; converting to tiff", mainName);
format = "TIFF";
}
if (d < 8 && !strcmp(format, "JPEG")) {
L_WARNING("can't convert to jpeg; converting to png", mainName);
splitPathAtExtension(fileout, &base, &ext);
fileout = stringJoin(base, ".png");
format = "PNG";
}
if (strcmp(format, "BMP") == 0)
pixWrite(fileout, pixs, IFF_BMP);
else if (strcmp(format, "JPEG") == 0)
pixWrite(fileout, pixs, IFF_JFIF_JPEG);
else if (strcmp(format, "PNG") == 0)
pixWrite(fileout, pixs, IFF_PNG);
else if (strcmp(format, "TIFF") == 0)
pixWrite(fileout, pixs, IFF_TIFF_ZIP);
else if (strcmp(format, "TIFF_G4") == 0)
pixWrite(fileout, pixs, IFF_TIFF_G4);
else if (strcmp(format, "PNM") == 0)
pixWrite(fileout, pixs, IFF_PNM);
else
return ERROR_INT(error_msg, mainName, 1);
return 0;
}
