/*
* captureProtoSignature()
*
* Input: sa (output from cpp, by line)
* start (starting index to search; never a comment line)
* stop (index of line on which pattern is completed)
* charindex (char index of completing ')' character)
* Return: cleanstr (prototype string), or NULL on error
*
* Notes:
* (1) Return all characters, ending with a ';' after the ')'
*/
static char *
captureProtoSignature(SARRAY *sa,
l_int32 start,
l_int32 stop,
l_int32 charindex)
{
char *str, *newstr, *protostr, *cleanstr;
SARRAY *sap;
l_int32 i;
PROCNAME("captureProtoSignature");
if (!sa)
return (char *)ERROR_PTR("sa not defined", procName, NULL);
sap = sarrayCreate(0);
for (i = start; i < stop; i++) {
str = sarrayGetString(sa, i, L_COPY);
sarrayAddString(sap, str, L_INSERT);
}
str = sarrayGetString(sa, stop, L_COPY);
str[charindex + 1] = '\0';
newstr = stringJoin(str, ";");
sarrayAddString(sap, newstr, L_INSERT);
LEPT_FREE(str);
protostr = sarrayToString(sap, 2);
sarrayDestroy(&sap);
cleanstr = cleanProtoSignature(protostr);
LEPT_FREE(protostr);
return cleanstr;
}
/*
* parseForProtos()
*
* Input: filein (output of cpp)
* prestring (<optional> string that prefaces each decl;
* use NULL to omit)
* Return: parsestr (string of function prototypes), or NULL on error
*
* Notes:
* (1) We parse the output of cpp:
* cpp -ansi <filein>
* Three plans were attempted, with success on the third.
* (2) Plan 1. A cursory examination of the cpp output indicated that
* every function was preceeded by a cpp comment statement.
* So we just need to look at statements beginning after comments.
* Unfortunately, this is NOT the case. Some functions start
* without cpp comment lines, typically when there are no
* comments in the source that immediately precede the function.
* (3) Plan 2. Consider the keywords in the language that start
* parts of the cpp file. Some, like 'typedef', 'enum',
* 'union' and 'struct', are followed after a while by '{',
* and eventually end with '}, plus an optional token and a
* final ';' Others, like 'extern' and 'static', are never
* the beginnings of global function definitions. Function
* prototypes have one or more sets of '(' followed eventually
* by a ')', and end with ';'. But function definitions have
* tokens, followed by '(', more tokens, ')' and then
* immediately a '{'. We would generate a prototype from this
* by adding a ';' to all tokens up to the ')'. So we use
* these special tokens to decide what we are parsing. And
* whenever a function definition is found and the prototype
* extracted, we skip through the rest of the function
* past the corresponding '}'. This token ends a line, and
* is often on a line of its own. But as it turns out,
* the only keyword we need to consider is 'static'.
* (4) Plan 3. Consider the parentheses and braces for various
* declarations. A struct, enum, or union has a pair of
* braces followed by a semicolon. They cannot have parentheses
* before the left brace, but a struct can have lots of parentheses
* within the brace set. A function prototype has no braces.
* A function declaration can have sets of left and right
* parentheses, but these are followed by a left brace.
* So plan 3 looks at the way parentheses and braces are
* organized. Once the beginning of a function definition
* is found, the prototype is extracted and we search for
* the ending right brace.
* (5) To find the ending right brace, it is necessary to do some
* careful parsing. For example, in this file, we have
* left and right braces as characters, and these must not
* be counted. Somewhat more tricky, the file fhmtauto.c
* generates code, and includes a right brace in a string.
* So we must not include braces that are in strings. But how
* do we know if something is inside a string? Keep state,
* starting with not-inside, and every time you hit a double quote
* that is not escaped, toggle the condition. Any brace
* found in the state of being within a string is ignored.
* (6) When a prototype is extracted, it is put in a canonical
* form (i.e., cleaned up). Finally, we check that it is
* not static and save it. (If static, it is ignored).
* (7) The @prestring for unix is NULL; it is included here so that
* you can use Microsoft's declaration for importing or
* exporting to a dll. See environ.h for examples of use.
* Here, we set: @prestring = "LEPT_DLL ". Note in particular
* the space character that will separate 'LEPT_DLL' from
* the standard unix prototype that follows.
*/
char *
parseForProtos(const char *filein,
const char *prestring)
{
char *strdata, *str, *newstr, *parsestr, *secondword;
l_int32 nbytes, start, next, stop, charindex, found;
SARRAY *sa, *saout, *satest;
PROCNAME("parseForProtos");
if (!filein)
return (char *)ERROR_PTR("filein not defined", procName, NULL);
/* Read in the cpp output into memory, one string for each
* line in the file, omitting blank lines. */
strdata = (char *)arrayRead(filein, &nbytes);
sa = sarrayCreateLinesFromString(strdata, 0);
saout = sarrayCreate(0);
next = 0;
while (1) { /* repeat after each non-static prototype is extracted */
searchForProtoSignature(sa, next, &start, &stop, &charindex, &found);
if (!found)
break;
/* fprintf(stderr, " start = %d, stop = %d, charindex = %d\n",
start, stop, charindex); */
str = captureProtoSignature(sa, start, stop, charindex);
/* Make sure it is not static. Note that 'extern' has
* been prepended to the prototype, so the 'static'
* keyword, if it exists, would be the second word. */
satest = sarrayCreateWordsFromString(str);
secondword = sarrayGetString(satest, 1, 0);
if (strcmp(secondword, "static")) { /* not static */
if (prestring) { /* prepend it to the prototype */
newstr = stringJoin(prestring, str);
sarrayAddString(saout, newstr, L_INSERT);
FREE(str);
}
else
sarrayAddString(saout, str, L_INSERT);
}
else
FREE(str);
sarrayDestroy(&satest);
skipToEndOfFunction(sa, stop, charindex, &next);
if (next == -1) break;
}
/* Flatten into a string with newlines between prototypes */
parsestr = sarrayToString(saout, 1);
FREE(strdata);
sarrayDestroy(&sa);
sarrayDestroy(&saout);
return parsestr;
}
/*
* cleanProtoSignature()
*
* Input: instr (input prototype string)
* Return: cleanstr (clean prototype string), or NULL on error
*
* Notes:
* (1) Adds 'extern' at beginning and regularizes spaces
* between tokens.
*/
static char *
cleanProtoSignature(char *instr)
{
char *str, *cleanstr;
char buf[L_BUF_SIZE];
char externstring[] = "extern";
l_int32 i, j, nwords, nchars, index, len;
SARRAY *sa, *saout;
PROCNAME("cleanProtoSignature");
if (!instr)
return (char *)ERROR_PTR("instr not defined", procName, NULL);
sa = sarrayCreateWordsFromString(instr);
nwords = sarrayGetCount(sa);
saout = sarrayCreate(0);
sarrayAddString(saout, externstring, 1);
for (i = 0; i < nwords; i++) {
str = sarrayGetString(sa, i, 0);
nchars = strlen(str);
index = 0;
for (j = 0; j < nchars; j++) {
if (index > L_BUF_SIZE - 6)
return (char *)ERROR_PTR("token too large", procName, NULL);
if (str[j] == '(') {
buf[index++] = ' ';
buf[index++] = '(';
buf[index++] = ' ';
}
else if (str[j] == ')') {
buf[index++] = ' ';
buf[index++] = ')';
}
else
buf[index++] = str[j];
}
buf[index] = '\0';
sarrayAddString(saout, buf, 1);
}
/* Flatten to a prototype string with spaces added after
* each word, and remove the last space */
cleanstr = sarrayToString(saout, 2);
len = strlen(cleanstr);
cleanstr[len - 1] = '\0';
sarrayDestroy(&sa);
sarrayDestroy(&saout);
return cleanstr;
}
/*!
* \brief l_genDataString()
*
* \param[in] filein input file of serialized data
* \param[in] ifunc index into set of functions in output file
* \return encoded ascii data string, or NULL on error reading from file
*/
static char *
l_genDataString(const char *filein,
l_int32 ifunc)
{
char buf[80];
char *cdata1, *cdata2, *cdata3;
l_uint8 *data1, *data2;
l_int32 csize1, csize2;
size_t size1, size2;
SARRAY *sa;
PROCNAME("l_genDataString");
if (!filein)
return (char *)ERROR_PTR("filein not defined", procName, NULL);
/* Read it in, gzip it, encode, and reformat. We gzip because some
* serialized data has a significant amount of ascii content. */
if ((data1 = l_binaryRead(filein, &size1)) == NULL)
return (char *)ERROR_PTR("bindata not returned", procName, NULL);
data2 = zlibCompress(data1, size1, &size2);
cdata1 = encodeBase64(data2, size2, &csize1);
cdata2 = reformatPacked64(cdata1, csize1, 4, 72, 1, &csize2);
LEPT_FREE(data1);
LEPT_FREE(data2);
LEPT_FREE(cdata1);
/* Prepend the string declaration signature and put it together */
sa = sarrayCreate(3);
snprintf(buf, sizeof(buf), "static const char *l_strdata_%d =\n", ifunc);
sarrayAddString(sa, buf, L_COPY);
sarrayAddString(sa, cdata2, L_INSERT);
sarrayAddString(sa, (char *)";\n", L_COPY);
cdata3 = sarrayToString(sa, 0);
sarrayDestroy(&sa);
return cdata3;
}
/*!
* gplotGenCommandFile()
*
* Input: gplot
* Return: 0 if OK, 1 on error
*/
l_int32
gplotGenCommandFile(GPLOT *gplot)
{
char buf[L_BUF_SIZE];
char *cmdstr, *plottitle, *dataname;
l_int32 i, plotstyle, nplots;
FILE *fp;
PROCNAME("gplotGenCommandFile");
if (!gplot)
return ERROR_INT("gplot not defined", procName, 1);
/* Remove any previous command data */
sarrayClear(gplot->cmddata);
/* Generate command data instructions */
if (gplot->title) { /* set title */
snprintf(buf, L_BUF_SIZE, "set title '%s'", gplot->title);
sarrayAddString(gplot->cmddata, buf, L_COPY);
}
if (gplot->xlabel) { /* set xlabel */
snprintf(buf, L_BUF_SIZE, "set xlabel '%s'", gplot->xlabel);
sarrayAddString(gplot->cmddata, buf, L_COPY);
}
if (gplot->ylabel) { /* set ylabel */
snprintf(buf, L_BUF_SIZE, "set ylabel '%s'", gplot->ylabel);
sarrayAddString(gplot->cmddata, buf, L_COPY);
}
if (gplot->outformat == GPLOT_PNG) /* set terminal type and output */
snprintf(buf, L_BUF_SIZE, "set terminal png; set output '%s'",
gplot->outname);
else if (gplot->outformat == GPLOT_PS)
snprintf(buf, L_BUF_SIZE, "set terminal postscript; set output '%s'",
gplot->outname);
else if (gplot->outformat == GPLOT_EPS)
snprintf(buf, L_BUF_SIZE,
"set terminal postscript eps; set output '%s'",
gplot->outname);
else if (gplot->outformat == GPLOT_LATEX)
snprintf(buf, L_BUF_SIZE, "set terminal latex; set output '%s'",
gplot->outname);
else /* gplot->outformat == GPLOT_X11 */
#ifndef _WIN32
snprintf(buf, L_BUF_SIZE, "set terminal x11");
#else
snprintf(buf, L_BUF_SIZE, "set terminal windows");
#endif /* _WIN32 */
sarrayAddString(gplot->cmddata, buf, L_COPY);
if (gplot->scaling == GPLOT_LOG_SCALE_X ||
gplot->scaling == GPLOT_LOG_SCALE_X_Y) {
snprintf(buf, L_BUF_SIZE, "set logscale x");
sarrayAddString(gplot->cmddata, buf, L_COPY);
}
if (gplot->scaling == GPLOT_LOG_SCALE_Y ||
gplot->scaling == GPLOT_LOG_SCALE_X_Y) {
snprintf(buf, L_BUF_SIZE, "set logscale y");
sarrayAddString(gplot->cmddata, buf, L_COPY);
}
nplots = sarrayGetCount(gplot->datanames);
for (i = 0; i < nplots; i++) {
plottitle = sarrayGetString(gplot->plottitles, i, L_NOCOPY);
dataname = sarrayGetString(gplot->datanames, i, L_NOCOPY);
numaGetIValue(gplot->plotstyles, i, &plotstyle);
if (nplots == 1) {
snprintf(buf, L_BUF_SIZE, "plot '%s' title '%s' %s",
dataname, plottitle, gplotstylenames[plotstyle]);
} else {
if (i == 0)
snprintf(buf, L_BUF_SIZE, "plot '%s' title '%s' %s, \\",
dataname, plottitle, gplotstylenames[plotstyle]);
else if (i < nplots - 1)
snprintf(buf, L_BUF_SIZE, " '%s' title '%s' %s, \\",
dataname, plottitle, gplotstylenames[plotstyle]);
else
snprintf(buf, L_BUF_SIZE, " '%s' title '%s' %s",
dataname, plottitle, gplotstylenames[plotstyle]);
}
sarrayAddString(gplot->cmddata, buf, L_COPY);
}
/* Write command data to file */
cmdstr = sarrayToString(gplot->cmddata, 1);
if ((fp = fopenWriteStream(gplot->cmdname, "w")) == NULL)
return ERROR_INT("cmd stream not opened", procName, 1);
fwrite(cmdstr, 1, strlen(cmdstr), fp);
fclose(fp);
FREE(cmdstr);
return 0;
}
/*!
* gplotAddPlot()
*
* Input: gplot
* nax (<optional> numa: set to null for Y_VS_I;
* required for Y_VS_X)
* nay (numa: required for both Y_VS_I and Y_VS_X)
* plotstyle (GPLOT_LINES, GPLOT_POINTS, GPLOT_IMPULSES,
* GPLOT_LINESPOINTS, GPLOT_DOTS)
* plottitle (<optional> title for individual plot)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) There are 2 options for (x,y) values:
* o To plot an array vs a linear function of the
* index, set nax = NULL.
* o To plot one array vs another, use both nax and nay.
* (2) If nax is NULL, the x value corresponding to the i-th
* value of nay is found from the startx and delx fields
* in nay:
* x = startx + i * delx
* These are set with numaSetParameters(). Their default
* values are startx = 0.0, delx = 1.0.
* (3) If nax is defined, it must be the same size as nay.
* (4) The 'plottitle' string can have spaces, double
* quotes and backquotes, but not single quotes.
*/
l_int32
gplotAddPlot(GPLOT *gplot,
NUMA *nax,
NUMA *nay,
l_int32 plotstyle,
const char *plottitle)
{
char buf[L_BUF_SIZE];
char emptystring[] = "";
char *datastr, *title;
l_int32 n, i;
l_float32 valx, valy, startx, delx;
SARRAY *sa;
PROCNAME("gplotAddPlot");
if (!gplot)
return ERROR_INT("gplot not defined", procName, 1);
if (!nay)
return ERROR_INT("nay not defined", procName, 1);
if (plotstyle != GPLOT_LINES && plotstyle != GPLOT_POINTS &&
plotstyle != GPLOT_IMPULSES && plotstyle != GPLOT_LINESPOINTS &&
plotstyle != GPLOT_DOTS)
return ERROR_INT("invalid plotstyle", procName, 1);
n = numaGetCount(nay);
numaGetParameters(nay, &startx, &delx);
if (nax) {
if (n != numaGetCount(nax))
return ERROR_INT("nax and nay sizes differ", procName, 1);
}
/* Save plotstyle and plottitle */
numaAddNumber(gplot->plotstyles, plotstyle);
if (plottitle) {
title = stringNew(plottitle);
sarrayAddString(gplot->plottitles, title, L_INSERT);
} else {
sarrayAddString(gplot->plottitles, emptystring, L_COPY);
}
/* Generate and save data filename */
gplot->nplots++;
snprintf(buf, L_BUF_SIZE, "%s.data.%d", gplot->rootname, gplot->nplots);
sarrayAddString(gplot->datanames, buf, L_COPY);
/* Generate data and save as a string */
sa = sarrayCreate(n);
for (i = 0; i < n; i++) {
if (nax)
numaGetFValue(nax, i, &valx);
else
valx = startx + i * delx;
numaGetFValue(nay, i, &valy);
snprintf(buf, L_BUF_SIZE, "%f %f\n", valx, valy);
sarrayAddString(sa, buf, L_COPY);
}
datastr = sarrayToString(sa, 0);
sarrayAddString(gplot->plotdata, datastr, L_INSERT);
sarrayDestroy(&sa);
return 0;
}
main(int argc,
char **argv)
{
char *errorstr;
l_int32 same, error;
PIX *pixs1, *pixs2, *pixs4, *pixs8, *pixs16, *pixs32, *pixd;
PIX *pixc2, *pixc4, *pixc8;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXCMAP *cmap;
SARRAY *sa;
static char mainName[] = "convert_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: convert_rt", mainName, 1));
if ((pixs1 = pixRead("test1.png")) == NULL)
exit(ERROR_INT("pixs1 not made", mainName, 1));
if ((pixs2 = pixRead("dreyfus2.png")) == NULL)
exit(ERROR_INT("pixs2 not made", mainName, 1));
if ((pixc2 = pixRead("weasel2.4c.png")) == NULL)
exit(ERROR_INT("pixc2 not made", mainName, 1));
if ((pixs4 = pixRead("weasel4.16g.png")) == NULL)
exit(ERROR_INT("pixs4 not made", mainName, 1));
if ((pixc4 = pixRead("weasel4.11c.png")) == NULL)
exit(ERROR_INT("pixc4 not made", mainName, 1));
if ((pixs8 = pixRead("karen8.jpg")) == NULL)
exit(ERROR_INT("pixs8 not made", mainName, 1));
if ((pixc8 = pixRead("weasel8.240c.png")) == NULL)
exit(ERROR_INT("pixc8 not made", mainName, 1));
if ((pixs16 = pixRead("test16.tif")) == NULL)
exit(ERROR_INT("pixs16 not made", mainName, 1));
if ((pixs32 = pixRead("marge.jpg")) == NULL)
exit(ERROR_INT("pixs32 not made", mainName, 1));
error = FALSE;
sa = sarrayCreate(0);
/* Conversion: 1 bpp --> 8 bpp --> 1 bpp */
pixt1 = pixConvertTo8(pixs1, FALSE);
pixt2 = pixThreshold8(pixt1, 1, 0, 0);
pixEqual(pixs1, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs1, 100, 100, "1 bpp, no cmap", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "1 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 1 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 1 bpp <==> 8 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 2 bpp --> 8 bpp --> 2 bpp */
/* Conversion: 2 bpp cmap --> 8 bpp cmap --> 2 bpp cmap */
pixt1 = pixRemoveColormap(pixs2, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixThreshold8(pixt1, 2, 4, 0);
pixt3 = pixConvertTo8(pixt2, FALSE);
pixt4 = pixThreshold8(pixt3, 2, 4, 0);
pixEqual(pixt2, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "2 bpp, no cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "2 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 8 bpp\n");
pixt5 = pixConvertTo8(pixs2, TRUE);
pixt6 = pixThreshold8(pixt5, 2, 4, 1);
pixEqual(pixs2, pixt6, &same);
if (!same) {
pixDisplayWithTitle(pixs2, 100, 100, "2 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt6, 500, 100, "2 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 8 bpp; cmap",
L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 8 bpp; cmap\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
/* Conversion: 4 bpp --> 8 bpp --> 4 bpp */
/* Conversion: 4 bpp cmap --> 8 bpp cmap --> 4 bpp cmap */
pixt1 = pixRemoveColormap(pixs4, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixThreshold8(pixt1, 4, 16, 0);
pixt3 = pixConvertTo8(pixt2, FALSE);
pixt4 = pixThreshold8(pixt3, 4, 16, 0);
pixEqual(pixt2, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "4 bpp, no cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 8 bpp\n");
pixt5 = pixConvertTo8(pixs4, TRUE);
pixt6 = pixThreshold8(pixt5, 4, 16, 1);
pixEqual(pixs4, pixt6, &same);
if (!same) {
pixDisplayWithTitle(pixs4, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt6, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 8 bpp, cmap",
L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 8 bpp; cmap\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
/* Conversion: 2 bpp cmap --> 2 bpp --> 2 bpp cmap --> 2 bpp */
pixt1 = pixRemoveColormap(pixs2, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixConvertGrayToColormap(pixt1);
pixt3 = pixRemoveColormap(pixt2, REMOVE_CMAP_TO_GRAYSCALE);
pixt4 = pixThresholdTo2bpp(pixt3, 4, 1);
pixEqual(pixt1, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixs2, 100, 100, "2 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "2 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 2 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 2 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 4 bpp cmap --> 4 bpp --> 4 bpp cmap --> 4 bpp */
pixt1 = pixRemoveColormap(pixs4, REMOVE_CMAP_TO_GRAYSCALE);
pixt2 = pixConvertGrayToColormap(pixt1);
pixt3 = pixRemoveColormap(pixt2, REMOVE_CMAP_TO_GRAYSCALE);
pixt4 = pixThresholdTo4bpp(pixt3, 16, 1);
pixEqual(pixt1, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixs4, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 4 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 4 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 8 bpp --> 8 bpp cmap --> 8 bpp */
pixt1 = pixConvertTo8(pixs8, TRUE);
pixt2 = pixConvertTo8(pixt1, FALSE);
pixEqual(pixs8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixt1, 100, 100, "8 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp, no cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 8 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 2 bpp cmap --> 32 bpp --> 2 bpp cmap */
pixt1 = pixConvertTo8(pixc2, TRUE);
pixt2 = pixConvertTo32(pixt1);
pixt3 = pixConvertTo32(pixc2);
pixEqual(pixt2, pixt3, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "32 bpp", DFLAG);
pixDisplayWithTitle(pixt3, 500, 100, "32 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp ==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 32 bpp\n");
cmap = pixGetColormap(pixc2);
pixt4 = pixOctcubeQuantFromCmap(pixt3, cmap, 2, 4, L_EUCLIDEAN_DISTANCE);
pixEqual(pixc2, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixc2, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 2 bpp <==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 2 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 4 bpp cmap --> 32 bpp --> 4 bpp cmap */
pixt1 = pixConvertTo8(pixc4, TRUE);
pixt2 = pixConvertTo32(pixt1);
pixt3 = pixConvertTo32(pixc4);
pixEqual(pixt2, pixt3, &same);
if (!same) {
pixDisplayWithTitle(pixt2, 100, 100, "32 bpp", DFLAG);
pixDisplayWithTitle(pixt3, 500, 100, "32 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp ==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 32 bpp\n");
cmap = pixGetColormap(pixc4);
pixt4 = pixOctcubeQuantFromCmap(pixt3, cmap, 2, 4, L_EUCLIDEAN_DISTANCE);
pixEqual(pixc4, pixt4, &same);
if (!same) {
pixDisplayWithTitle(pixc4, 100, 100, "4 bpp, cmap", DFLAG);
pixDisplayWithTitle(pixt4, 500, 100, "4 bpp, cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 4 bpp <==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 4 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Conversion: 8 bpp --> 32 bpp --> 8 bpp */
pixt1 = pixConvertTo32(pixs8);
pixt2 = pixConvertTo8(pixt1, FALSE);
pixEqual(pixs8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs8, 100, 100, "8 bpp", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp <==> 32 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 8 bpp --> 16 bpp --> 8 bpp */
pixt1 = pixConvert8To16(pixs8, 8);
pixt2 = pixConvertTo8(pixt1, FALSE);
pixEqual(pixs8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs8, 100, 100, "8 bpp", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp <==> 16 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 16 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 16 bpp --> 8 bpp --> 16 bpp */
pixt1 = pixConvert16To8(pixs16, 1);
pixt2 = pixConvertTo16(pixt1);
pixWrite("/tmp/junkpix.png", pixt2, IFF_PNG);
pixEqual(pixs16, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixs16, 100, 100, "16 bpp", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "16 bpp", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 16 bpp <==> 8 bpp", L_COPY);
} else
fprintf(stderr, "OK: conversion 16 bpp <==> 8 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Conversion: 8 bpp cmap --> 32 bpp --> 8 bpp cmap */
/* Required to go to level 6 of octcube to get identical result */
pixt1 = pixConvertTo32(pixc8);
cmap = pixGetColormap(pixc8);
pixt2 = pixOctcubeQuantFromCmap(pixt1, cmap, 2, 6, L_EUCLIDEAN_DISTANCE);
pixEqual(pixc8, pixt2, &same);
if (!same) {
pixDisplayWithTitle(pixc8, 100, 100, "8 bpp cmap", DFLAG);
pixDisplayWithTitle(pixt2, 500, 100, "8 bpp cmap", DFLAG);
error = TRUE;
sarrayAddString(sa, (char *)"conversion 8 bpp cmap <==> 32 bpp cmap",
L_COPY);
} else
fprintf(stderr, "OK: conversion 8 bpp <==> 32 bpp\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Summarize results */
if (error == FALSE)
fprintf(stderr, "No errors found\n");
else {
errorstr = sarrayToString(sa, 1);
fprintf(stderr, "Errors in the following:\n %s", errorstr);
lept_free(errorstr);
}
sarrayDestroy(&sa);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixs4);
pixDestroy(&pixc2);
pixDestroy(&pixc4);
pixDestroy(&pixs8);
pixDestroy(&pixc8);
pixDestroy(&pixs16);
pixDestroy(&pixs32);
return 0;
}
/*
* parseForProtos()
*
* Input: filein (output of cpp)
* prestring (<optional> string that prefaces each decl;
* use NULL to omit)
* Return: parsestr (string of function prototypes), or NULL on error
*
* Notes:
* (1) We parse the output of cpp:
* cpp -ansi <filein>
* Three plans were attempted, with success on the third.
* (2) Plan 1. A cursory examination of the cpp output indicated that
* every function was preceded by a cpp comment statement.
* So we just need to look at statements beginning after comments.
* Unfortunately, this is NOT the case. Some functions start
* without cpp comment lines, typically when there are no
* comments in the source that immediately precede the function.
* (3) Plan 2. Consider the keywords in the language that start
* parts of the cpp file. Some, like 'typedef', 'enum',
* 'union' and 'struct', are followed after a while by '{',
* and eventually end with '}, plus an optional token and a
* final ';' Others, like 'extern' and 'static', are never
* the beginnings of global function definitions. Function
* prototypes have one or more sets of '(' followed eventually
* by a ')', and end with ';'. But function definitions have
* tokens, followed by '(', more tokens, ')' and then
* immediately a '{'. We would generate a prototype from this
* by adding a ';' to all tokens up to the ')'. So we use
* these special tokens to decide what we are parsing. And
* whenever a function definition is found and the prototype
* extracted, we skip through the rest of the function
* past the corresponding '}'. This token ends a line, and
* is often on a line of its own. But as it turns out,
* the only keyword we need to consider is 'static'.
* (4) Plan 3. Consider the parentheses and braces for various
* declarations. A struct, enum, or union has a pair of
* braces followed by a semicolon. They cannot have parentheses
* before the left brace, but a struct can have lots of parentheses
* within the brace set. A function prototype has no braces.
* A function declaration can have sets of left and right
* parentheses, but these are followed by a left brace.
* So plan 3 looks at the way parentheses and braces are
* organized. Once the beginning of a function definition
* is found, the prototype is extracted and we search for
* the ending right brace.
* (5) To find the ending right brace, it is necessary to do some
* careful parsing. For example, in this file, we have
* left and right braces as characters, and these must not
* be counted. Somewhat more tricky, the file fhmtauto.c
* generates code, and includes a right brace in a string.
* So we must not include braces that are in strings. But how
* do we know if something is inside a string? Keep state,
* starting with not-inside, and every time you hit a double quote
* that is not escaped, toggle the condition. Any brace
* found in the state of being within a string is ignored.
* (6) When a prototype is extracted, it is put in a canonical
* form (i.e., cleaned up). Finally, we check that it is
* not static and save it. (If static, it is ignored).
* (7) The @prestring for unix is NULL; it is included here so that
* you can use Microsoft's declaration for importing or
* exporting to a dll. See environ.h for examples of use.
* Here, we set: @prestring = "LEPT_DLL ". Note in particular
* the space character that will separate 'LEPT_DLL' from
* the standard unix prototype that follows.
*/
char *
parseForProtos(const char *filein,
const char *prestring)
{
char *strdata, *str, *newstr, *parsestr, *secondword;
l_int32 start, next, stop, charindex, found;
size_t nbytes;
SARRAY *sa, *saout, *satest;
PROCNAME("parseForProtos");
if (!filein)
return (char *)ERROR_PTR("filein not defined", procName, NULL);
/* Read in the cpp output into memory, one string for each
* line in the file, omitting blank lines. */
strdata = (char *)l_binaryRead(filein, &nbytes);
sa = sarrayCreateLinesFromString(strdata, 0);
saout = sarrayCreate(0);
next = 0;
while (1) { /* repeat after each non-static prototype is extracted */
searchForProtoSignature(sa, next, &start, &stop, &charindex, &found);
if (!found)
break;
/* fprintf(stderr, " start = %d, stop = %d, charindex = %d\n",
start, stop, charindex); */
str = captureProtoSignature(sa, start, stop, charindex);
/* Make sure that the signature found by cpp is neither
* static nor extern. We get 'extern' declarations from
* header files, and with some versions of cpp running on
* #include <sys/stat.h> we get something of the form:
* extern ... (( ... )) ... ( ... ) { ...
* For this, the 1st '(' is the lp, the 2nd ')' is the rp,
* and there is a lot of garbage between the rp and the lb.
* It is easiest to simply reject any signature that starts
* with 'extern'. Note also that an 'extern' token has been
* prepended to each prototype, so the 'static' or
* 'extern' keywords we are looking for, if they exist,
* would be the second word. */
satest = sarrayCreateWordsFromString(str);
secondword = sarrayGetString(satest, 1, L_NOCOPY);
if (strcmp(secondword, "static") && /* not static */
strcmp(secondword, "extern")) { /* not extern */
if (prestring) { /* prepend it to the prototype */
newstr = stringJoin(prestring, str);
sarrayAddString(saout, newstr, L_INSERT);
LEPT_FREE(str);
} else {
sarrayAddString(saout, str, L_INSERT);
}
} else {
LEPT_FREE(str);
}
sarrayDestroy(&satest);
skipToEndOfFunction(sa, stop, charindex, &next);
if (next == -1) break;
}
/* Flatten into a string with newlines between prototypes */
parsestr = sarrayToString(saout, 1);
LEPT_FREE(strdata);
sarrayDestroy(&sa);
sarrayDestroy(&saout);
return parsestr;
}
/*
* fmorphautogen2()
*
* Input: sela
* fileindex
* filename (<optional>; can be null)
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) This function uses morphtemplate2.txt to create a
* low-level file that contains the low-level functions for
* implementing dilation and erosion for every sel
* in the input sela.
* (2) The fileindex parameter is inserted into the output
* filename, as described below.
* (3) If filename == NULL, the output file is fmorphgenlow.<n>.c,
* where <n> is equal to the 'fileindex' parameter.
* (4) If filename != NULL, the output file is <filename>low.<n>.c.
*/
l_int32
fmorphautogen2(SELA *sela,
l_int32 fileindex,
const char *filename)
{
char *filestr, *linestr, *fname;
char *str_doc1, *str_doc2, *str_doc3, *str_doc4, *str_def1;
char bigbuf[L_BUF_SIZE];
char breakstring[] = " break;";
char staticstring[] = "static void";
l_int32 i, nsels, nbytes, actstart, end, newstart;
l_int32 argstart, argend, loopstart, loopend, finalstart, finalend;
size_t size;
SARRAY *sa1, *sa2, *sa3, *sa4, *sa5, *sa6;
SEL *sel;
PROCNAME("fmorphautogen2");
if (!sela)
return ERROR_INT("sela not defined", procName, 1);
if (fileindex < 0)
fileindex = 0;
if ((nsels = selaGetCount(sela)) == 0)
return ERROR_INT("no sels in sela", procName, 1);
/* Make the array of textlines from morphtemplate2.txt */
if ((filestr = (char *)l_binaryRead(TEMPLATE2, &size)) == NULL)
return ERROR_INT("filestr not made", procName, 1);
sa1 = sarrayCreateLinesFromString(filestr, 1);
LEPT_FREE(filestr);
if (!sa1)
return ERROR_INT("sa1 not made", procName, 1);
/* Make the array of static function names */
if ((sa2 = sarrayCreate(2 * nsels)) == NULL) {
sarrayDestroy(&sa1);
return ERROR_INT("sa2 not made", procName, 1);
}
for (i = 0; i < nsels; i++) {
sprintf(bigbuf, "fdilate_%d_%d", fileindex, i);
sarrayAddString(sa2, bigbuf, L_COPY);
sprintf(bigbuf, "ferode_%d_%d", fileindex, i);
sarrayAddString(sa2, bigbuf, L_COPY);
}
/* Make the static prototype strings */
sa3 = sarrayCreate(2 * nsels); /* should be ok */
for (i = 0; i < 2 * nsels; i++) {
fname = sarrayGetString(sa2, i, L_NOCOPY);
sprintf(bigbuf, "static void %s%s", fname, PROTOARGS);
sarrayAddString(sa3, bigbuf, L_COPY);
}
/* Make strings containing function names */
sprintf(bigbuf, " * l_int32 fmorphopgen_low_%d()",
fileindex);
str_doc1 = stringNew(bigbuf);
sprintf(bigbuf, " * void fdilate_%d_*()", fileindex);
str_doc2 = stringNew(bigbuf);
sprintf(bigbuf, " * void ferode_%d_*()", fileindex);
str_doc3 = stringNew(bigbuf);
sprintf(bigbuf, " * fmorphopgen_low_%d()", fileindex);
str_doc4 = stringNew(bigbuf);
sprintf(bigbuf, "fmorphopgen_low_%d(l_uint32 *datad,", fileindex);
str_def1 = stringNew(bigbuf);
/* Output to this sa */
sa4 = sarrayCreate(0);
/* Copyright notice and info header */
sarrayParseRange(sa1, 0, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
/* Insert function names as documentation */
sarrayAddString(sa4, str_doc1, L_INSERT);
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
sarrayAddString(sa4, str_doc2, L_INSERT);
sarrayAddString(sa4, str_doc3, L_INSERT);
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
/* Insert static protos */
for (i = 0; i < 2 * nsels; i++) {
if ((linestr = sarrayGetString(sa3, i, L_COPY)) == NULL) {
sarrayDestroy(&sa1);
sarrayDestroy(&sa2);
sarrayDestroy(&sa3);
sarrayDestroy(&sa4);
return ERROR_INT("linestr not retrieved", procName, 1);
}
sarrayAddString(sa4, linestr, L_INSERT);
}
/* Insert function header */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
sarrayAddString(sa4, str_doc4, L_INSERT);
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
sarrayAddString(sa4, str_def1, L_INSERT);
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
/* Generate and insert the dispatcher code */
for (i = 0; i < 2 * nsels; i++) {
sprintf(bigbuf, " case %d:", i);
sarrayAddString(sa4, bigbuf, L_COPY);
sprintf(bigbuf, " %s(datad, w, h, wpld, datas, wpls);",
sarrayGetString(sa2, i, L_NOCOPY));
sarrayAddString(sa4, bigbuf, L_COPY);
sarrayAddString(sa4, breakstring, L_COPY);
}
/* Finish the dispatcher and introduce the low-level code */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa4, sa1, actstart, end);
/* Get the range for the args common to all functions */
sarrayParseRange(sa1, newstart, &argstart, &argend, &newstart, "--", 0);
/* Get the range for the loop code common to all functions */
sarrayParseRange(sa1, newstart, &loopstart, &loopend, &newstart, "--", 0);
/* Get the range for the ending code common to all functions */
sarrayParseRange(sa1, newstart, &finalstart, &finalend, &newstart, "--", 0);
/* Do all the static functions */
for (i = 0; i < 2 * nsels; i++) {
/* Generate the function header and add the common args */
sarrayAddString(sa4, staticstring, L_COPY);
fname = sarrayGetString(sa2, i, L_NOCOPY);
sprintf(bigbuf, "%s(l_uint32 *datad,", fname);
sarrayAddString(sa4, bigbuf, L_COPY);
sarrayAppendRange(sa4, sa1, argstart, argend);
/* Declare and define wplsN args, as necessary */
if ((sel = selaGetSel(sela, i/2)) == NULL) {
sarrayDestroy(&sa1);
sarrayDestroy(&sa2);
sarrayDestroy(&sa3);
sarrayDestroy(&sa4);
return ERROR_INT("sel not returned", procName, 1);
}
sa5 = sarrayMakeWplsCode(sel);
sarrayJoin(sa4, sa5);
sarrayDestroy(&sa5);
/* Add the function loop code */
sarrayAppendRange(sa4, sa1, loopstart, loopend);
/* Insert barrel-op code for *dptr */
sa6 = sarrayMakeInnerLoopDWACode(sel, i);
sarrayJoin(sa4, sa6);
sarrayDestroy(&sa6);
/* Finish the function code */
sarrayAppendRange(sa4, sa1, finalstart, finalend);
}
/* Output to file */
filestr = sarrayToString(sa4, 1);
nbytes = strlen(filestr);
if (filename)
snprintf(bigbuf, L_BUF_SIZE, "%slow.%d.c", filename, fileindex);
else
sprintf(bigbuf, "%slow.%d.c", OUTROOT, fileindex);
l_binaryWrite(bigbuf, "w", filestr, nbytes);
sarrayDestroy(&sa1);
sarrayDestroy(&sa2);
sarrayDestroy(&sa3);
sarrayDestroy(&sa4);
LEPT_FREE(filestr);
return 0;
}
/*!
* \brief fmorphautogen1()
*
* \param[in] sela
* \param[in] fileindex
* \param[in] filename [optional]; can be null
* \return 0 if OK; 1 on error
*
* <pre>
* Notes:
* (1) This function uses morphtemplate1.txt to create a
* top-level file that contains two functions. These
* functions will carry out dilation, erosion,
* opening or closing for any of the sels in the input sela.
* (2) The fileindex parameter is inserted into the output
* filename, as described below.
* (3) If filename == NULL, the output file is fmorphgen.<n>.c,
* where <n> is equal to the 'fileindex' parameter.
* (4) If filename != NULL, the output file is <filename>.<n>.c.
* </pre>
*/
l_int32
fmorphautogen1(SELA *sela,
l_int32 fileindex,
const char *filename)
{
char *filestr;
char *str_proto1, *str_proto2, *str_proto3;
char *str_doc1, *str_doc2, *str_doc3, *str_doc4;
char *str_def1, *str_def2, *str_proc1, *str_proc2;
char *str_dwa1, *str_low_dt, *str_low_ds, *str_low_ts;
char *str_low_tsp1, *str_low_dtp1;
char bigbuf[L_BUF_SIZE];
l_int32 i, nsels, nbytes, actstart, end, newstart;
size_t size;
SARRAY *sa1, *sa2, *sa3;
PROCNAME("fmorphautogen1");
if (!sela)
return ERROR_INT("sela not defined", procName, 1);
if (fileindex < 0)
fileindex = 0;
if ((nsels = selaGetCount(sela)) == 0)
return ERROR_INT("no sels in sela", procName, 1);
/* Make array of textlines from morphtemplate1.txt */
if ((filestr = (char *)l_binaryRead(TEMPLATE1, &size)) == NULL)
return ERROR_INT("filestr not made", procName, 1);
sa2 = sarrayCreateLinesFromString(filestr, 1);
LEPT_FREE(filestr);
if (!sa2)
return ERROR_INT("sa2 not made", procName, 1);
/* Make array of sel names */
sa1 = selaGetSelnames(sela);
/* Make strings containing function call names */
sprintf(bigbuf, "PIX *pixMorphDwa_%d(PIX *pixd, PIX *pixs, "
"l_int32 operation, char *selname);", fileindex);
str_proto1 = stringNew(bigbuf);
sprintf(bigbuf, "PIX *pixFMorphopGen_%d(PIX *pixd, PIX *pixs, "
"l_int32 operation, char *selname);", fileindex);
str_proto2 = stringNew(bigbuf);
sprintf(bigbuf, "l_int32 fmorphopgen_low_%d(l_uint32 *datad, l_int32 w,\n"
" l_int32 h, l_int32 wpld,\n"
" l_uint32 *datas, l_int32 wpls,\n"
" l_int32 index);", fileindex);
str_proto3 = stringNew(bigbuf);
sprintf(bigbuf, " * PIX *pixMorphDwa_%d()", fileindex);
str_doc1 = stringNew(bigbuf);
sprintf(bigbuf, " * PIX *pixFMorphopGen_%d()", fileindex);
str_doc2 = stringNew(bigbuf);
sprintf(bigbuf, " * pixMorphDwa_%d()", fileindex);
str_doc3 = stringNew(bigbuf);
sprintf(bigbuf, " * pixFMorphopGen_%d()", fileindex);
str_doc4 = stringNew(bigbuf);
sprintf(bigbuf, "pixMorphDwa_%d(PIX *pixd,", fileindex);
str_def1 = stringNew(bigbuf);
sprintf(bigbuf, "pixFMorphopGen_%d(PIX *pixd,", fileindex);
str_def2 = stringNew(bigbuf);
sprintf(bigbuf, " PROCNAME(\"pixMorphDwa_%d\");", fileindex);
str_proc1 = stringNew(bigbuf);
sprintf(bigbuf, " PROCNAME(\"pixFMorphopGen_%d\");", fileindex);
str_proc2 = stringNew(bigbuf);
sprintf(bigbuf,
" pixt2 = pixFMorphopGen_%d(NULL, pixt1, operation, selname);",
fileindex);
str_dwa1 = stringNew(bigbuf);
sprintf(bigbuf,
" fmorphopgen_low_%d(datad, w, h, wpld, datat, wpls, index);",
fileindex);
str_low_dt = stringNew(bigbuf);
sprintf(bigbuf,
" fmorphopgen_low_%d(datad, w, h, wpld, datas, wpls, index);",
fileindex);
str_low_ds = stringNew(bigbuf);
sprintf(bigbuf,
" fmorphopgen_low_%d(datat, w, h, wpls, datas, wpls, index+1);",
fileindex);
str_low_tsp1 = stringNew(bigbuf);
sprintf(bigbuf,
" fmorphopgen_low_%d(datat, w, h, wpls, datas, wpls, index);",
fileindex);
str_low_ts = stringNew(bigbuf);
sprintf(bigbuf,
" fmorphopgen_low_%d(datad, w, h, wpld, datat, wpls, index+1);",
fileindex);
str_low_dtp1 = stringNew(bigbuf);
/* Make the output sa */
sa3 = sarrayCreate(0);
/* Copyright notice and info header */
sarrayParseRange(sa2, 0, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Insert function names as documentation */
sarrayAddString(sa3, str_doc1, L_INSERT);
sarrayAddString(sa3, str_doc2, L_INSERT);
/* Add '#include's */
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Insert function prototypes */
sarrayAddString(sa3, str_proto1, L_INSERT);
sarrayAddString(sa3, str_proto2, L_INSERT);
sarrayAddString(sa3, str_proto3, L_INSERT);
/* Add static globals */
sprintf(bigbuf, "\nstatic l_int32 NUM_SELS_GENERATED = %d;", nsels);
sarrayAddString(sa3, bigbuf, L_COPY);
sprintf(bigbuf, "static char SEL_NAMES[][80] = {");
sarrayAddString(sa3, bigbuf, L_COPY);
for (i = 0; i < nsels - 1; i++) {
sprintf(bigbuf, " \"%s\",",
sarrayGetString(sa1, i, L_NOCOPY));
sarrayAddString(sa3, bigbuf, L_COPY);
}
sprintf(bigbuf, " \"%s\"};",
sarrayGetString(sa1, i, L_NOCOPY));
sarrayAddString(sa3, bigbuf, L_COPY);
/* Start pixMorphDwa_*() function description */
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_doc3, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Finish pixMorphDwa_*() function definition */
sarrayAddString(sa3, str_def1, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_proc1, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_dwa1, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Start pixFMorphopGen_*() function description */
sarrayAddString(sa3, str_doc4, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Finish pixFMorphopGen_*() function definition */
sarrayAddString(sa3, str_def2, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_proc2, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_low_dt, L_COPY);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_low_ds, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_low_tsp1, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_low_dt, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_low_ts, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
sarrayAddString(sa3, str_low_dtp1, L_INSERT);
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Output to file */
filestr = sarrayToString(sa3, 1);
nbytes = strlen(filestr);
if (filename)
snprintf(bigbuf, L_BUF_SIZE, "%s.%d.c", filename, fileindex);
else
sprintf(bigbuf, "%s.%d.c", OUTROOT, fileindex);
l_binaryWrite(bigbuf, "w", filestr, nbytes);
sarrayDestroy(&sa1);
sarrayDestroy(&sa2);
sarrayDestroy(&sa3);
LEPT_FREE(filestr);
return 0;
}
main(int argc,
char **argv)
{
char *filename, *filein, *str, *prestring;
const char *spacestr = " ";
char buf[L_BUF_SIZE];
l_int32 i, firstfile, len, ret;
SARRAY *sa;
static char mainName[] = "xtractprotos";
/* Output extern C head */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"/*", 1);
snprintf(buf, L_BUF_SIZE,
" * This file was autogen'd by xtractprotos, v. %s", version);
sarrayAddString(sa, buf, 1);
sarrayAddString(sa, (char *)" */", 1);
sarrayAddString(sa, (char *)"#ifdef __cplusplus", 1);
sarrayAddString(sa, (char *)"extern \"C\" {", 1);
sarrayAddString(sa, (char *)"#endif /* __cplusplus */\n", 1);
str = sarrayToString(sa, 1);
fprintf(stdout, str);
sarrayDestroy(&sa);
FREE(str);
/* Prepend 'prestring' if requested */
firstfile = 1;
prestring = NULL;
if (argv[1][0] == '-') {
firstfile = 2;
if (sscanf(argv[1], "-prestring=%s", buf) != 1)
L_WARNING("Failure to parse prestring; omitting!", mainName);
else {
if ((len = strlen(buf)) > L_BUF_SIZE - 3)
L_WARNING("prestring too large; omitting!", mainName);
else {
buf[len] = ' ';
buf[len + 1] = '\0';
prestring = stringNew(buf);
}
}
}
for (i = firstfile; i < argc; i++) {
filein = argv[i];
len = strlen(filein);
if (filein[len - 1] == 'h')
continue;
snprintf(buf, L_BUF_SIZE, "cpp -ansi -DNO_PROTOS %s %s",
filein, tempfile);
ret = system(buf);
if (ret) {
fprintf(stderr, "cpp failure for %s; continuing\n", filein);
continue;
}
#ifndef _CYGWIN_ENVIRON
filename = stringNew(tempfile);
#else
filename = stringJoin(tempfile, ".exe");
#endif /* ~ _CYGWIN_ENVIRON */
if ((str = parseForProtos(filename, prestring)) == NULL) {
fprintf(stderr, "parse failure for %s; continuing\n", filein);
continue;
}
if (strlen(str) > 1) /* strlen(str) == 1 is a file without protos */
fprintf(stdout, str);
FREE(str);
FREE(filename);
}
/* Output extern C tail */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"\n#ifdef __cplusplus", 1);
sarrayAddString(sa, (char *)"}", 1);
sarrayAddString(sa, (char *)"#endif /* __cplusplus */", 1);
str = sarrayToString(sa, 1);
fprintf(stdout, str);
sarrayDestroy(&sa);
FREE(str);
if (prestring)
FREE(prestring);
return 0;
}
main(int argc,
char **argv)
{
char *str;
l_int32 i, j, same, ok;
l_float32 sum, avediff, rmsdiff;
L_KERNEL *kel1, *kel2, *kel3, *kel4, *kelx, *kely;
BOX *box;
PIX *pix, *pixs, *pixb, *pixg, *pixr, *pixd, *pixp, *pixt;
PIX *pixt1, *pixt2, *pixt3;
PIXA *pixa;
SARRAY *sa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Test creating from a string */
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = kernelDisplayInPix(kel1, 41, 2);
pixWrite("/tmp/pixkern.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/pixkern.png"); /* 0 */
pixSaveTiled(pixd, pixa, 1, 1, 20, 8);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test read/write for kernel. Note that both get
* compared to the same golden file, which is
* overwritten with a copy of /tmp/kern2.kel */
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
kernelWrite("/tmp/kern1.kel", kel1);
regTestCheckFile(rp, "/tmp/kern1.kel"); /* 1 */
kel2 = kernelRead("/tmp/kern1.kel");
kernelWrite("/tmp/kern2.kel", kel2);
regTestCheckFile(rp, "/tmp/kern2.kel"); /* 2 */
regTestCompareFiles(rp, 1, 2); /* 3 */
kernelDestroy(&kel1);
kernelDestroy(&kel2);
/* Test creating from a file */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"# small 3x3 kernel", L_COPY);
sarrayAddString(sa, (char *)"3 5", L_COPY);
sarrayAddString(sa, (char *)"1 2", L_COPY);
sarrayAddString(sa, (char *)"20.5 50 80 50 20", L_COPY);
sarrayAddString(sa, (char *)"82. 120 180 120 80", L_COPY);
sarrayAddString(sa, (char *)"22.1 50 80 50 20", L_COPY);
str = sarrayToString(sa, 1);
l_binaryWrite("/tmp/kernfile.kel", "w", str, strlen(str));
kel2 = kernelCreateFromFile("/tmp/kernfile.kel");
pixd = kernelDisplayInPix(kel2, 41, 2);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/ker1.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker1.png"); /* 4 */
pixDestroy(&pixd);
sarrayDestroy(&sa);
lept_free(str);
kernelDestroy(&kel2);
/* Test creating from a pix */
pixt = pixCreate(5, 3, 8);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 0, 50);
pixSetPixel(pixt, 2, 0, 80);
pixSetPixel(pixt, 3, 0, 50);
pixSetPixel(pixt, 4, 0, 20);
pixSetPixel(pixt, 0, 1, 80);
pixSetPixel(pixt, 1, 1, 120);
pixSetPixel(pixt, 2, 1, 180);
pixSetPixel(pixt, 3, 1, 120);
pixSetPixel(pixt, 4, 1, 80);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 2, 50);
pixSetPixel(pixt, 2, 2, 80);
pixSetPixel(pixt, 3, 2, 50);
pixSetPixel(pixt, 4, 2, 20);
kel3 = kernelCreateFromPix(pixt, 1, 2);
pixd = kernelDisplayInPix(kel3, 41, 2);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker2.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker2.png"); /* 5 */
pixDestroy(&pixd);
pixDestroy(&pixt);
kernelDestroy(&kel3);
/* Test convolution with kel1 */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 3, COLOR_GREEN);
pixSaveTiled(pixg, pixa, 1, 1, 20, 0);
kel1 = kernelCreateFromString(5, 5, 2, 2, kdatastr);
pixd = pixConvolve(pixg, kel1, 8, 1);
pixSaveTiled(pixd, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker3.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker3.png"); /* 6 */
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
kernelDestroy(&kel1);
/* Test convolution with flat rectangular kel; also test
* block convolution with tiling. */
pixs = pixRead("test24.jpg");
pixg = pixScaleRGBToGrayFast(pixs, 3, COLOR_GREEN);
kel2 = makeFlatKernel(11, 11, 5, 5);
pixd = pixConvolve(pixg, kel2, 8, 1);
pixSaveTiled(pixd, pixa, 1, 1, 20, 0);
pixWrite("/tmp/ker4.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker4.png"); /* 7 */
pixt = pixBlockconv(pixg, 5, 5);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker5.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker5.png"); /* 8 */
if (rp->display)
pixCompareGray(pixd, pixt, L_COMPARE_ABS_DIFF, GPLOT_X11, NULL,
NULL, NULL, NULL);
pixt2 = pixBlockconvTiled(pixg, 5, 5, 3, 6);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker5a.png", pixt2, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker5a.png"); /* 9 */
pixDestroy(&pixt2);
ok = TRUE;
for (i = 1; i <= 7; i++) {
for (j = 1; j <= 7; j++) {
if (i == 1 && j == 1) continue;
pixt2 = pixBlockconvTiled(pixg, 5, 5, j, i);
pixEqual(pixt2, pixd, &same);
if (!same) {
fprintf(stderr," Error for nx = %d, ny = %d\n", j, i);
ok = FALSE;
}
pixDestroy(&pixt2);
}
}
if (ok)
fprintf(stderr, "OK: Tiled results identical to pixConvolve()\n");
else
fprintf(stderr, "ERROR: Tiled results not identical to pixConvolve()\n");
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixDestroy(&pixt);
kernelDestroy(&kel2);
/* Do another flat rectangular test; this time with white at edge.
* About 1% of the pixels near the image edge differ by 1 between
* the pixConvolve() and pixBlockconv(). For what it's worth,
* pixConvolve() gives the more accurate result; namely, 255 for
* pixels at the edge. */
pix = pixRead("pageseg1.tif");
box = boxCreate(100, 100, 2260, 3160);
pixb = pixClipRectangle(pix, box, NULL);
pixs = pixScaleToGray4(pixb);
kel3 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt = pixConvolve(pixs, kel3, 8, 1);
fprintf(stderr, "Generic convolution time: %5.3f sec\n", stopTimer());
pixSaveTiled(pixt, pixa, 1, 1, 20, 0);
pixWrite("/tmp/conv1.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/conv1.png"); /* 10 */
startTimer();
pixt2 = pixBlockconv(pixs, 3, 3);
fprintf(stderr, "Flat block convolution time: %5.3f sec\n", stopTimer());
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/conv2.png", pixt2, IFF_PNG); /* ditto */
regTestCheckFile(rp, "/tmp/conv2.png"); /* 11 */
pixCompareGray(pixt, pixt2, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&avediff, &rmsdiff, NULL);
#ifndef _WIN32
sleep(1); /* give gnuplot time to write out the file */
#else
Sleep(1000);
#endif /* _WIN32 */
pixp = pixRead("/tmp/grayroot.png");
pixSaveTiled(pixp, pixa, 1, 0, 20, 0);
pixWrite("/tmp/conv3.png", pixp, IFF_PNG);
regTestCheckFile(rp, "/tmp/conv3.png"); /* 12 */
fprintf(stderr, "Ave diff = %6.4f, RMS diff = %6.4f\n", avediff, rmsdiff);
if (avediff <= 0.01)
fprintf(stderr, "OK: avediff = %6.4f <= 0.01\n", avediff);
else
fprintf(stderr, "Bad?: avediff = %6.4f > 0.01\n", avediff);
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDestroy(&pixp);
pixDestroy(&pix);
pixDestroy(&pixb);
boxDestroy(&box);
kernelDestroy(&kel3);
/* Do yet another set of flat rectangular tests, this time
* on an RGB image */
pixs = pixRead("test24.jpg");
kel4 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt1 = pixConvolveRGB(pixs, kel4);
fprintf(stderr, "Time 7x7 non-separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv4.jpg", pixt1, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv4.jpg"); /* 13 */
kelx = makeFlatKernel(1, 7, 0, 3);
kely = makeFlatKernel(7, 1, 3, 0);
startTimer();
pixt2 = pixConvolveRGBSep(pixs, kelx, kely);
fprintf(stderr, "Time 7x1,1x7 separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv5.jpg", pixt2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv5.jpg"); /* 14 */
startTimer();
pixt3 = pixBlockconv(pixs, 3, 3);
fprintf(stderr, "Time 7x7 blockconv: %7.3f sec\n", stopTimer());
pixWrite("/tmp/conv6.jpg", pixt3, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/conv6.jpg"); /* 15 */
regTestComparePix(rp, pixt1, pixt2); /* 16 */
regTestCompareSimilarPix(rp, pixt2, pixt3, 15, 0.0005, 0); /* 17 */
pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
kernelDestroy(&kel4);
kernelDestroy(&kelx);
kernelDestroy(&kely);
/* Test generation and convolution with gaussian kernel */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
kel1 = makeGaussianKernel(5, 5, 3.0, 5.0);
kernelGetSum(kel1, &sum);
fprintf(stderr, "Sum for gaussian kernel = %f\n", sum);
kernelWrite("/tmp/gauss.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 1);
pixt2 = pixConvolve(pixs, kel1, 16, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker6.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker6.png"); /* 18 */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixt = kernelDisplayInPix(kel1, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kel1);
pixDestroy(&pixs);
/* Test generation and convolution with separable gaussian kernel */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
makeGaussianKernelSep(5, 5, 3.0, 5.0, &kelx, &kely);
kernelGetSum(kelx, &sum);
fprintf(stderr, "Sum for x gaussian kernel = %f\n", sum);
kernelGetSum(kely, &sum);
fprintf(stderr, "Sum for y gaussian kernel = %f\n", sum);
kernelWrite("/tmp/gauss.kelx", kelx);
kernelWrite("/tmp/gauss.kely", kely);
pixt = pixConvolveSep(pixs, kelx, kely, 8, 1);
pixt2 = pixConvolveSep(pixs, kelx, kely, 16, 0);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixSaveTiled(pixt2, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker7.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker7.png"); /* 19 */
pixDestroy(&pixt);
pixDestroy(&pixt2);
pixt = kernelDisplayInPix(kelx, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 25, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kelx);
kernelDestroy(&kely);
pixDestroy(&pixs);
/* Test generation and convolution with diff of gaussians kernel */
/* pixt = pixRead("marge.jpg");
pixs = pixConvertRGBToLuminance(pixt);
pixDestroy(&pixt); */
pixs = pixRead("test8.jpg");
pixSaveTiled(pixs, pixa, 1, 1, 20, 0);
kel1 = makeDoGKernel(7, 7, 1.5, 2.7);
kernelGetSum(kel1, &sum);
fprintf(stderr, "Sum for DoG kernel = %f\n", sum);
kernelWrite("/tmp/dog.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 0);
/* pixInvert(pixt, pixt); */
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixWrite("/tmp/ker8.png", pixt, IFF_PNG);
regTestCheckFile(rp, "/tmp/ker8.png"); /* 20 */
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kel1, 20, 2);
pixSaveTiled(pixt, pixa, 1, 0, 20, 0);
pixDestroy(&pixt);
kernelDestroy(&kel1);
pixDestroy(&pixs);
pixd = pixaDisplay(pixa, 0, 0);
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixWrite("/tmp/kernel.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
regTestCleanup(rp);
return 0;
}
/*!
* pixHtmlViewer()
*
* Input: dirin: directory of input image files
* dirout: directory for output files
* rootname: root name for output files
* thumbwidth: width of thumb images
* (in pixels; use 0 for default)
* viewwidth: maximum width of view images (no up-scaling)
* (in pixels; use 0 for default)
* copyorig: 1 to copy originals to dirout; 0 otherwise
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) The thumb and view reduced images are generated,
* along with two html files:
* <rootname>.html and <rootname>-links.html
* (2) The thumb and view files are named
* <rootname>_thumb_xxx.jpg
* <rootname>_view_xxx.jpg
* With this naming scheme, any number of input directories
* of images can be processed into views and thumbs
* and placed in the same output directory.
*/
l_int32
pixHtmlViewer(const char *dirin,
const char *dirout,
const char *rootname,
l_int32 thumbwidth,
l_int32 viewwidth,
l_int32 copyorig)
{
char *fname, *fullname, *outname;
char *mainname, *linkname, *linknameshort;
char *viewfile, *thumbfile;
char *shtml, *slink;
char charbuf[L_BUF_SIZE];
char htmlstring[] = "<html>";
char framestring[] = "</frameset></html>";
l_int32 i, nfiles, index, w, nimages, ret;
l_float32 factor;
PIX *pix, *pixthumb, *pixview;
SARRAY *safiles, *sathumbs, *saviews, *sahtml, *salink;
PROCNAME("pixHtmlViewer");
if (!dirin)
return ERROR_INT("dirin not defined", procName, 1);
if (!dirout)
return ERROR_INT("dirout not defined", procName, 1);
if (!rootname)
return ERROR_INT("rootname not defined", procName, 1);
if (thumbwidth == 0)
thumbwidth = DEFAULT_THUMB_WIDTH;
if (thumbwidth < MIN_THUMB_WIDTH) {
L_WARNING("thumbwidth too small; using min value\n", procName);
thumbwidth = MIN_THUMB_WIDTH;
}
if (viewwidth == 0)
viewwidth = DEFAULT_VIEW_WIDTH;
if (viewwidth < MIN_VIEW_WIDTH) {
L_WARNING("viewwidth too small; using min value\n", procName);
viewwidth = MIN_VIEW_WIDTH;
}
/* Make the output directory if it doesn't already exist */
#ifndef _WIN32
sprintf(charbuf, "mkdir -p %s", dirout);
ret = system(charbuf);
#else
ret = CreateDirectory(dirout, NULL) ? 0 : 1;
#endif /* !_WIN32 */
if (ret) {
L_ERROR("output directory %s not made\n", procName, dirout);
return 1;
}
/* Capture the filenames in the input directory */
if ((safiles = getFilenamesInDirectory(dirin)) == NULL)
return ERROR_INT("safiles not made", procName, 1);
/* Generate output text file names */
sprintf(charbuf, "%s/%s.html", dirout, rootname);
mainname = stringNew(charbuf);
sprintf(charbuf, "%s/%s-links.html", dirout, rootname);
linkname = stringNew(charbuf);
linknameshort = stringJoin(rootname, "-links.html");
if ((sathumbs = sarrayCreate(0)) == NULL)
return ERROR_INT("sathumbs not made", procName, 1);
if ((saviews = sarrayCreate(0)) == NULL)
return ERROR_INT("saviews not made", procName, 1);
/* Generate the thumbs and views */
nfiles = sarrayGetCount(safiles);
index = 0;
for (i = 0; i < nfiles; i++) {
fname = sarrayGetString(safiles, i, L_NOCOPY);
fullname = genPathname(dirin, fname);
fprintf(stderr, "name: %s\n", fullname);
if ((pix = pixRead(fullname)) == NULL) {
fprintf(stderr, "file %s not a readable image\n", fullname);
FREE(fullname);
continue;
}
FREE(fullname);
if (copyorig) {
outname = genPathname(dirout, fname);
pixWrite(outname, pix, IFF_JFIF_JPEG);
FREE(outname);
}
/* Make and store the thumb */
w = pixGetWidth(pix);
factor = (l_float32)thumbwidth / (l_float32)w;
if ((pixthumb = pixScale(pix, factor, factor)) == NULL)
return ERROR_INT("pixthumb not made", procName, 1);
sprintf(charbuf, "%s_thumb_%03d.jpg", rootname, index);
sarrayAddString(sathumbs, charbuf, L_COPY);
outname = genPathname(dirout, charbuf);
pixWrite(outname, pixthumb, IFF_JFIF_JPEG);
FREE(outname);
pixDestroy(&pixthumb);
/* Make and store the view */
factor = (l_float32)viewwidth / (l_float32)w;
if (factor >= 1.0) {
pixview = pixClone(pix); /* no upscaling */
} else {
if ((pixview = pixScale(pix, factor, factor)) == NULL)
return ERROR_INT("pixview not made", procName, 1);
}
sprintf(charbuf, "%s_view_%03d.jpg", rootname, index);
sarrayAddString(saviews, charbuf, L_COPY);
outname = genPathname(dirout, charbuf);
pixWrite(outname, pixview, IFF_JFIF_JPEG);
FREE(outname);
pixDestroy(&pixview);
pixDestroy(&pix);
index++;
}
/* Generate the main html file */
if ((sahtml = sarrayCreate(0)) == NULL)
return ERROR_INT("sahtml not made", procName, 1);
sarrayAddString(sahtml, htmlstring, L_COPY);
sprintf(charbuf, "<frameset cols=\"%d, *\">", thumbwidth + 30);
sarrayAddString(sahtml, charbuf, L_COPY);
sprintf(charbuf, "<frame name=\"thumbs\" src=\"%s\">", linknameshort);
sarrayAddString(sahtml, charbuf, L_COPY);
sprintf(charbuf, "<frame name=\"views\" src=\"%s\">",
sarrayGetString(saviews, 0, L_NOCOPY));
sarrayAddString(sahtml, charbuf, L_COPY);
sarrayAddString(sahtml, framestring, L_COPY);
shtml = sarrayToString(sahtml, 1);
l_binaryWrite(mainname, "w", shtml, strlen(shtml));
FREE(shtml);
FREE(mainname);
/* Generate the link html file */
nimages = sarrayGetCount(saviews);
fprintf(stderr, "num. images = %d\n", nimages);
if ((salink = sarrayCreate(0)) == NULL)
return ERROR_INT("salink not made", procName, 1);
for (i = 0; i < nimages; i++) {
viewfile = sarrayGetString(saviews, i, L_NOCOPY);
thumbfile = sarrayGetString(sathumbs, i, L_NOCOPY);
sprintf(charbuf, "<a href=\"%s\" TARGET=views><img src=\"%s\"></a>",
viewfile, thumbfile);
sarrayAddString(salink, charbuf, L_COPY);
}
slink = sarrayToString(salink, 1);
l_binaryWrite(linkname, "w", slink, strlen(slink));
FREE(slink);
FREE(linkname);
FREE(linknameshort);
sarrayDestroy(&safiles);
sarrayDestroy(&sathumbs);
sarrayDestroy(&saviews);
sarrayDestroy(&sahtml);
sarrayDestroy(&salink);
return 0;
}
/*!
* sarrayConvertWordsToLines()
*
* Input: sa (sa of individual words)
* linesize (max num of chars in each line)
* Return: saout (sa of formatted lines), or null on error
*
* This is useful for re-typesetting text to a specific maximum
* line length. The individual words in the input sarray
* are concatenated into textlines. An input word string of zero
* length is taken to be a paragraph separator. Each time
* such a string is found, the current line is ended and
* a new line is also produced that contains just the
* string of zero length (""). When the output sarray
* of lines is eventually converted to a string with newlines
* (typically) appended to each line string, the empty
* strings are just converted to newlines, producing the visible
* paragraph separation.
*
* What happens when a word is larger than linesize?
* We write it out as a single line anyway! Words preceding
* or following this long word are placed on lines preceding
* or following the line with the long word. Why this choice?
* Long "words" found in text documents are typically URLs, and
* it's often desirable not to put newlines in the middle of a URL.
* The text display program (e.g., text editor) will typically
* wrap the long "word" to fit in the window.
*/
SARRAY *
sarrayConvertWordsToLines(SARRAY *sa,
l_int32 linesize)
{
char *wd, *strl;
char emptystring[] = "";
l_int32 n, i, len, totlen;
SARRAY *sal, *saout;
PROCNAME("sarrayConvertWordsToLines");
if (!sa)
return (SARRAY *)ERROR_PTR("sa not defined", procName, NULL);
if ((saout = sarrayCreate(0)) == NULL)
return (SARRAY *)ERROR_PTR("saout not defined", procName, NULL);
n = sarrayGetCount(sa);
totlen = 0;
sal = NULL;
for (i = 0; i < n; i++) {
if (!sal) {
if ((sal = sarrayCreate(0)) == NULL)
return (SARRAY *)ERROR_PTR("sal not made", procName, NULL);
}
wd = sarrayGetString(sa, i, L_NOCOPY);
len = strlen(wd);
if (len == 0) { /* end of paragraph: end line & insert blank line */
if (totlen > 0) {
strl = sarrayToString(sal, 2);
sarrayAddString(saout, strl, L_INSERT);
}
sarrayAddString(saout, emptystring, L_COPY);
sarrayDestroy(&sal);
totlen = 0;
}
else if (totlen == 0 && len + 1 > linesize) { /* long word! */
sarrayAddString(saout, wd, L_COPY); /* copy to one line */
}
else if (totlen + len + 1 > linesize) { /* end line & start new one */
strl = sarrayToString(sal, 2);
sarrayAddString(saout, strl, L_INSERT);
sarrayDestroy(&sal);
if ((sal = sarrayCreate(0)) == NULL)
return (SARRAY *)ERROR_PTR("sal not made", procName, NULL);
sarrayAddString(sal, wd, L_COPY);
totlen = len + 1;
}
else { /* add to current line */
sarrayAddString(sal, wd, L_COPY);
totlen += len + 1;
}
}
if (totlen > 0) { /* didn't end with blank line; output last line */
strl = sarrayToString(sal, 2);
sarrayAddString(saout, strl, L_INSERT);
sarrayDestroy(&sal);
}
return saout;
}
int main(int argc,
char **argv)
{
l_int32 ignore;
size_t nbytesin, nbytesout;
char *infile, *instring, *outstring;
SARRAY *sa1, *sa2, *sa3, *sa4, *sa5;
char buf[256];
static char mainName[] = "string_reg";
if (argc != 2)
return ERROR_INT(" Syntax: string_reg infile", mainName, 1);
infile = argv[1];
instring = (char *)l_binaryRead(infile, &nbytesin);
if (!instring)
return ERROR_INT("file not read", mainName, 1);
sa1 = sarrayCreateWordsFromString(instring);
sa2 = sarrayCreateLinesFromString(instring, 0);
sa3 = sarrayCreateLinesFromString(instring, 1);
outstring = sarrayToString(sa1, 0);
nbytesout = strlen(outstring);
l_binaryWrite("/tmp/junk1.txt", "w", outstring, nbytesout);
lept_free(outstring);
outstring = sarrayToString(sa1, 1);
nbytesout = strlen(outstring);
l_binaryWrite("/tmp/junk2.txt", "w", outstring, nbytesout);
lept_free(outstring);
outstring = sarrayToString(sa2, 0);
nbytesout = strlen(outstring);
l_binaryWrite("/tmp/junk3.txt", "w", outstring, nbytesout);
lept_free(outstring);
outstring = sarrayToString(sa2, 1);
nbytesout = strlen(outstring);
l_binaryWrite("/tmp/junk4.txt", "w", outstring, nbytesout);
lept_free(outstring);
outstring = sarrayToString(sa3, 0);
nbytesout = strlen(outstring);
l_binaryWrite("/tmp/junk5.txt", "w", outstring, nbytesout);
lept_free(outstring);
outstring = sarrayToString(sa3, 1);
nbytesout = strlen(outstring);
l_binaryWrite("/tmp/junk6.txt", "w", outstring, nbytesout);
lept_free(outstring);
sprintf(buf, "diff -s /tmp/junk6.txt %s", infile);
ignore = system(buf);
/* write/read/write; compare /tmp/junkout5 with /tmp/junkout6 */
sarrayWrite("/tmp/junk7.txt", sa2);
sarrayWrite("/tmp/junk8.txt", sa3);
sa4 = sarrayRead("/tmp/junk8.txt");
sarrayWrite("/tmp/junk9.txt", sa4);
sa5 = sarrayRead("/tmp/junk9.txt");
ignore = system("diff -s /tmp/junk8.txt /tmp/junk9.txt");
sarrayDestroy(&sa1);
sarrayDestroy(&sa2);
sarrayDestroy(&sa3);
sarrayDestroy(&sa4);
sarrayDestroy(&sa5);
lept_free(instring);
return 0;
}
/*!
* \brief strcodeFinalize()
*
* \param[in,out] pstrcode destroys after .c and .h files have been generated
* \param[in] outdir [optional] if NULL, files are made in /tmp/lept/auto
* \return void
*/
l_int32
strcodeFinalize(L_STRCODE **pstrcode,
const char *outdir)
{
char buf[256];
char *filestr, *casestr, *descr, *datastr, *realoutdir;
l_int32 actstart, end, newstart, fileno, nbytes;
size_t size;
L_STRCODE *strcode;
SARRAY *sa1, *sa2, *sa3;
PROCNAME("strcodeFinalize");
lept_mkdir("lept/auto");
if (!pstrcode || *pstrcode == NULL)
return ERROR_INT("No input data", procName, 1);
strcode = *pstrcode;
if (!outdir) {
L_INFO("no outdir specified; writing to /tmp/lept/auto\n", procName);
realoutdir = stringNew("/tmp/lept/auto");
} else {
realoutdir = stringNew(outdir);
}
/* ------------------------------------------------------- */
/* Make the output autogen.*.c file */
/* ------------------------------------------------------- */
/* Make array of textlines from TEMPLATE1 */
if ((filestr = (char *)l_binaryRead(TEMPLATE1, &size)) == NULL)
return ERROR_INT("filestr not made", procName, 1);
if ((sa1 = sarrayCreateLinesFromString(filestr, 1)) == NULL)
return ERROR_INT("sa1 not made", procName, 1);
LEPT_FREE(filestr);
if ((sa3 = sarrayCreate(0)) == NULL)
return ERROR_INT("sa3 not made", procName, 1);
/* Copyright notice */
sarrayParseRange(sa1, 0, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* File name comment */
fileno = strcode->fileno;
snprintf(buf, sizeof(buf), " * autogen.%d.c", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* More text */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* Description of function types by index */
descr = sarrayToString(strcode->descr, 1);
descr[strlen(descr) - 1] = '\0';
sarrayAddString(sa3, descr, L_INSERT);
/* Includes */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
snprintf(buf, sizeof(buf), "#include \"autogen.%d.h\"", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Header for auto-generated deserializers */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* Function name (as comment) */
snprintf(buf, sizeof(buf), " * l_autodecode_%d()", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Input and return values */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* Function name */
snprintf(buf, sizeof(buf), "l_autodecode_%d(l_int32 index)", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Stack vars */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* Declaration of nfunc on stack */
snprintf(buf, sizeof(buf), "l_int32 nfunc = %d;\n", strcode->n);
sarrayAddString(sa3, buf, L_COPY);
/* Declaration of PROCNAME */
snprintf(buf, sizeof(buf), " PROCNAME(\"l_autodecode_%d\");", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Test input variables */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* Insert case string */
casestr = sarrayToString(strcode->function, 0);
casestr[strlen(casestr) - 1] = '\0';
sarrayAddString(sa3, casestr, L_INSERT);
/* End of function */
sarrayParseRange(sa1, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa1, actstart, end);
/* Flatten to string and output to autogen*.c file */
if ((filestr = sarrayToString(sa3, 1)) == NULL)
return ERROR_INT("filestr from sa3 not made", procName, 1);
nbytes = strlen(filestr);
snprintf(buf, sizeof(buf), "%s/autogen.%d.c", realoutdir, fileno);
l_binaryWrite(buf, "w", filestr, nbytes);
LEPT_FREE(filestr);
sarrayDestroy(&sa1);
sarrayDestroy(&sa3);
/* ------------------------------------------------------- */
/* Make the output autogen.*.h file */
/* ------------------------------------------------------- */
/* Make array of textlines from TEMPLATE2 */
if ((filestr = (char *)l_binaryRead(TEMPLATE2, &size)) == NULL)
return ERROR_INT("filestr not made", procName, 1);
if ((sa2 = sarrayCreateLinesFromString(filestr, 1)) == NULL)
return ERROR_INT("sa2 not made", procName, 1);
LEPT_FREE(filestr);
if ((sa3 = sarrayCreate(0)) == NULL)
return ERROR_INT("sa3 not made", procName, 1);
/* Copyright notice */
sarrayParseRange(sa2, 0, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* File name comment */
snprintf(buf, sizeof(buf), " * autogen.%d.h", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* More text */
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Beginning header protection */
snprintf(buf, sizeof(buf), "#ifndef LEPTONICA_AUTOGEN_%d_H\n"
"#define LEPTONICA_AUTOGEN_%d_H",
fileno, fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Prototype header text */
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Prototype declaration */
snprintf(buf, sizeof(buf), "void *l_autodecode_%d(l_int32 index);", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Prototype trailer text */
sarrayParseRange(sa2, newstart, &actstart, &end, &newstart, "--", 0);
sarrayAppendRange(sa3, sa2, actstart, end);
/* Insert serialized data strings */
datastr = sarrayToString(strcode->data, 1);
datastr[strlen(datastr) - 1] = '\0';
sarrayAddString(sa3, datastr, L_INSERT);
/* End header protection */
snprintf(buf, sizeof(buf), "#endif /* LEPTONICA_AUTOGEN_%d_H */", fileno);
sarrayAddString(sa3, buf, L_COPY);
/* Flatten to string and output to autogen*.h file */
if ((filestr = sarrayToString(sa3, 1)) == NULL)
return ERROR_INT("filestr from sa3 not made", procName, 1);
nbytes = strlen(filestr);
snprintf(buf, sizeof(buf), "%s/autogen.%d.h", realoutdir, fileno);
l_binaryWrite(buf, "w", filestr, nbytes);
LEPT_FREE(filestr);
LEPT_FREE(realoutdir);
sarrayDestroy(&sa2);
sarrayDestroy(&sa3);
/* Cleanup */
strcodeDestroy(pstrcode);
return 0;
}
int main(int argc,
char **argv)
{
char *filein, *str, *prestring, *outprotos, *protostr;
const char *spacestr = " ";
char buf[L_BUF_SIZE];
l_uint8 *allheaders;
l_int32 i, maxindex, in_line, nflags, protos_added, firstfile, len, ret;
size_t nbytes;
L_BYTEA *ba, *ba2;
SARRAY *sa, *safirst;
static char mainName[] = "xtractprotos";
if (argc == 1) {
fprintf(stderr,
"xtractprotos [-prestring=<string>] [-protos=<where>] "
"[list of C files]\n"
"where the prestring is prepended to each prototype, and \n"
"protos can be either 'inline' or the name of an output "
"prototype file\n");
return 1;
}
/* ---------------------------------------------------------------- */
/* Parse input flags and find prestring and outprotos, if requested */
/* ---------------------------------------------------------------- */
prestring = outprotos = NULL;
in_line = FALSE;
nflags = 0;
maxindex = L_MIN(3, argc);
for (i = 1; i < maxindex; i++) {
if (argv[i][0] == '-') {
if (!strncmp(argv[i], "-prestring", 10)) {
nflags++;
ret = sscanf(argv[i] + 1, "prestring=%s", buf);
if (ret != 1) {
fprintf(stderr, "parse failure for prestring\n");
return 1;
}
if ((len = strlen(buf)) > L_BUF_SIZE - 3) {
L_WARNING("prestring too large; omitting!\n", mainName);
} else {
buf[len] = ' ';
buf[len + 1] = '\0';
prestring = stringNew(buf);
}
} else if (!strncmp(argv[i], "-protos", 7)) {
nflags++;
ret = sscanf(argv[i] + 1, "protos=%s", buf);
if (ret != 1) {
fprintf(stderr, "parse failure for protos\n");
return 1;
}
outprotos = stringNew(buf);
if (!strncmp(outprotos, "inline", 7))
in_line = TRUE;
}
}
}
if (argc - nflags < 2) {
fprintf(stderr, "no files specified!\n");
return 1;
}
/* ---------------------------------------------------------------- */
/* Generate the prototype string */
/* ---------------------------------------------------------------- */
ba = l_byteaCreate(500);
/* First the extern C head */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"/*", 1);
snprintf(buf, L_BUF_SIZE,
" * These prototypes were autogen'd by xtractprotos, v. %s",
version);
sarrayAddString(sa, buf, 1);
sarrayAddString(sa, (char *)" */", 1);
sarrayAddString(sa, (char *)"#ifdef __cplusplus", 1);
sarrayAddString(sa, (char *)"extern \"C\" {", 1);
sarrayAddString(sa, (char *)"#endif /* __cplusplus */\n", 1);
str = sarrayToString(sa, 1);
l_byteaAppendString(ba, str);
lept_free(str);
sarrayDestroy(&sa);
/* Then the prototypes */
firstfile = 1 + nflags;
protos_added = FALSE;
for (i = firstfile; i < argc; i++) {
filein = argv[i];
len = strlen(filein);
if (filein[len - 1] == 'h') /* skip .h files */
continue;
snprintf(buf, L_BUF_SIZE, "cpp -ansi -DNO_PROTOS %s %s",
filein, tempfile);
ret = system(buf);
if (ret) {
fprintf(stderr, "cpp failure for %s; continuing\n", filein);
continue;
}
if ((str = parseForProtos(tempfile, prestring)) == NULL) {
fprintf(stderr, "parse failure for %s; continuing\n", filein);
continue;
}
if (strlen(str) > 1) { /* strlen(str) == 1 is a file without protos */
l_byteaAppendString(ba, str);
protos_added = TRUE;
}
lept_free(str);
}
/* Lastly the extern C tail */
sa = sarrayCreate(0);
sarrayAddString(sa, (char *)"\n#ifdef __cplusplus", 1);
sarrayAddString(sa, (char *)"}", 1);
sarrayAddString(sa, (char *)"#endif /* __cplusplus */", 1);
str = sarrayToString(sa, 1);
l_byteaAppendString(ba, str);
lept_free(str);
sarrayDestroy(&sa);
protostr = (char *)l_byteaCopyData(ba, &nbytes);
l_byteaDestroy(&ba);
/* ---------------------------------------------------------------- */
/* Generate the output */
/* ---------------------------------------------------------------- */
if (!outprotos) { /* just write to stdout */
fprintf(stderr, "%s\n", protostr);
lept_free(protostr);
return 0;
}
/* If no protos were found, do nothing further */
if (!protos_added) {
fprintf(stderr, "No protos found\n");
lept_free(protostr);
return 1;
}
/* Make the output files */
ba = l_byteaInitFromFile("allheaders_top.txt");
if (!in_line) {
snprintf(buf, sizeof(buf), "#include \"%s\"\n", outprotos);
l_byteaAppendString(ba, buf);
l_binaryWrite(outprotos, "w", protostr, nbytes);
} else {
l_byteaAppendString(ba, protostr);
}
ba2 = l_byteaInitFromFile("allheaders_bot.txt");
l_byteaJoin(ba, &ba2);
l_byteaWrite("allheaders.h", ba, 0, 0);
l_byteaDestroy(&ba);
lept_free(protostr);
return 0;
}
main(int argc,
char **argv)
{
char *str, *results_file;
char command[256], buf[256];
l_int32 i, ntests, dotest, nfail, ret, start, stop;
SARRAY *sa;
L_TIMER timer;
static char mainName[] = "alltests_reg";
if (argc != 2)
return ERROR_INT(" Syntax alltests_reg [generate | compare | display]",
mainName, 1);
l_getCurrentTime(&start, NULL);
ntests = sizeof(tests) / sizeof(char *);
fprintf(stderr, "Running alltests_reg:\n"
"This currently tests %d of the 97 Regression Test\n"
"programs in the /prog directory.\n", ntests);
/* Clear the output file if we're doing the set of reg tests */
dotest = strcmp(argv[1], "compare") ? 0 : 1;
if (dotest) {
results_file = genPathname("/tmp", "reg_results.txt");
sa = sarrayCreate(3);
sarrayAddString(sa, (char *)header, L_COPY);
sarrayAddString(sa, getLeptonicaVersion(), L_INSERT);
sarrayAddString(sa, getImagelibVersions(), L_INSERT);
str = sarrayToString(sa, 1);
sarrayDestroy(&sa);
l_binaryWrite("/tmp/reg_results.txt", "w", str, strlen(str));
lept_free(str);
}
nfail = 0;
for (i = 0; i < ntests; i++) {
snprintf(command, sizeof(command) - 2, "./%s %s", tests[i], argv[1]);
ret = system(command);
if (ret) {
snprintf(buf, sizeof(buf), "Failed to complete %s\n", tests[i]);
if (dotest) {
l_binaryWrite("/tmp/reg_results.txt", "a", buf, strlen(buf));
nfail++;
}
else
fprintf(stderr, "%s", buf);
}
}
if (dotest) {
#ifndef _WIN32
snprintf(command, sizeof(command) - 2, "cat %s", results_file);
#else
snprintf(command, sizeof(command) - 2, "type \"%s\"", results_file);
#endif /* !_WIN32 */
lept_free(results_file);
ret = system(command);
fprintf(stderr, "Success in %d of %d *_reg programs (output matches"
" the \"golden\" files)\n", ntests - nfail, ntests);
}
l_getCurrentTime(&stop, NULL);
fprintf(stderr, "Time for all regression tests: %d sec\n", stop - start);
return 0;
}
