/*!
* \brief recogWriteStream()
*
* \param[in] fp file stream opened for "wb"
* \param[in] recog
* \return 0 if OK, 1 on error
*/
l_int32
recogWriteStream(FILE *fp,
L_RECOG *recog)
{
PROCNAME("recogWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!recog)
return ERROR_INT("recog not defined", procName, 1);
fprintf(fp, "\nRecog Version %d\n", RECOG_VERSION_NUMBER);
fprintf(fp, "Size of character set = %d\n", recog->setsize);
fprintf(fp, "Binarization threshold = %d\n", recog->threshold);
fprintf(fp, "Maxyshift = %d\n", recog->maxyshift);
fprintf(fp, "Scale to width = %d\n", recog->scalew);
fprintf(fp, "Scale to height = %d\n", recog->scaleh);
fprintf(fp, "Normalized line width = %d\n", recog->linew);
fprintf(fp, "\nLabels for character set:\n");
l_dnaWriteStream(fp, recog->dna_tochar);
sarrayWriteStream(fp, recog->sa_text);
fprintf(fp, "\nPixaa of all samples in the training set:\n");
pixaaWriteStream(fp, recog->pixaa);
return 0;
}
/*!
* gplotWrite()
*
* Input: filename
* gplot
* Return: 0 if OK; 1 on error
*/
l_int32
gplotWrite(const char *filename,
GPLOT *gplot)
{
FILE *fp;
PROCNAME("gplotWrite");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!gplot)
return ERROR_INT("gplot not defined", procName, 1);
if ((fp = fopenWriteStream(filename, "wb")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
fprintf(fp, "Gplot Version %d\n", GPLOT_VERSION_NUMBER);
fprintf(fp, "Rootname: %s\n", gplot->rootname);
fprintf(fp, "Output format: %d\n", gplot->outformat);
fprintf(fp, "Title: %s\n", gplot->title);
fprintf(fp, "X axis label: %s\n", gplot->xlabel);
fprintf(fp, "Y axis label: %s\n", gplot->ylabel);
fprintf(fp, "Commandfile name: %s\n", gplot->cmdname);
fprintf(fp, "\nCommandfile data:");
sarrayWriteStream(fp, gplot->cmddata);
fprintf(fp, "\nDatafile names:");
sarrayWriteStream(fp, gplot->datanames);
fprintf(fp, "\nPlot data:");
sarrayWriteStream(fp, gplot->plotdata);
fprintf(fp, "\nPlot titles:");
sarrayWriteStream(fp, gplot->plottitles);
fprintf(fp, "\nPlot styles:");
numaWriteStream(fp, gplot->plotstyles);
fprintf(fp, "Number of plots: %d\n", gplot->nplots);
fprintf(fp, "Output file name: %s\n", gplot->outname);
fprintf(fp, "Axis scaling: %d\n", gplot->scaling);
fclose(fp);
return 0;
}
/*!
* sarrayAppend()
*
* Input: filename
* sarray
* Return: 0 if OK; 1 on error
*/
l_int32
sarrayAppend(const char *filename,
SARRAY *sa)
{
FILE *fp;
PROCNAME("sarrayAppend");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!sa)
return ERROR_INT("sa not defined", procName, 1);
if ((fp = fopen(filename, "a")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
if (sarrayWriteStream(fp, sa))
return ERROR_INT("sa not appended to stream", procName, 1);
fclose(fp);
return 0;
}
l_int32 main(int argc,
char **argv)
{
char *boxatxt;
l_int32 i;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa, *baa1;
NUMAA *naa1;
PIX *pixdb, *pix1, *pix2, *pix3, *pix4;
PIXA *pixa1, *pixa2, *pixa3, *pixat;
L_RECOG *recog;
L_RECOGA *recoga;
SARRAY *sa1;
/* ----- Example identifying samples using training data ----- */
#if 1
/* Read the training data */
pixat = pixaRead("recog/sets/train06.pa");
recog = recogCreateFromPixa(pixat, 0, 0, L_USE_ALL, 128, 1);
recoga = recogaCreateFromRecog(recog);
pixaDestroy(&pixat);
/* Read the data from all samples */
pix1 = pixRead("recog/sets/samples06.png");
boxatxt = pixGetText(pix1);
boxa1 = boxaReadMem((l_uint8 *)boxatxt, strlen(boxatxt));
pixa1 = pixaCreateFromBoxa(pix1, boxa1, NULL);
pixDestroy(&pix1); /* destroys boxa1 */
/* Identify components in the sample data */
pixa2 = pixaCreate(0);
pixa3 = pixaCreate(0);
for (i = 0; i < 9; i++) {
/* if (i != 4) continue; */ /* dots form separate boxa */
/* if (i != 8) continue; */ /* broken 2 in '24' */
pix1 = pixaGetPix(pixa1, i, L_CLONE);
/* Show the 2d box data in the sample */
boxa2 = pixConnComp(pix1, NULL, 8);
baa = boxaSort2d(boxa2, NULL, 6, 6, 5);
pix2 = boxaaDisplay(baa, 3, 1, 0xff000000, 0x00ff0000, 0, 0);
pixaAddPix(pixa3, pix2, L_INSERT);
boxaaDestroy(&baa);
boxaDestroy(&boxa2);
/* Get the numbers in the sample */
recogaIdentifyMultiple(recoga, pix1, 0, 5, 3, &boxa3, NULL, &pixdb, 0);
sa1 = recogaExtractNumbers(recoga, boxa3, 0.7, -1, &baa1, &naa1);
sarrayWriteStream(stderr, sa1);
boxaaWriteStream(stderr, baa1);
numaaWriteStream(stderr, naa1);
pixaAddPix(pixa2, pixdb, L_INSERT);
/* pixaWrite("/tmp/pixa.pa", pixa2); */
pixDestroy(&pix1);
boxaDestroy(&boxa3);
boxaaDestroy(&baa1);
numaaDestroy(&naa1);
sarrayDestroy(&sa1);
}
pix3 = pixaDisplayLinearly(pixa2, L_VERT, 1.0, 0, 20, 1, NULL);
pixWrite("/tmp/pix3.png", pix3, IFF_PNG);
pix4 = pixaDisplayTiledInRows(pixa3, 32, 1500, 1.0, 0, 20, 2);
pixDisplay(pix4, 500, 0);
pixWrite("/tmp/pix4.png", pix4, IFF_PNG);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixDestroy(&pix1);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
recogaDestroy(&recoga);
#endif
return 0;
}
int main(int argc,
char **argv)
{
char *fname, *filename;
const char *str;
char buffer[512];
l_int32 i, npages;
size_t length;
FILE *fp;
NUMA *naflags, *nasizes;
PIX *pix, *pix1, *pix2, *pixd;
PIXA *pixa;
PIXCMAP *cmap;
SARRAY *savals, *satypes, *sa;
static char mainName[] = "mtifftest";
if (argc != 1)
return ERROR_INT(" Syntax: mtifftest", mainName, 1);
lept_mkdir("tiff");
#if 1 /* ------------------ Test multipage I/O -------------------*/
/* This puts every image file in the directory with a string
* match to "weasel" into a multipage tiff file.
* Images with 1 bpp are coded as g4; the others as zip.
* It then reads back into a pix and displays. */
writeMultipageTiff(".", "weasel8.", "/tmp/tiff/weasel8.tif");
pixa = pixaReadMultipageTiff("/tmp/tiff/weasel8.tif");
pixd = pixaDisplayTiledInRows(pixa, 1, 1200, 0.5, 0, 15, 4);
pixDisplay(pixd, 100, 0);
pixDestroy(&pixd);
pixd = pixaDisplayTiledInRows(pixa, 8, 1200, 0.8, 0, 15, 4);
pixDisplay(pixd, 100, 200);
pixDestroy(&pixd);
pixd = pixaDisplayTiledInRows(pixa, 32, 1200, 1.2, 0, 15, 4);
pixDisplay(pixd, 100, 400);
pixDestroy(&pixd);
pixaDestroy(&pixa);
#endif
#if 1 /* ------------ Test single-to-multipage I/O -------------------*/
/* Read the files and generate a multipage tiff file of G4 images.
* Then convert that to a G4 compressed and ascii85 encoded PS file. */
sa = getSortedPathnamesInDirectory(".", "weasel4.", 0, 4);
sarrayWriteStream(stderr, sa);
sarraySort(sa, sa, L_SORT_INCREASING);
sarrayWriteStream(stderr, sa);
npages = sarrayGetCount(sa);
for (i = 0; i < npages; i++) {
fname = sarrayGetString(sa, i, 0);
filename = genPathname(".", fname);
pix1 = pixRead(filename);
if (!pix1) continue;
pix2 = pixConvertTo1(pix1, 128);
if (i == 0)
pixWriteTiff("/tmp/tiff/weasel4", pix2, IFF_TIFF_G4, "w+");
else
pixWriteTiff("/tmp/tiff/weasel4", pix2, IFF_TIFF_G4, "a");
pixDestroy(&pix1);
pixDestroy(&pix2);
lept_free(filename);
}
/* Write it out as a PS file */
convertTiffMultipageToPS("/tmp/tiff/weasel4", "/tmp/tiff/weasel4.ps",
NULL, 0.95);
sarrayDestroy(&sa);
#endif
#if 1 /* ------------------ Test multipage I/O -------------------*/
/* Read count of pages in tiff multipage file */
writeMultipageTiff(".", "weasel2", weasel_orig);
fp = lept_fopen(weasel_orig, "rb");
if (fileFormatIsTiff(fp)) {
tiffGetCount(fp, &npages);
fprintf(stderr, " Tiff: %d page\n", npages);
}
else
return ERROR_INT(" file not tiff", mainName, 1);
lept_fclose(fp);
/* Split into separate page files */
for (i = 0; i < npages + 1; i++) { /* read one beyond to catch error */
if (i == npages)
L_INFO("Errors in next 2 lines are intentional!\n", mainName);
pix = pixReadTiff(weasel_orig, i);
if (!pix) continue;
sprintf(buffer, "/tmp/tiff/%03d.tif", i);
pixWrite(buffer, pix, IFF_TIFF_ZIP);
pixDestroy(&pix);
}
/* Read separate page files and write reversed file */
for (i = npages - 1; i >= 0; i--) {
sprintf(buffer, "/tmp/tiff/%03d.tif", i);
pix = pixRead(buffer);
if (!pix) continue;
if (i == npages - 1)
pixWriteTiff(weasel_rev, pix, IFF_TIFF_ZIP, "w+");
else
pixWriteTiff(weasel_rev, pix, IFF_TIFF_ZIP, "a");
pixDestroy(&pix);
}
/* Read reversed file and reverse again */
pixa = pixaCreate(npages);
for (i = 0; i < npages; i++) {
pix = pixReadTiff(weasel_rev, i);
pixaAddPix(pixa, pix, L_INSERT);
}
for (i = npages - 1; i >= 0; i--) {
pix = pixaGetPix(pixa, i, L_CLONE);
if (i == npages - 1)
pixWriteTiff(weasel_rev_rev, pix, IFF_TIFF_ZIP, "w+");
else
pixWriteTiff(weasel_rev_rev, pix, IFF_TIFF_ZIP, "a");
pixDestroy(&pix);
}
pixaDestroy(&pixa);
#endif
#if 0 /* ----- test adding custom public tags to a tiff header ----- */
pix = pixRead("feyn.tif");
naflags = numaCreate(10);
savals = sarrayCreate(10);
satypes = sarrayCreate(10);
nasizes = numaCreate(10);
/* numaAddNumber(naflags, TIFFTAG_XMLPACKET); */ /* XMP: 700 */
numaAddNumber(naflags, 700);
str = "<xmp>This is a Fake XMP packet</xmp>\n<text>Guess what ...?</text>";
length = strlen(str);
sarrayAddString(savals, (char *)str, L_COPY);
sarrayAddString(satypes, (char *)"char*", L_COPY);
numaAddNumber(nasizes, length); /* get it all */
numaAddNumber(naflags, 269); /* DOCUMENTNAME */
sarrayAddString(savals, (char *)"One silly title", L_COPY);
sarrayAddString(satypes, (char *)"const char*", L_COPY);
numaAddNumber(naflags, 270); /* IMAGEDESCRIPTION */
sarrayAddString(savals, (char *)"One page of text", L_COPY);
sarrayAddString(satypes, (char *)"const char*", L_COPY);
/* the max sample is used by rendering programs
* to scale the dynamic range */
numaAddNumber(naflags, 281); /* MAXSAMPLEVALUE */
sarrayAddString(savals, (char *)"4", L_COPY);
sarrayAddString(satypes, (char *)"l_uint16", L_COPY);
/* note that date is required to be a 20 byte string */
numaAddNumber(naflags, 306); /* DATETIME */
sarrayAddString(savals, (char *)"2004:10:11 09:35:15", L_COPY);
sarrayAddString(satypes, (char *)"const char*", L_COPY);
/* note that page number requires 2 l_uint16 input */
numaAddNumber(naflags, 297); /* PAGENUMBER */
sarrayAddString(savals, (char *)"1-412", L_COPY);
sarrayAddString(satypes, (char *)"l_uint16-l_uint16", L_COPY);
pixWriteTiffCustom("/tmp/tiff/tags.tif", pix, IFF_TIFF_G4, "w", naflags,
savals, satypes, nasizes);
fprintTiffInfo(stderr, (char *)"/tmp/tiff/tags.tif");
fprintf(stderr, "num flags = %d\n", numaGetCount(naflags));
fprintf(stderr, "num sizes = %d\n", numaGetCount(nasizes));
fprintf(stderr, "num vals = %d\n", sarrayGetCount(savals));
fprintf(stderr, "num types = %d\n", sarrayGetCount(satypes));
numaDestroy(&naflags);
numaDestroy(&nasizes);
sarrayDestroy(&savals);
sarrayDestroy(&satypes);
pixDestroy(&pix);
#endif
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;
}
int main(int argc,
char **argv)
{
char filename[BUF_SIZE];
char *dirin, *rootname, *fname;
l_int32 i, firstpage, npages, nfiles;
l_float32 thresh, weight;
JBDATA *data;
JBCLASSER *classer;
SARRAY *safiles;
PIX *pix, *pixt;
PIXA *pixa, *pixadb;
static char mainName[] = "jbcorrelation";
if (argc != 5 && argc != 7)
return ERROR_INT(" Syntax: jbcorrelation dirin thresh weight "
"rootname [firstpage, npages]", mainName, 1);
dirin = argv[1];
thresh = atof(argv[2]);
weight = atof(argv[3]);
rootname = argv[4];
if (argc == 5) {
firstpage = 0;
npages = 0;
}
else {
firstpage = atoi(argv[5]);
npages = atoi(argv[6]);
}
#if 0
/*--------------------------------------------------------------*/
jbCorrelation(dirin, thresh, weight, COMPONENTS, rootname,
firstpage, npages, 1);
/*--------------------------------------------------------------*/
#else
/*--------------------------------------------------------------*/
safiles = getSortedPathnamesInDirectory(dirin, NULL, firstpage, npages);
nfiles = sarrayGetCount(safiles);
sarrayWriteStream(stderr, safiles);
/* Classify components on requested pages */
startTimer();
classer = jbCorrelationInit(COMPONENTS, 0, 0, thresh, weight);
jbAddPages(classer, safiles);
fprintf(stderr, "Time to generate classes: %6.3f sec\n", stopTimer());
/* Save and write out the result */
data = jbDataSave(classer);
jbDataWrite(rootname, data);
fprintf(stderr, "Number of classes: %d\n", classer->nclass);
/* Render the pages from the classifier data.
* Use debugflag == FALSE to omit outlines of each component. */
pixa = jbDataRender(data, FALSE);
/* Write the pages out */
npages = pixaGetCount(pixa);
if (npages != nfiles)
fprintf(stderr, "npages = %d, nfiles = %d, not equal!\n",
npages, nfiles);
for (i = 0; i < npages; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
snprintf(filename, BUF_SIZE, "%s.%05d", rootname, i);
fprintf(stderr, "filename: %s\n", filename);
pixWrite(filename, pix, IFF_PNG);
pixDestroy(&pix);
}
#if DISPLAY_DIFFERENCE
fname = sarrayGetString(safiles, 0, 0);
pixt = pixRead(fname);
pix = pixaGetPix(pixa, 0, L_CLONE);
pixXor(pixt, pixt, pix);
pixWrite("junk_output_diff", pixt, IFF_PNG);
pixDestroy(&pix);
pixDestroy(&pixt);
#endif /* DISPLAY_DIFFERENCE */
#if DEBUG_TEST_DATA_IO
{ JBDATA *newdata;
PIX *newpix;
PIXA *newpixa;
l_int32 same, iofail;
/* Read the data back in and render the pages */
newdata = jbDataRead(rootname);
newpixa = jbDataRender(newdata, FALSE);
iofail = FALSE;
for (i = 0; i < npages; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
newpix = pixaGetPix(newpixa, i, L_CLONE);
pixEqual(pix, newpix, &same);
if (!same) {
iofail = TRUE;
fprintf(stderr, "pix on page %d are unequal!\n", i);
}
pixDestroy(&pix);
pixDestroy(&newpix);
}
if (iofail)
fprintf(stderr, "read/write for jbdata fails\n");
else
fprintf(stderr, "read/write for jbdata succeeds\n");
jbDataDestroy(&newdata);
pixaDestroy(&newpixa);
}
#endif /* DEBUG_TEST_DATA_IO */
#if RENDER_DEBUG
/* Use debugflag == TRUE to see outlines of each component. */
pixadb = jbDataRender(data, TRUE);
/* Write the debug pages out */
npages = pixaGetCount(pixadb);
for (i = 0; i < npages; i++) {
pix = pixaGetPix(pixadb, i, L_CLONE);
snprintf(filename, BUF_SIZE, "%s.db.%05d", rootname, i);
fprintf(stderr, "filename: %s\n", filename);
pixWrite(filename, pix, IFF_PNG);
pixDestroy(&pix);
}
pixaDestroy(&pixadb);
#endif /* RENDER_DEBUG */
#if DISPLAY_ALL_INSTANCES
/* display all instances, organized by template */
pix = pixaaDisplayByPixa(classer->pixaa,
X_SPACING, Y_SPACING, MAX_OUTPUT_WIDTH);
pixWrite("output_instances", pix, IFF_PNG);
pixDestroy(&pix);
#endif /* DISPLAY_ALL_INSTANCES */
pixaDestroy(&pixa);
sarrayDestroy(&safiles);
jbClasserDestroy(&classer);
jbDataDestroy(&data);
/*--------------------------------------------------------------*/
#endif
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout, *str, *fname, *filename;
char buffer[512];
l_int32 i, count, npages, length;
FILE *fp;
NUMA *naflags, *nasizes;
PIX *pix, *pixd;
PIXA *pixa;
PIXCMAP *cmap;
SARRAY *savals, *satypes, *sa;
static char mainName[] = "mtifftest";
if (argc != 3)
exit(ERROR_INT(" Syntax: mtifftest filein fileout", mainName, 1));
filein = argv[1];
fileout = argv[2];
#if 1 /* ------------------ Test multipage I/O -------------------*/
/* This puts every image file in the directory with a string
* match to "weasel" into a multipage tiff file.
* Images with 1 bpp are coded as g4; the others as zip.
* It then reads back into a pix and displays. */
writeMultipageTiff(".", "weasel", "/tmp/junkout.tif");
pixa = pixaReadMultipageTiff("/tmp/junkout.tif");
pixd = pixaDisplayTiledInRows(pixa, 1, 1200, 0.5, 0, 15, 4);
pixDisplay(pixd, 100, 0);
pixDestroy(&pixd);
pixd = pixaDisplayTiledInRows(pixa, 8, 1200, 0.8, 0, 15, 4);
pixDisplay(pixd, 100, 200);
pixDestroy(&pixd);
pixd = pixaDisplayTiledInRows(pixa, 32, 1200, 1.2, 0, 15, 4);
pixDisplay(pixd, 100, 400);
pixDestroy(&pixd);
pixaDestroy(&pixa);
#endif
#if 0 /* ------------ Test single-to-multipage I/O -------------------*/
/* Use 'filein' to specify a directory of tiff files.
* Read them in and generate a multipage tiff file.
* Then convert that to a G4 compressed and ascii85 encoded
* PS file. */
sa = getFilenamesInDirectory(filein);
sarrayWriteStream(stderr, sa);
sarraySort(sa, sa, L_SORT_INCREASING);
sarrayWriteStream(stderr, sa);
npages = sarrayGetCount(sa);
for (i = 0; i < npages; i++) {
fname = sarrayGetString(sa, i, 0);
filename = genPathname(filein, fname);
pix = pixRead(filename);
if (!pix) continue;
if (i == 0)
pixWriteTiff(tempmtiff, pix, IFF_TIFF_G4, "w+");
else
pixWriteTiff(tempmtiff, pix, IFF_TIFF_G4, "a");
pixDestroy(&pix);
lept_free(filename);
}
/* write it out as a PS file */
convertTiffMultipageToPS(tempmtiff, fileout, NULL, 0.95);
sarrayDestroy(&sa);
#endif
#if 0 /* ------------------ Test multipage I/O -------------------*/
/* read count of tiff multipage */
fp = lept_fopen(filein, "rb");
if (fileFormatIsTiff(fp)) {
tiffGetCount(fp, &npages);
fprintf(stderr, " Tiff: %d page\n", npages);
}
else
exit(ERROR_INT(" file not tiff", mainName, 1));
lept_fclose(fp);
/* split into separate page files */
for (i = 0; i < npages + 1; i++) { /* read one beyond to catch error */
pix = pixReadTiff(filein, i);
if (!pix) continue;
sprintf(buffer, "/tmp/junkout.%d.tif", i);
pixWrite(buffer, pix, IFF_TIFF_G4);
pixDestroy(&pix);
}
/* read separate page files and write reversed file */
for (i = npages - 1; i >= 0; i--) {
sprintf(buffer, "/tmp/junkout.%d.tif", i);
pix = pixRead(buffer);
if (!pix) continue;
if (i == npages - 1)
pixWriteTiff(tempmtiff, pix, IFF_TIFF_G4, "w+");
else
pixWriteTiff(tempmtiff, pix, IFF_TIFF_G4, "a");
pixDestroy(&pix);
}
/* read reversed file and reverse again */
pixa = pixaCreate(npages);
for (i = 0; i < 5; i++) {
pix = pixReadTiff(tempmtiff, i);
pixaAddPix(pixa, pix, L_INSERT);
}
for (i = npages - 1; i >= 0; i--) {
pix = pixaGetPix(pixa, i, L_CLONE);
if (i == npages - 1)
pixWriteTiff(tempnewmtiff, pix, IFF_TIFF_G4, "w+");
else
pixWriteTiff(tempnewmtiff, pix, IFF_TIFF_G4, "a");
pixDestroy(&pix);
}
pixaDestroy(&pixa);
#endif
#if 0 /* ----- test adding custom public tags to a tiff header ----- */
pix = pixRead(filein);
naflags = numaCreate(10);
savals = sarrayCreate(10);
satypes = sarrayCreate(10);
nasizes = numaCreate(10);
/* numaAddNumber(naflags, TIFFTAG_XMLPACKET); */ /* XMP: 700 */
numaAddNumber(naflags, 700);
str = "<xmp>This is a Fake XMP packet</xmp>\n<text>Guess what ...?</text>";
length = strlen(str);
sarrayAddString(savals, str, 1);
sarrayAddString(satypes, "char*", 1);
numaAddNumber(nasizes, length); /* get it all */
numaAddNumber(naflags, 269); /* DOCUMENTNAME */
sarrayAddString(savals, "One silly title", 1);
sarrayAddString(satypes, "char*", 1);
numaAddNumber(naflags, 270); /* IMAGEDESCRIPTION */
sarrayAddString(savals, "One page of text", 1);
sarrayAddString(satypes, "char*", 1);
/* the max sample is used by rendering programs
* to scale the dynamic range */
numaAddNumber(naflags, 281); /* MAXSAMPLEVALUE */
sarrayAddString(savals, "4", 1);
sarrayAddString(satypes, "l_uint16", 1);
/* note that date is required to be a 20 byte string */
numaAddNumber(naflags, 306); /* DATETIME */
sarrayAddString(savals, "2004:10:11 09:35:15", 1);
sarrayAddString(satypes, "char*", 1);
/* note that page number requires 2 l_uint16 input */
numaAddNumber(naflags, 297); /* PAGENUMBER */
sarrayAddString(savals, "1-412", 1);
sarrayAddString(satypes, "l_uint16-l_uint16", 1);
pixWriteTiffCustom(fileout, pix, IFF_TIFF_G4, "w", naflags,
savals, satypes, nasizes);
fprintTiffInfo(stderr, fileout);
numaDestroy(&naflags);
numaDestroy(&nasizes);
sarrayDestroy(&savals);
sarrayDestroy(&satypes);
pixDestroy(&pix);
#endif
exit(0);
}
