static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int widthSpec, heightSpec, cutoffSpec, typeSpec;
const char * type;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "width", OPT_UINT, &cmdlineP->width,
&widthSpec, 0);
OPTENT3(0, "height", OPT_UINT, &cmdlineP->height,
&heightSpec, 0);
OPTENT3(0, "cutoff", OPT_UINT, &cmdlineP->cutoff,
&cutoffSpec, 0);
OPTENT3(0, "type", OPT_STRING, &type,
&typeSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!widthSpec)
cmdlineP->width = 3;
if (!heightSpec)
cmdlineP->height = 3;
if (!cutoffSpec)
cmdlineP->cutoff = 250;
if (typeSpec) {
if (streq(type, "histogram_sort"))
cmdlineP->type = HISTOGRAM_SORT_MEDIAN;
else if (streq(type, "select"))
cmdlineP->type = SELECT_MEDIAN;
else
pm_error("Invalid value '%s' for -type. Valid values are "
"'histogram_sort' and 'select'", type);
} else
cmdlineP->type = MEDIAN_UNSPECIFIED;
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[1];
if (argc-1 > 1)
pm_error ("Too many arguments. The only argument is "
"the optional input file name");
}
}
static void
splitBox(boxVector const bv,
unsigned int * const boxesP,
unsigned int const bi,
tupletable2 const colorfreqtable,
unsigned int const depth,
enum methodForLargest const methodForLargest) {
/*----------------------------------------------------------------------------
Split Box 'bi' in the box vector bv (so that bv contains one more box
than it did as input). Split it so that each new box represents about
half of the pixels in the distribution given by 'colorfreqtable' for
the colors in the original box, but with distinct colors in each of the
two new boxes.
Assume the box contains at least two colors.
-----------------------------------------------------------------------------*/
unsigned int const boxStart = bv[bi].ind;
unsigned int const boxSize = bv[bi].colors;
unsigned int const sm = bv[bi].sum;
sample * minval; /* malloc'ed array */
sample * maxval; /* malloc'ed array */
unsigned int largestDimension;
/* number of the plane with the largest spread */
unsigned int medianIndex;
int lowersum;
/* Number of pixels whose value is "less than" the median */
MALLOCARRAY_NOFAIL(minval, depth);
MALLOCARRAY_NOFAIL(maxval, depth);
findBoxBoundaries(colorfreqtable, depth, boxStart, boxSize,
minval, maxval);
/* Find the largest dimension, and sort by that component. I have
included two methods for determining the "largest" dimension;
first by simply comparing the range in RGB space, and second by
transforming into luminosities before the comparison.
*/
switch (methodForLargest) {
case LARGE_NORM:
largestDimension = largestByNorm(minval, maxval, depth);
break;
case LARGE_LUM:
largestDimension = largestByLuminosity(minval, maxval, depth);
break;
}
/* TODO: I think this sort should go after creating a box,
not before splitting. Because you need the sort to use
the REP_CENTER_BOX method of choosing a color to
represent the final boxes
*/
/* Set the gross global variable 'compareplanePlane' as a
parameter to compareplane(), which is called by qsort().
*/
compareplanePlane = largestDimension;
qsort((char*) &colorfreqtable.table[boxStart], boxSize,
sizeof(colorfreqtable.table[boxStart]),
compareplane);
{
/* Now find the median based on the counts, so that about half
the pixels (not colors, pixels) are in each subdivision. */
unsigned int i;
lowersum = colorfreqtable.table[boxStart]->value; /* initial value */
for (i = 1; i < boxSize - 1 && lowersum < sm/2; ++i) {
lowersum += colorfreqtable.table[boxStart + i]->value;
}
medianIndex = i;
}
/* Split the box, and sort to bring the biggest boxes to the top. */
bv[bi].colors = medianIndex;
bv[bi].sum = lowersum;
bv[*boxesP].ind = boxStart + medianIndex;
bv[*boxesP].colors = boxSize - medianIndex;
bv[*boxesP].sum = sm - lowersum;
++(*boxesP);
qsort((char*) bv, *boxesP, sizeof(struct box), sumcompare);
free(minval); free(maxval);
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int floydOpt, atkinsonOpt, hilbertOpt, thresholdOpt, dither8Opt,
cluster3Opt, cluster4Opt, cluster8Opt;
unsigned int valueSpec, clumpSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "floyd", OPT_FLAG, NULL, &floydOpt, 0);
OPTENT3(0, "fs", OPT_FLAG, NULL, &floydOpt, 0);
OPTENT3(0, "atkinson", OPT_FLAG, NULL, &atkinsonOpt, 0);
OPTENT3(0, "threshold", OPT_FLAG, NULL, &thresholdOpt, 0);
OPTENT3(0, "hilbert", OPT_FLAG, NULL, &hilbertOpt, 0);
OPTENT3(0, "dither8", OPT_FLAG, NULL, &dither8Opt, 0);
OPTENT3(0, "d8", OPT_FLAG, NULL, &dither8Opt, 0);
OPTENT3(0, "cluster3", OPT_FLAG, NULL, &cluster3Opt, 0);
OPTENT3(0, "c3", OPT_FLAG, NULL, &cluster3Opt, 0);
OPTENT3(0, "cluster4", OPT_FLAG, NULL, &cluster4Opt, 0);
OPTENT3(0, "c4", OPT_FLAG, NULL, &cluster4Opt, 0);
OPTENT3(0, "cluster8", OPT_FLAG, NULL, &cluster8Opt, 0);
OPTENT3(0, "c8", OPT_FLAG, NULL, &cluster8Opt, 0);
OPTENT3(0, "value", OPT_FLOAT, &cmdlineP->threshval,
&valueSpec, 0);
OPTENT3(0, "clump", OPT_UINT, &cmdlineP->clumpSize,
&clumpSpec, 0);
OPTENT3(0, "randomseed", OPT_UINT, &cmdlineP->randomseed,
&cmdlineP->randomseedSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (floydOpt + atkinsonOpt + thresholdOpt + hilbertOpt + dither8Opt +
cluster3Opt + cluster4Opt + cluster8Opt == 0)
cmdlineP->halftone = QT_FS;
else if (floydOpt + atkinsonOpt + thresholdOpt + dither8Opt +
cluster3Opt + cluster4Opt + cluster8Opt > 1)
pm_error("Cannot specify more than one halftoning type");
else {
if (floydOpt)
cmdlineP->halftone = QT_FS;
else if (atkinsonOpt)
cmdlineP->halftone = QT_ATKINSON;
else if (thresholdOpt)
cmdlineP->halftone = QT_THRESH;
else if (hilbertOpt) {
cmdlineP->halftone = QT_HILBERT;
if (!clumpSpec)
cmdlineP->clumpSize = 5;
else {
if (cmdlineP->clumpSize < 2)
pm_error("-clump must be at least 2. You specified %u",
cmdlineP->clumpSize);
}
} else if (dither8Opt)
cmdlineP->halftone = QT_DITHER8;
else if (cluster3Opt) {
cmdlineP->halftone = QT_CLUSTER;
cmdlineP->clusterRadius = 3;
} else if (cluster4Opt) {
cmdlineP->halftone = QT_CLUSTER;
cmdlineP->clusterRadius = 4;
} else if (cluster8Opt) {
cmdlineP->halftone = QT_CLUSTER;
cmdlineP->clusterRadius = 8;
} else
pm_error("INTERNAL ERROR. No halftone option");
}
if (!valueSpec)
cmdlineP->threshval = 0.5;
else {
if (cmdlineP->threshval < 0.0)
pm_error("-value cannot be negative. You specified %f",
cmdlineP->threshval);
if (cmdlineP->threshval > 1.0)
pm_error("-value cannot be greater than one. You specified %f",
cmdlineP->threshval);
}
if (clumpSpec && cmdlineP->halftone != QT_HILBERT)
pm_error("-clump is not valid without -hilbert");
if (argc-1 > 1)
pm_error("Too many arguments (%d). There is at most one "
"non-option argument: the file name",
argc-1);
else if (argc-1 == 1)
cmdlineP->inputFilespec = argv[1];
else
cmdlineP->inputFilespec = "-";
}
static void
parseCommandLine(int argc, const char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int lvalSpec, rvalSpec, heightSpec;
unsigned int redSpec, greenSpec, blueSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "black", OPT_FLAG, NULL, &cmdlineP->black, 0);
OPTENT3(0, "white", OPT_FLAG, NULL, &cmdlineP->white, 0);
OPTENT3(0, "dots", OPT_FLAG, NULL, &cmdlineP->dots, 0);
OPTENT3(0, "red", OPT_FLAG, NULL, &redSpec, 0);
OPTENT3(0, "green", OPT_FLAG, NULL, &greenSpec, 0);
OPTENT3(0, "blue", OPT_FLAG, NULL, &blueSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "nmax", OPT_FLOAT, &cmdlineP->nmax,
&cmdlineP->nmaxSpec, 0);
OPTENT3(0, "lval", OPT_UINT, &cmdlineP->lval,
&lvalSpec, 0);
OPTENT3(0, "rval", OPT_UINT, &cmdlineP->rval,
&rvalSpec, 0);
OPTENT3(0, "width", OPT_UINT, &cmdlineP->width,
&cmdlineP->widthSpec, 0);
OPTENT3(0, "height", OPT_UINT, &cmdlineP->height,
&heightSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!lvalSpec)
cmdlineP->lval = 0;
if (!rvalSpec)
cmdlineP->rval = PNM_OVERALLMAXVAL;
if (!redSpec && !greenSpec && !blueSpec) {
cmdlineP->colorWanted[WANT_RED] = TRUE;
cmdlineP->colorWanted[WANT_GRN] = TRUE;
cmdlineP->colorWanted[WANT_BLU] = TRUE;
} else {
cmdlineP->colorWanted[WANT_RED] = redSpec;
cmdlineP->colorWanted[WANT_GRN] = greenSpec;
cmdlineP->colorWanted[WANT_BLU] = blueSpec;
}
if (!heightSpec)
cmdlineP->height = 200;
if (argc-1 == 0)
cmdlineP->inputFilespec = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %u", argc-1);
else
cmdlineP->inputFilespec = argv[1];
}
static void
parseCommandLine(int argc, const char ** const argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3() on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int leftright, topbottom, black, white, jtop, jbottom,
jleft, jright, jcenter;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "leftright", OPT_FLAG, NULL, &leftright, 0);
OPTENT3(0, "lr", OPT_FLAG, NULL, &leftright, 0);
OPTENT3(0, "topbottom", OPT_FLAG, NULL, &topbottom, 0);
OPTENT3(0, "tb", OPT_FLAG, NULL, &topbottom, 0);
OPTENT3(0, "black", OPT_FLAG, NULL, &black, 0);
OPTENT3(0, "white", OPT_FLAG, NULL, &white, 0);
OPTENT3(0, "jtop", OPT_FLAG, NULL, &jtop, 0);
OPTENT3(0, "jbottom", OPT_FLAG, NULL, &jbottom, 0);
OPTENT3(0, "jleft", OPT_FLAG, NULL, &jleft, 0);
OPTENT3(0, "jright", OPT_FLAG, NULL, &jright, 0);
OPTENT3(0, "jcenter", OPT_FLAG, NULL, &jcenter, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
free(option_def);
if (leftright + topbottom > 1)
pm_error("You may specify only one of -topbottom (-tb) and "
"-leftright (-lr)");
else if (leftright)
cmdlineP->orientation = LEFTRIGHT;
else if (topbottom)
cmdlineP->orientation = TOPBOTTOM;
else
pm_error("You must specify either -leftright or -topbottom");
if (black + white > 1)
pm_error("You may specify only one of -black and -white");
else if (black)
cmdlineP->backcolor = BACK_BLACK;
else if (white)
cmdlineP->backcolor = BACK_WHITE;
else
cmdlineP->backcolor = BACK_AUTO;
if (jtop + jbottom + jleft + jright + jcenter > 1)
pm_error("You may specify onlyone of -jtop, -jbottom, "
"-jleft, and -jright");
else {
switch (cmdlineP->orientation) {
case LEFTRIGHT:
if (jleft)
pm_error("-jleft is invalid with -leftright");
if (jright)
pm_error("-jright is invalid with -leftright");
if (jtop)
cmdlineP->justification = JUST_MIN;
else if (jbottom)
cmdlineP->justification = JUST_MAX;
else if (jcenter)
cmdlineP->justification = JUST_CENTER;
else
cmdlineP->justification = JUST_CENTER;
break;
case TOPBOTTOM:
if (jtop)
pm_error("-jtop is invalid with -topbottom");
if (jbottom)
pm_error("-jbottom is invalid with -topbottom");
if (jleft)
cmdlineP->justification = JUST_MIN;
else if (jright)
cmdlineP->justification = JUST_MAX;
else if (jcenter)
cmdlineP->justification = JUST_CENTER;
else
cmdlineP->justification = JUST_CENTER;
break;
}
}
if (argc-1 < 1) {
MALLOCARRAY_NOFAIL(cmdlineP->inputFilespec, 1);
cmdlineP->inputFilespec[0] = "-";
cmdlineP->nfiles = 1;
} else {
unsigned int i;
unsigned int stdinCt;
/* Number of input files user specified as Standard Input */
MALLOCARRAY_NOFAIL(cmdlineP->inputFilespec, argc-1);
for (i = 0, stdinCt = 0; i < argc-1; ++i) {
cmdlineP->inputFilespec[i] = argv[1+i];
if (streq(argv[1+i], "-"))
++stdinCt;
}
cmdlineP->nfiles = argc-1;
if (stdinCt > 1)
pm_error("At most one input image can come from Standard Input. "
"You specified %u", stdinCt);
}
}
static void
ppmTo16ColorPcx(pixel ** const pixels,
int const cols,
int const rows,
struct pcxCmapEntry const pcxcmap[],
int const colors,
colorhash_table const cht,
bool const packbits,
unsigned int const planesRequested,
unsigned int const xPos,
unsigned int const yPos) {
int Planes, BytesPerLine, BitsPerPixel;
unsigned char *indexRow; /* malloc'ed */
/* indexRow[x] is the palette index of the pixel at column x of
the row currently being processed
*/
unsigned char *planesrow; /* malloc'ed */
/* This is the input for a single row to the compressor */
int row;
if (packbits) {
Planes = 1;
if (colors > 4) BitsPerPixel = 4;
else if (colors > 2) BitsPerPixel = 2;
else BitsPerPixel = 1;
} else {
BitsPerPixel = 1;
if (planesRequested)
Planes = planesRequested;
else {
if (colors > 8) Planes = 4;
else if (colors > 4) Planes = 3;
else if (colors > 2) Planes = 2;
else Planes = 1;
}
}
BytesPerLine = ((cols * BitsPerPixel) + 7) / 8;
MALLOCARRAY_NOFAIL(indexRow, cols);
MALLOCARRAY_NOFAIL(planesrow, BytesPerLine);
write_header(stdout, cols, rows, BitsPerPixel, Planes, pcxcmap,
xPos, yPos);
for (row = 0; row < rows; ++row) {
int col;
for (col = 0; col < cols; ++col)
indexRow[col] = indexOfColor(cht, pixels[row][col]);
if (packbits) {
PackBits(indexRow, cols, planesrow, BitsPerPixel);
PCXEncode(stdout, planesrow, BytesPerLine);
} else {
unsigned int plane;
for (plane = 0; plane < Planes; ++plane) {
extractPlane(indexRow, cols, planesrow, plane);
PCXEncode(stdout, planesrow, BytesPerLine);
}
}
}
free(planesrow);
free(indexRow);
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdline_info *cmdlineP) {
unsigned int imagewidth_spec, imageheight_spec;
float imagewidth, imageheight;
unsigned int center, nocenter;
unsigned int nosetpage;
float width, height;
unsigned int noturn;
unsigned int showpage, noshowpage;
const char *dpiOpt;
unsigned int dpiSpec;
optStruct3 opt;
unsigned int option_def_index = 0;
optEntry *option_def;
MALLOCARRAY_NOFAIL(option_def, 100);
OPTENT3(0, "scale", OPT_FLOAT, &cmdlineP->scale, NULL, 0);
OPTENT3(0, "dpi", OPT_STRING, &dpiOpt, &dpiSpec, 0);
OPTENT3(0, "width", OPT_FLOAT, &width, NULL, 0);
OPTENT3(0, "height", OPT_FLOAT, &height, NULL, 0);
OPTENT3(0, "psfilter", OPT_FLAG, NULL, &cmdlineP->psfilter, 0);
OPTENT3(0, "turn", OPT_FLAG, NULL, &cmdlineP->mustturn, 0);
OPTENT3(0, "noturn", OPT_FLAG, NULL, ¬urn, 0);
OPTENT3(0, "rle", OPT_FLAG, NULL, &cmdlineP->rle, 0);
OPTENT3(0, "runlength", OPT_FLAG, NULL, &cmdlineP->rle, 0);
OPTENT3(0, "ascii85", OPT_FLAG, NULL, &cmdlineP->ascii85, 0);
OPTENT3(0, "center", OPT_FLAG, NULL, ¢er, 0);
OPTENT3(0, "nocenter", OPT_FLAG, NULL, &nocenter, 0);
OPTENT3(0, "equalpixels", OPT_FLAG, NULL, &cmdlineP->equalpixels, 0);
OPTENT3(0, "imagewidth", OPT_FLOAT, &imagewidth, &imagewidth_spec, 0);
OPTENT3(0, "imageheight", OPT_FLOAT, &imageheight, &imageheight_spec,0);
OPTENT3(0, "nosetpage", OPT_FLAG, NULL, &nosetpage, 0);
OPTENT3(0, "setpage", OPT_FLAG, NULL, &cmdlineP->setpage, 0);
OPTENT3(0, "noshowpage", OPT_FLAG, NULL, &noshowpage, 0);
OPTENT3(0, "flate", OPT_FLAG, NULL, &cmdlineP->flate, 0);
OPTENT3(0, "dict", OPT_FLAG, NULL, &cmdlineP->dict, 0);
OPTENT3(0, "vmreclaim", OPT_FLAG, NULL, &cmdlineP->vmreclaim, 0);
OPTENT3(0, "showpage", OPT_FLAG, NULL, &showpage, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "level", OPT_UINT, &cmdlineP->level,
&cmdlineP->levelSpec, 0);
/* DEFAULTS */
cmdlineP->scale = 1.0;
width = 8.5;
height = 11.0;
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = FALSE;
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (cmdlineP->mustturn && noturn)
pm_error("You cannot specify both -turn and -noturn");
if (center && nocenter)
pm_error("You cannot specify both -center and -nocenter");
if (showpage && noshowpage)
pm_error("You cannot specify both -showpage and -noshowpage");
if (cmdlineP->setpage && nosetpage)
pm_error("You cannot specify both -setpage and -nosetpage");
if (dpiSpec)
parse_dpi(dpiOpt, &cmdlineP->dpiX, &cmdlineP->dpiY);
else {
cmdlineP->dpiX = 300;
cmdlineP->dpiY = 300;
}
cmdlineP->center = !nocenter;
cmdlineP->canturn = !noturn;
cmdlineP->showpage = !noshowpage;
overflow2(width, 72);
cmdlineP->width = width * 72;
overflow2(width, 72);
cmdlineP->height = height * 72;
if (imagewidth_spec) {
overflow2(imagewidth, 72);
cmdlineP->imagewidth = imagewidth * 72;
}
else
cmdlineP->imagewidth = 0;
if (imageheight_spec) {
overflow2(imagewidth, 72);
cmdlineP->imageheight = imageheight * 72;
} else
cmdlineP->imageheight = 0;
if (!cmdlineP->psfilter &&
(cmdlineP->flate || cmdlineP->ascii85))
pm_error("You must specify -psfilter in order to specify "
"-flate or -ascii85");
if (cmdlineP->rle && cmdlineP->flate)
pm_error("You cannot specify both -rle and -flate");
if (argc-1 == 0)
cmdlineP->input_filespec = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->input_filespec = argv[1];
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int mapSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "map", OPT_STRING, &cmdlineP->map,
&mapSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!mapSpec)
cmdlineP->map = NULL;
if (mapSpec) {
/* No color argument; only argument is file name */
if (argc-1 < 1)
cmdlineP->inputFilename = "-";
else {
cmdlineP->inputFilename = argv[1];
if (argc-1 > 1)
pm_error("With -map option, there is at most one argument: "
"the file name. You specified %u", argc-1);
}
} else {
/* Arguments are color or color range and file name */
if (argc-1 < 1) {
cmdlineP->colorBlack = "black";
cmdlineP->colorWhite = "white";
} else {
char * buffer = strdup(argv[1]);
char * hyphenPos = strchr(buffer, '-');
if (hyphenPos) {
*hyphenPos = '\0';
cmdlineP->colorBlack = buffer;
cmdlineP->colorWhite = hyphenPos+1;
} else {
cmdlineP->colorBlack = "black";
cmdlineP->colorWhite = buffer;
}
}
if (argc-1 < 2)
cmdlineP->inputFilename = "-";
else
cmdlineP->inputFilename = argv[2];
if (argc-1 > 2)
pm_error("Program takes at most 2 arguments: "
"color name/range and input file name. "
"You specified %u", argc-1);
}
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo *cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int outputSpec, andpgms;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "output", OPT_STRING, &cmdlineP->output,
&outputSpec, 0);
OPTENT3(0, "andpgms", OPT_FLAG, NULL,
&andpgms, 0);
OPTENT3(0, "truetransparent", OPT_FLAG, NULL,
&cmdlineP->truetransparent, 0);
OPTENT3(0, "verbose", OPT_STRING, NULL,
&cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!outputSpec)
cmdlineP->output = "-";
if (!andpgms) {
if (argc-1 == 0) {
cmdlineP->iconCount = 1;
MALLOCARRAY_NOFAIL(cmdlineP->inputFilespec, cmdlineP->iconCount);
cmdlineP->inputFilespec[0] = "-";
} else {
unsigned int iconIndex;
cmdlineP->iconCount = argc-1;
MALLOCARRAY_NOFAIL(cmdlineP->inputFilespec, cmdlineP->iconCount);
for (iconIndex = 0; iconIndex < cmdlineP->iconCount; ++iconIndex)
cmdlineP->inputFilespec[iconIndex] = argv[iconIndex+1];
}
{
unsigned int iconIndex;
MALLOCARRAY_NOFAIL(cmdlineP->andpgmFilespec, cmdlineP->iconCount);
for (iconIndex = 0; iconIndex < cmdlineP->iconCount; ++iconIndex)
cmdlineP->andpgmFilespec[iconIndex] = NULL;
}
} else {
if (argc-1 < 2)
pm_error("with -andpgms, you must specify at least two "
"arguments: image file name and and mask file name. "
"You specified %d", argc-1);
else if ((argc-1)/2*2 != (argc-1))
pm_error("with -andpgms, you must specify an even number of "
"arguments. You specified %d", argc-1);
else {
unsigned int iconIndex;
cmdlineP->iconCount = (argc-1)/2;
MALLOCARRAY_NOFAIL(cmdlineP->inputFilespec, cmdlineP->iconCount);
MALLOCARRAY_NOFAIL(cmdlineP->andpgmFilespec, cmdlineP->iconCount);
for (iconIndex = 0; iconIndex < cmdlineP->iconCount; ++iconIndex) {
cmdlineP->inputFilespec[iconIndex] = argv[1 + iconIndex*2];
cmdlineP->andpgmFilespec[iconIndex] = argv[2 + iconIndex*2];
}
}
}
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo *cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
/* vars for the option parser */
optEntry * option_def;
optStruct3 opt;
unsigned int option_def_index = 0; /* incremented by OPTENT3 */
unsigned int thresholdSpec, localSpec, dualSpec, contrastSpec;
const char * localOpt;
const char * dualOpt;
MALLOCARRAY_NOFAIL(option_def, 100);
/* define the options */
OPTENT3(0, "simple", OPT_FLAG, NULL,
&cmdlineP->simple, 0);
OPTENT3(0, "local", OPT_STRING, &localOpt,
&localSpec, 0);
OPTENT3(0, "dual", OPT_STRING, &dualOpt,
&dualSpec, 0);
OPTENT3(0, "threshold", OPT_FLOAT, &cmdlineP->threshold,
&thresholdSpec, 0);
OPTENT3(0, "contrast", OPT_FLOAT, &cmdlineP->contrast,
&contrastSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
/* set the defaults */
cmdlineP->width = cmdlineP->height = 0U;
/* set the option description for pm_optParseOptions3 */
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* long options only */
opt.allowNegNum = FALSE; /* we have no numbers at all */
/* parse commandline, change argc, argv, and *cmdlineP */
pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (cmdlineP->simple + localSpec + dualSpec > 1)
pm_error("You may specify only one of -simple, -local, and -dual");
if (!thresholdSpec)
cmdlineP->threshold = 0.5;
/* 0 <= threshold <= 1 */
if ((cmdlineP->threshold < 0.0) || (cmdlineP->threshold > 1.0))
pm_error("threshold must be in [0,1]");
if (!contrastSpec)
cmdlineP->contrast = 0.05;
/* 0 <= contrast <= 1 */
if ((cmdlineP->contrast < 0.0) || (cmdlineP->contrast > 1.0))
pm_error("contrast must be in [0,1]");
if (localSpec) {
const char * error;
cmdlineP->local = TRUE;
parseGeometry(localOpt, &cmdlineP->width, &cmdlineP->height, &error);
if (error) {
pm_error("Invalid -local value '%s'. %s", localOpt, error);
pm_strfree(error);
}
} else
cmdlineP->local = FALSE;
if (dualSpec) {
const char * error;
cmdlineP->dual = TRUE;
parseGeometry(dualOpt, &cmdlineP->width, &cmdlineP->height, &error);
if (error) {
pm_error("Invalid -dual value '%s'. %s", dualOpt, error);
pm_strfree(error);
}
} else
cmdlineP->dual = FALSE;
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else if (argc-1 == 1)
cmdlineP->inputFileName = argv[1];
else
pm_error("Progam takes at most 1 parameter: the file name. "
"You specified %d", argc-1);
}
int
main(int argc, char **argv) {
struct cmdlineInfo cmdline;
FILE *vf,*uf,*yf;
int cols, rows;
pixel *pixelrow1,*pixelrow2;
int row;
unsigned char *y1buf,*y2buf,*ubuf,*vbuf;
const char * ufname;
const char * vfname;
const char * yfname;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
pm_asprintf(&ufname, "%s.U", cmdline.filenameBase);
pm_asprintf(&vfname, "%s.V", cmdline.filenameBase);
pm_asprintf(&yfname, "%s.Y", cmdline.filenameBase);
uf = pm_openr(ufname);
vf = pm_openr(vfname);
yf = pm_openr(yfname);
ppm_writeppminit(stdout, cmdline.width, cmdline.height, 255, 0);
if (cmdline.width % 2 != 0) {
pm_message("Warning: odd width; last column ignored");
cols = cmdline.width - 1;
} else
cols = cmdline.width;
if (cmdline.height % 2 != 0) {
pm_message("Warning: odd height; last row ignored");
rows = cmdline.height - 1;
} else
rows = cmdline.height;
pixelrow1 = ppm_allocrow(cols);
pixelrow2 = ppm_allocrow(cols);
MALLOCARRAY_NOFAIL(y1buf, cmdline.width);
MALLOCARRAY_NOFAIL(y2buf, cmdline.width);
MALLOCARRAY_NOFAIL(ubuf, cmdline.width/2);
MALLOCARRAY_NOFAIL(vbuf, cmdline.width/2);
for (row = 0; row < rows; row += 2) {
fread(y1buf, cmdline.width, 1, yf);
fread(y2buf, cmdline.width, 1, yf);
fread(ubuf, cmdline.width/2, 1, uf);
fread(vbuf, cmdline.width/2, 1, vf);
computeTwoOutputRows(cols, cmdline.ccir601,
y1buf, y2buf, ubuf, vbuf,
pixelrow1, pixelrow2);
ppm_writeppmrow(stdout, pixelrow1, cols, (pixval) 255, 0);
ppm_writeppmrow(stdout, pixelrow2, cols, (pixval) 255, 0);
}
pm_close(stdout);
pm_strfree(yfname);
pm_strfree(vfname);
pm_strfree(ufname);
pm_close(yf);
pm_close(uf);
pm_close(vf);
exit(0);
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Convert program invocation arguments (argc,argv) into a format the
program can use easily, struct cmdlineInfo. Validate arguments along
the way and exit program with message if invalid.
Note that some string information we return as *cmdlineP is in the storage
argv[] points to.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to OptParseOptions2 on how to parse our options.
*/
optStruct3 opt;
unsigned int tupletypeSpec, maxvalSpec, sigmaSpec;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "tupletype", OPT_STRING, &cmdlineP->tupletype,
&tupletypeSpec, 0);
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval,
&maxvalSpec, 0);
OPTENT3(0, "sigma", OPT_FLOAT, &cmdlineP->sigma,
&sigmaSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!tupletypeSpec)
cmdlineP->tupletype = "";
else {
struct pam pam;
if (strlen(cmdlineP->tupletype)+1 > sizeof(pam.tuple_type))
pm_error("The tuple type you specified is too long. "
"Maximum %d characters.", sizeof(pam.tuple_type)-1);
}
if (!sigmaSpec)
pm_error("You must specify the -sigma option.");
else if (cmdlineP->sigma <= 0.0)
pm_error("-sigma must be positive. You specified %f",
cmdlineP->sigma);
if (!maxvalSpec)
cmdlineP->maxval = PNM_MAXMAXVAL;
else {
if (cmdlineP->maxval > PNM_OVERALLMAXVAL)
pm_error("The maxval you specified (%u) is too big. "
"Maximum is %u", cmdlineP->maxval, PNM_OVERALLMAXVAL);
if (cmdlineP->maxval < 1)
pm_error("-maxval must be at least 1");
}
if (argc-1 < 2)
pm_error("Need two arguments: width and height.");
else if (argc-1 > 2)
pm_error("Only two argumeents allowed: with and height. "
"You specified %d", argc-1);
else {
cmdlineP->width = atoi(argv[1]);
cmdlineP->height = atoi(argv[2]);
if (cmdlineP->width <= 0)
pm_error("width argument must be a positive number. You "
"specified '%s'", argv[1]);
if (cmdlineP->height <= 0)
pm_error("height argument must be a positive number. You "
"specified '%s'", argv[2]);
}
}
static void
parseCommandLine (int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int spreadbrightness, spreadluminosity;
unsigned int center, meancolor, meanpixel;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "spreadbrightness", OPT_FLAG,
NULL, &spreadbrightness, 0);
OPTENT3(0, "spreadluminosity", OPT_FLAG,
NULL, &spreadluminosity, 0);
OPTENT3(0, "center", OPT_FLAG,
NULL, ¢er, 0);
OPTENT3(0, "meancolor", OPT_FLAG,
NULL, &meancolor, 0);
OPTENT3(0, "meanpixel", OPT_FLAG,
NULL, &meanpixel, 0);
OPTENT3(0, "sort", OPT_FLAG, NULL,
&cmdlineP->sort, 0 );
OPTENT3(0, "square", OPT_FLAG, NULL,
&cmdlineP->square, 0 );
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0 );
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
/* Uses and sets argc, argv, and some of *cmdline_p and others. */
if (spreadbrightness && spreadluminosity)
pm_error("You cannot specify both -spreadbrightness and "
"spreadluminosity.");
if (spreadluminosity)
cmdlineP->methodForLargest = LARGE_LUM;
else
cmdlineP->methodForLargest = LARGE_NORM;
if (center + meancolor + meanpixel > 1)
pm_error("You can specify only one of -center, -meancolor, and "
"-meanpixel.");
if (meancolor)
cmdlineP->methodForRep = REP_AVERAGE_COLORS;
else if (meanpixel)
cmdlineP->methodForRep = REP_AVERAGE_PIXELS;
else
cmdlineP->methodForRep = REP_CENTER_BOX;
if (argc-1 > 2)
pm_error("Program takes at most two arguments: number of colors "
"and input file specification. "
"You specified %d arguments.", argc-1);
else {
if (argc-1 < 2)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[2];
if (argc-1 < 1)
pm_error("You must specify the number of colors in the "
"output as an argument.");
else {
if (strcmp(argv[1], "all") == 0)
cmdlineP->allcolors = TRUE;
else {
char * tail;
long int const newcolors = strtol(argv[1], &tail, 10);
if (*tail != '\0')
pm_error("The number of colors argument '%s' is not "
"a number or 'all'", argv[1]);
else if (newcolors < 1)
pm_error("The number of colors must be positive");
else if (newcolors == 1)
pm_error("The number of colors must be greater than 1.");
else {
cmdlineP->newcolors = newcolors;
cmdlineP->allcolors = FALSE;
}
}
}
}
}
static void
parseCommandLine(int argc, char ** const argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "left", OPT_INT, &cmdlineP->left, NULL, 0);
OPTENT3(0, "right", OPT_INT, &cmdlineP->right, NULL, 0);
OPTENT3(0, "top", OPT_INT, &cmdlineP->top, NULL, 0);
OPTENT3(0, "bottom", OPT_INT, &cmdlineP->bottom, NULL, 0);
OPTENT3(0, "width", OPT_INT, &cmdlineP->width, NULL, 0);
OPTENT3(0, "height", OPT_INT, &cmdlineP->height, NULL, 0);
OPTENT3(0, "pad", OPT_FLAG, NULL, &cmdlineP->pad, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
/* Set the defaults */
cmdlineP->left = UNSPEC;
cmdlineP->right = UNSPEC;
cmdlineP->top = UNSPEC;
cmdlineP->bottom = UNSPEC;
cmdlineP->width = UNSPEC;
cmdlineP->height = UNSPEC;
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = TRUE; /* We may have parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (cmdlineP->width < 0)
pm_error("-width may not be negative.");
if (cmdlineP->height < 0)
pm_error("-height may not be negative.");
if ((argc-1) != 0 && (argc-1) != 1 && (argc-1) != 4 && (argc-1) != 5)
pm_error("Wrong number of arguments: %u. The only argument in "
"the preferred syntax is an optional input file name. "
"In older syntax, there are also forms with 4 and 5 "
"arguments.", argc-1);
switch (argc-1) {
case 0:
cmdlineP->inputFilespec = "-";
break;
case 1:
cmdlineP->inputFilespec = argv[1];
break;
case 4:
case 5: {
int warg, harg; /* The "width" and "height" command line arguments */
if (sscanf(argv[1], "%d", &cmdlineP->left) != 1)
pm_error("Invalid number for left column argument");
if (sscanf(argv[2], "%d", &cmdlineP->top) != 1)
pm_error("Invalid number for right column argument");
if (sscanf(argv[3], "%d", &warg) != 1)
pm_error("Invalid number for width argument");
if (sscanf(argv[4], "%d", &harg) != 1)
pm_error("Invalid number for height argument");
if (warg > 0) {
cmdlineP->width = warg;
cmdlineP->right = UNSPEC;
} else {
cmdlineP->width = UNSPEC;
cmdlineP->right = warg -1;
}
if (harg > 0) {
cmdlineP->height = harg;
cmdlineP->bottom = UNSPEC;
} else {
cmdlineP->height = UNSPEC;
cmdlineP->bottom = harg - 1;
}
if (argc-1 == 4)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[5];
break;
}
}
}
static void
parseCommandLine (int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int widthSpec, heightSpec, dumpSpec, sizeSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "dump", OPT_STRING,
&cmdlineP->dump, &dumpSpec, 0);
OPTENT3(0, "width", OPT_UINT,
&cmdlineP->width, &widthSpec, 0);
OPTENT3(0, "height", OPT_UINT,
&cmdlineP->height, &heightSpec, 0);
OPTENT3(0, "size", OPT_FLAG,
NULL, &sizeSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
/* Uses and sets argc, argv, and some of *cmdline_p and others. */
if (!widthSpec)
cmdlineP->width = 3;
if (!heightSpec)
cmdlineP->height = 3;
if (!dumpSpec)
cmdlineP->dump = NULL;
if (sizeSpec) {
/* -size is strictly for backward compatibility. This program
used to use a different command line processor and had
irregular syntax in which the -size option had two values,
e.g. "-size <width> <height>" And the options had to go
before the arguments. So an old pnmsmooth command looks to us
like a command with the -size flag option and the first two
arguments being the width and height.
*/
if (widthSpec || heightSpec)
pm_error("-size is obsolete. Use -width and -height instead");
if (argc-1 > 3)
pm_error("Too many arguments. With -size, there are at most "
"3 arguments.");
else if (argc-1 < 2)
pm_error("Not enough arguments. With -size, the first two "
"arguments are width and height");
else {
cmdlineP->width = atoi(argv[1]);
cmdlineP->height = atoi(argv[2]);
if (argc-1 < 3)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[3];
}
} else {
if (argc-1 > 1)
pm_error("Program takes at most one argument: the input file "
"specification. "
"You specified %d arguments.", argc-1);
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[1];
}
if (cmdlineP->width % 2 != 1)
pm_error("The convolution matrix must have an odd number of columns. "
"You specified %u", cmdlineP->width);
if (cmdlineP->height % 2 != 1)
pm_error("The convolution matrix must have an odd number of rows. "
"You specified %u", cmdlineP->height);
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo *cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int patfileSpec, dpiSpec, eyesepSpec, depthSpec,
guidesizeSpec, magnifypatSpec, xshiftSpec, yshiftSpec, randomseedSpec;
unsigned int blackandwhite, grayscale, color;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "verbose", OPT_FLAG, NULL,
(unsigned int *)&cmdlineP->verbose, 0);
OPTENT3(0, "crosseyed", OPT_FLAG, NULL,
&cmdlineP->crosseyed, 0);
OPTENT3(0, "makemask", OPT_FLAG, NULL,
&cmdlineP->makemask, 0);
OPTENT3(0, "blackandwhite", OPT_FLAG, NULL,
&blackandwhite, 0);
OPTENT3(0, "grayscale", OPT_FLAG, NULL,
&grayscale, 0);
OPTENT3(0, "color", OPT_FLAG, NULL,
&color, 0);
OPTENT3(0, "dpi", OPT_UINT, &cmdlineP->dpi,
&dpiSpec, 0);
OPTENT3(0, "eyesep", OPT_FLOAT, &cmdlineP->eyesep,
&eyesepSpec, 0);
OPTENT3(0, "depth", OPT_FLOAT, &cmdlineP->depth,
&depthSpec, 0);
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval,
&cmdlineP->maxvalSpec, 0);
OPTENT3(0, "guidesize", OPT_INT, &cmdlineP->guidesize,
&guidesizeSpec, 0);
OPTENT3(0, "magnifypat", OPT_UINT, &cmdlineP->magnifypat,
&magnifypatSpec, 0);
OPTENT3(0, "xshift", OPT_UINT, &cmdlineP->xshift,
&xshiftSpec, 0);
OPTENT3(0, "yshift", OPT_UINT, &cmdlineP->yshift,
&yshiftSpec, 0);
OPTENT3(0, "patfile", OPT_STRING, &cmdlineP->patFilespec,
&patfileSpec, 0);
OPTENT3(0, "randomseed", OPT_UINT, &cmdlineP->randomseed,
&randomseedSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (blackandwhite + grayscale + color == 0)
cmdlineP->outputType = OUTPUT_BW;
else if (blackandwhite + grayscale + color > 1)
pm_error("You may specify only one of -blackandwhite, -grayscale, "
"and -color");
else {
if (blackandwhite)
cmdlineP->outputType = OUTPUT_BW;
else if (grayscale)
cmdlineP->outputType = OUTPUT_GRAYSCALE;
else {
assert(color);
cmdlineP->outputType = OUTPUT_COLOR;
}
}
if (!patfileSpec)
cmdlineP->patFilespec = NULL;
if (!dpiSpec)
cmdlineP->dpi = 96;
else if (cmdlineP->dpi < 1)
pm_error("The argument to -dpi must be a positive integer");
if (!eyesepSpec)
cmdlineP->eyesep = 2.5;
else if (cmdlineP->eyesep <= 0.0)
pm_error("The argument to -eyesep must be a positive number");
if (!depthSpec)
cmdlineP->depth = (1.0/3.0);
else if (cmdlineP->depth < 0.0 || cmdlineP->depth > 1.0)
pm_error("The argument to -depth must be a number from 0.0 to 1.0");
if (cmdlineP->maxvalSpec) {
if (cmdlineP->maxval < 1)
pm_error("-maxval must be at least 1");
else if (cmdlineP->maxval > PNM_OVERALLMAXVAL)
pm_error("-maxval must be at most %u. You specified %u",
PNM_OVERALLMAXVAL, cmdlineP->maxval);
}
if (!guidesizeSpec)
cmdlineP->guidesize = 0;
if (!magnifypatSpec)
cmdlineP->magnifypat = 1;
else if (cmdlineP->magnifypat < 1)
pm_error("The argument to -magnifypat must be a positive integer");
if (!xshiftSpec)
cmdlineP->xshift = 0;
if (!yshiftSpec)
cmdlineP->yshift = 0;
if (!randomseedSpec)
cmdlineP->randomseed = time(NULL);
if (xshiftSpec && !cmdlineP->patFilespec)
pm_error("-xshift is valid only with -patfile");
if (yshiftSpec && !cmdlineP->patFilespec)
pm_error("-yshift is valid only with -patfile");
if (cmdlineP->makemask && cmdlineP->patFilespec)
pm_error("You may not specify both -makemask and -patfile");
if (cmdlineP->patFilespec && blackandwhite)
pm_error("-blackandwhite is not valid with -patfile");
if (cmdlineP->patFilespec && grayscale)
pm_error("-grayscale is not valid with -patfile");
if (cmdlineP->patFilespec && color)
pm_error("-color is not valid with -patfile");
if (cmdlineP->patFilespec && cmdlineP->maxvalSpec)
pm_error("-maxval is not valid with -patfile");
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else if (argc-1 == 1)
cmdlineP->inputFilespec = argv[1];
else
pm_error("Too many non-option arguments: %d. Only argument is "
"input file name", argc-1);
}
static void
parseCommandLine(int argc, const char ** argv,
struct CmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options. */
optStruct3 opt;
unsigned int dataSpec, headerSpec, prefixSpec, qualitySpec;
unsigned int option_def_index;
unsigned int i;
unsigned int q[10];
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3( 0, "data", OPT_STRING, &cmdlineP->data, &dataSpec, 0);
OPTENT3( 0, "header", OPT_STRING, &cmdlineP->header, &headerSpec, 0);
OPTENT3('q', "quality", OPT_UINT, &cmdlineP->quality, &qualitySpec, 0);
OPTENT3('p', "prefix", OPT_STRING, &cmdlineP->prefix, &prefixSpec, 0);
OPTENT3('0', "0", OPT_FLAG, NULL, &q[0], 0);
OPTENT3('1', "1", OPT_FLAG, NULL, &q[1], 0);
OPTENT3('2', "2", OPT_FLAG, NULL, &q[2], 0);
OPTENT3('3', "3", OPT_FLAG, NULL, &q[3], 0);
OPTENT3('4', "4", OPT_FLAG, NULL, &q[4], 0);
OPTENT3('5', "5", OPT_FLAG, NULL, &q[5], 0);
OPTENT3('6', "6", OPT_FLAG, NULL, &q[6], 0);
OPTENT3('7', "7", OPT_FLAG, NULL, &q[7], 0);
OPTENT3('8', "8", OPT_FLAG, NULL, &q[8], 0);
OPTENT3('9', "9", OPT_FLAG, NULL, &q[9], 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = FALSE;
pm_optParseOptions3(&argc, (char**)argv, opt, sizeof(opt), 0);
free(option_def);
if (!dataSpec)
cmdlineP->data = NULL;
if (!headerSpec)
cmdlineP->header = NULL;
if (!prefixSpec)
cmdlineP->prefix = "";
if (!qualitySpec)
cmdlineP->quality = 200;
/* cmdlineP->quality2 is the greatest number from the --1, --2, etc.
options, or 5 if none of those are specified.
*/
cmdlineP->quality2 = 5; /* initial value */
for (i = 0; i < 10; ++i) {
if (q[i])
cmdlineP->quality2 = i;
}
cmdlineP->nFiles = argc-1;
MALLOCARRAY_NOFAIL(cmdlineP->inFileName, argc-1);
for (i = 0; i < argc-1; ++i) {
if (cmdlineP->data && strchr(argv[i+1], ':'))
pm_error("Filename '%s' contains a \":\", which is forbidden "
"with -data", argv[i+1]);
else
cmdlineP->inFileName[i] = strdup(argv[i+1]);
}
}
static void
parseCommandLine (int argc, const char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int scriptSpec, scriptfileSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "script", OPT_STRING, &cmdlineP->script,
&scriptSpec, 0);
OPTENT3(0, "scriptfile", OPT_STRING, &cmdlineP->scriptfile,
&scriptfileSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!scriptSpec && !scriptfileSpec)
pm_error("You must specify either -script or -scriptfile");
if (scriptSpec && scriptfileSpec)
pm_error("You may not specify both -script and -scriptfile");
if (!scriptSpec)
cmdlineP->script = NULL;
if (!scriptfileSpec)
cmdlineP->scriptfile = NULL;
if (argc-1 < 1) {
if (cmdlineP->scriptfile && strcmp(cmdlineP->scriptfile, "-") == 0)
pm_error("You can't specify Standard Input for both the "
"input image and the script file");
else
cmdlineP->inputFilename = "-";
}
else if (argc-1 == 1)
cmdlineP->inputFilename = argv[1];
else
pm_error("Program takes at most one argument: input file name");
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
Note that many of the strings that this function returns in the
*cmdlineP structure are actually in the supplied argv array. And
sometimes, one of these strings is actually just a suffix of an entry
in argv!
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options. */
optStruct3 opt;
unsigned int option_def_index;
const char * colorOpt;
unsigned int colorSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "color", OPT_STRING, &colorOpt, &colorSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and all of *cmdlineP. */
if (colorSpec)
parseColorOpt(colorOpt, cmdlineP);
if (colorSpec) {
if (argc-1 < 1)
cmdlineP->inputFilename = "-"; /* he wants stdin */
else if (argc-1 == 1)
cmdlineP->inputFilename = argv[1];
else
pm_error("Too many arguments. When you specify -color, "
"the only argument accepted is the optional input "
"file name.");
} else {
if (argc-1 < 1)
pm_error("You must specify the -color option.");
else {
cmdlineP->colorCount = 1;
cmdlineP->maskColor[0].matchType = MATCH_EXACT;
cmdlineP->maskColor[0].u.color =
ppm_parsecolor(argv[1], PPM_MAXMAXVAL);
if (argc - 1 < 2)
cmdlineP->inputFilename = "-"; /* he wants stdin */
else if (argc-1 == 2)
cmdlineP->inputFilename = argv[2];
else
pm_error("Too many arguments. The only arguments accepted "
"are the mask color and optional input file name");
}
}
}
int
main(int argc,
const char ** argv) {
struct cmdlineInfo cmdline;
struct imgInfo * img; /* malloc'ed array */
xelval newmaxval;
int newformat;
unsigned int i;
unsigned int newrows, newcols;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
MALLOCARRAY_NOFAIL(img, cmdline.nfiles);
for (i = 0; i < cmdline.nfiles; ++i) {
img[i].ifP = pm_openr(cmdline.inputFilespec[i]);
pnm_readpnminit(img[i].ifP, &img[i].cols, &img[i].rows,
&img[i].maxval, &img[i].format);
}
computeOutputParms(cmdline.nfiles, cmdline.orientation, img,
&newcols, &newrows, &newmaxval, &newformat);
pnm_writepnminit(stdout, newcols, newrows, newmaxval, newformat, 0);
if (PNM_FORMAT_TYPE(newformat) == PBM_TYPE) {
switch (cmdline.orientation) {
case LEFTRIGHT:
concatenateLeftRightPbm(stdout, cmdline.nfiles,
newcols, newrows, cmdline.justification,
img, cmdline.backcolor);
break;
case TOPBOTTOM:
concatenateTopBottomPbm(stdout, cmdline.nfiles,
newcols, newrows, cmdline.justification,
img, cmdline.backcolor);
break;
}
} else {
switch (cmdline.orientation) {
case LEFTRIGHT:
concatenateLeftRightGen(stdout, cmdline.nfiles,
newcols, newrows, newmaxval, newformat,
cmdline.justification, img,
cmdline.backcolor);
break;
case TOPBOTTOM:
concatenateTopBottomGen(stdout, cmdline.nfiles,
newcols, newrows, newmaxval, newformat,
cmdline.justification, img,
cmdline.backcolor);
break;
}
}
for (i = 0; i < cmdline.nfiles; ++i)
pm_close(img[i].ifP);
free(cmdline.inputFilespec);
free(img);
pm_close(stdout);
return 0;
}
static void
parseCommandLine(int argc, char ** const argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def; /* malloc'ed */
/* Instructions to OptParseOptions3 on how to parse our options. */
optStruct3 opt;
unsigned int option_def_index;
unsigned int widthSpec, paper_sizeSpec;
const char * paperSize;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "reversebits", OPT_FLAG, NULL, &cmdlineP->reversebits,
0);
OPTENT3(0, "kludge", OPT_FLAG, NULL, &cmdlineP->kludge,
0);
OPTENT3(0, "stretch", OPT_FLAG, NULL, &cmdlineP->stretch,
0);
OPTENT3(0, "stop_error", OPT_FLAG, NULL, &cmdlineP->stop_error,
0);
OPTENT3(0, "width", OPT_UINT, &cmdlineP->expectedLineSize,
&widthSpec, 0);
OPTENT3(0, "paper_size", OPT_STRING, &paperSize,
&paper_sizeSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (widthSpec && paper_sizeSpec)
pm_error("You can't specify both -width and -paper_size");
if (widthSpec) {
if (cmdlineP->expectedLineSize < 1)
pm_error("-width must be at least 1");
} else if (paper_sizeSpec) {
if (strcaseeq(paperSize, "A6"))
cmdlineP->expectedLineSize = 864;
else if (strcaseeq(paperSize, "A5"))
cmdlineP->expectedLineSize = 1216;
else if (strcaseeq(paperSize, "A4"))
cmdlineP->expectedLineSize = 1728;
else if (strcaseeq(paperSize, "B4"))
cmdlineP->expectedLineSize = 2048;
else if (strcaseeq(paperSize, "A3"))
cmdlineP->expectedLineSize = 2432;
else
pm_error("Unrecognized value for -paper_size '%s'. "
"We recognize only A3, A4, A5, A6, and B4.",
paperSize);
} else
cmdlineP->expectedLineSize = 0;
if (argc-1 == 0)
cmdlineP->inputFilespec = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->inputFilespec = argv[1];
}
static void
makePcxColormapFromImage(pixel ** const pixels,
int const cols,
int const rows,
pixval const maxval,
struct pcxCmapEntry ** const pcxcmapP,
colorhash_table * const chtP,
int * const colorsP,
bool * const tooManyColorsP) {
/*----------------------------------------------------------------------------
Make a colormap (palette) for the PCX header that can be used
for the image described by 'pixels', 'cols', 'rows', and 'maxval'.
Return it in newly malloc'ed storage and return its address as
*pcxcmapP.
Also return a lookup hash to relate a color in the image to the
appropriate index in *pcxcmapP. Return that in newly malloc'ed
storage as *chtP.
Iff there are too many colors to do that (i.e. more than 256),
return *tooManyColorsP == TRUE.
-----------------------------------------------------------------------------*/
int colors;
colorhist_vector chv;
pm_message("computing colormap...");
chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &colors);
if (chv == NULL)
*tooManyColorsP = TRUE;
else {
int i;
struct pcxCmapEntry * pcxcmap;
*tooManyColorsP = FALSE;
pm_message("%d colors found", colors);
moveBlackToIndex0(chv, colors);
MALLOCARRAY_NOFAIL(pcxcmap, MAXCOLORS);
*pcxcmapP = pcxcmap;
for (i = 0; i < colors; ++i) {
pixel p;
PPM_DEPTH(p, chv[i].color, maxval, PCX_MAXVAL);
pcxcmap[i].r = PPM_GETR(p);
pcxcmap[i].g = PPM_GETG(p);
pcxcmap[i].b = PPM_GETB(p);
}
/* Fill it out with black */
for ( ; i < MAXCOLORS; ++i) {
pcxcmap[i].r = 0;
pcxcmap[i].g = 0;
pcxcmap[i].b = 0;
}
*chtP = ppm_colorhisttocolorhash(chv, colors);
*colorsP = colors;
ppm_freecolorhist(chv);
}
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo * const cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
char *align, *valign;
unsigned int xoffSpec, yoffSpec, alignSpec, valignSpec, opacitySpec,
alphaSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "invert", OPT_FLAG, NULL,
&cmdlineP->alphaInvert, 0);
OPTENT3(0, "xoff", OPT_INT, &cmdlineP->xoff,
&xoffSpec, 0);
OPTENT3(0, "yoff", OPT_INT, &cmdlineP->yoff,
&yoffSpec, 0);
OPTENT3(0, "opacity", OPT_FLOAT, &cmdlineP->opacity,
&opacitySpec, 0);
OPTENT3(0, "alpha", OPT_STRING, &cmdlineP->alphaFilespec,
&alphaSpec, 0);
OPTENT3(0, "align", OPT_STRING, &align,
&alignSpec, 0);
OPTENT3(0, "valign", OPT_STRING, &valign,
&valignSpec, 0);
OPTENT3(0, "linear", OPT_FLAG, NULL,
&cmdlineP->linear, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!xoffSpec)
cmdlineP->xoff = 0;
if (!yoffSpec)
cmdlineP->yoff = 0;
if (!alphaSpec)
cmdlineP->alphaFilespec = NULL;
if (alignSpec) {
if (strcasecmp(align, "BEYONDLEFT") == 0)
cmdlineP->align = BEYONDLEFT;
else if (strcasecmp(align, "LEFT") == 0)
cmdlineP->align = LEFT;
else if (strcasecmp(align, "CENTER") == 0)
cmdlineP->align = CENTER;
else if (strcasecmp(align, "RIGHT") == 0)
cmdlineP->align = RIGHT;
else if (strcasecmp(align, "BEYONDRIGHT") == 0)
cmdlineP->align = BEYONDRIGHT;
else
pm_error("Invalid value for align option: '%s'. Only LEFT, "
"RIGHT, CENTER, BEYONDLEFT, and BEYONDRIGHT are valid.",
align);
} else
cmdlineP->align = LEFT;
if (valignSpec) {
if (strcasecmp(valign, "ABOVE") == 0)
cmdlineP->valign = ABOVE;
else if (strcasecmp(valign, "TOP") == 0)
cmdlineP->valign = TOP;
else if (strcasecmp(valign, "MIDDLE") == 0)
cmdlineP->valign = MIDDLE;
else if (strcasecmp(valign, "BOTTOM") == 0)
cmdlineP->valign = BOTTOM;
else if (strcasecmp(valign, "BELOW") == 0)
cmdlineP->valign = BELOW;
else
pm_error("Invalid value for valign option: '%s'. Only TOP, "
"BOTTOM, MIDDLE, ABOVE, and BELOW are valid.",
align);
} else
cmdlineP->valign = TOP;
if (!opacitySpec)
cmdlineP->opacity = 1.0;
if (argc-1 < 1)
pm_error("Need at least one argument: file specification of the "
"overlay image.");
cmdlineP->overlayFilespec = argv[1];
if (argc-1 >= 2)
cmdlineP->underlyingFilespec = argv[2];
else
cmdlineP->underlyingFilespec = "-";
if (argc-1 >= 3)
cmdlineP->outputFilespec = argv[3];
else
cmdlineP->outputFilespec = "-";
if (argc-1 > 3)
pm_error("Too many arguments. Only acceptable arguments are: "
"overlay image, underlying image, output image");
}
static struct converter
createClusterConverter(struct pam * const graypamP,
enum ditherType const ditherType,
unsigned int const radius) {
/* TODO: We create a floating point normalized, gamma-adjusted
dither matrix from the old integer dither matrices that were
developed for use with integer arithmetic. We really should
just change the literal values in dither.h instead of computing
the matrix from the integer literal values here.
*/
int const clusterNormalizer = radius * radius * 2;
unsigned int const diameter = 2 * radius;
struct converter converter;
struct clusterState * stateP;
unsigned int row;
converter.cols = graypamP->width;
converter.convertRow = &clusterConvertRow;
converter.destroy = &clusterDestroy;
MALLOCVAR_NOFAIL(stateP);
stateP->radius = radius;
MALLOCARRAY_NOFAIL(stateP->clusterMatrix, diameter);
for (row = 0; row < diameter; ++row) {
unsigned int col;
MALLOCARRAY_NOFAIL(stateP->clusterMatrix[row], diameter);
for (col = 0; col < diameter; ++col) {
switch (ditherType) {
case DT_REGULAR:
switch (radius) {
case 8:
stateP->clusterMatrix[row][col] =
pm_gamma709((float)dither8[row][col] / 256);
break;
default:
pm_error("INTERNAL ERROR: invalid radius");
}
break;
case DT_CLUSTER: {
int val;
switch (radius) {
case 3: val = cluster3[row][col]; break;
case 4: val = cluster4[row][col]; break;
case 8: val = cluster8[row][col]; break;
default:
pm_error("INTERNAL ERROR: invalid radius");
}
stateP->clusterMatrix[row][col] =
pm_gamma709((float)val / clusterNormalizer);
}
break;
}
}
}
converter.stateP = stateP;
return converter;
}
int
main(int argc, char **argv) {
struct cmdlineInfo cmdline;
FILE * ifP;
tuplen ** tuplenarray;
struct pam inpam;
struct pam mappam;
tuple ** map;
int row;
float * sharpness;
pnm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFilespec);
tuplenarray = pnm_readpamn(ifP, &inpam, sizeof(inpam));
mappam = inpam;
mappam.file = stdout;
mappam.maxval = 255;
MALLOCARRAY_NOFAIL(sharpness, inpam.depth);
map = pnm_allocpamarray(&mappam);
makeBlackRown(&inpam, tuplenarray[0]);
for (row = 1; row < inpam.height-1; ++row) {
int col;
makeBlackTuplen(&inpam, tuplenarray[row][0]);
for (col = 1; col < inpam.width-1; ++col) {
int dy;
unsigned int plane;
for (plane = 0; plane < inpam.depth; ++plane)
sharpness[plane] = 0.0;
for (dy = -1; dy <= 1; ++dy) {
int dx;
for (dx = -1; dx <= 1; ++dx) {
if (dx != 0 || dy != 0) {
unsigned int plane;
for (plane = 0; plane < inpam.depth; ++plane) {
samplen const sampleval =
tuplenarray[row][col][plane];
samplen const sampleval2 =
tuplenarray[row+dy][col+dx][plane];
sharpness[plane] += fabs(sampleval - sampleval2);
}
}
}
}
makeSharpnessPixel(&mappam, sharpness, map[row][col]);
}
makeBlackTuplen(&inpam, tuplenarray[row][inpam.width-1]);
}
makeBlackRown(&inpam, tuplenarray[inpam.height-1]);
free(sharpness);
pnm_writepam(&mappam, map);
pnm_freepamarray(map, &mappam);
pnm_freepamarrayn(tuplenarray, &inpam);
return 0;
}
static void
parseCommandLine(int argc, const char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "font", OPT_STRING, &cmdlineP->font, NULL, 0);
OPTENT3(0, "builtin", OPT_STRING, &cmdlineP->builtin, NULL, 0);
OPTENT3(0, "dump", OPT_FLAG, NULL, &cmdlineP->dump, 0);
OPTENT3(0, "space", OPT_FLOAT, &cmdlineP->space, NULL, 0);
OPTENT3(0, "width", OPT_UINT, &cmdlineP->width, NULL, 0);
OPTENT3(0, "lspace", OPT_INT, &cmdlineP->lspace, NULL, 0);
OPTENT3(0, "nomargins", OPT_FLAG, NULL, &cmdlineP->nomargins, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
/* Set the defaults */
cmdlineP->font = NULL;
cmdlineP->builtin = NULL;
cmdlineP->space = 0.0;
cmdlineP->width = 0;
cmdlineP->lspace = 0;
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 == 0)
cmdlineP->text = NULL;
else {
char *text;
int i;
int totaltextsize;
totaltextsize = 1; /* initial value */
text = malloc(totaltextsize); /* initial allocation */
text[0] = '\0';
for (i = 1; i < argc; ++i) {
if (i > 1) {
totaltextsize += 1;
text = realloc(text, totaltextsize);
if (text == NULL)
pm_error("out of memory allocating space for input text");
strcat(text, " ");
}
totaltextsize += strlen(argv[i]);
text = realloc(text, totaltextsize);
if (text == NULL)
pm_error("out of memory allocating space for input text");
strcat(text, argv[i]);
}
cmdlineP->text = text;
}
}
static void
createRowCutter(const struct pam * const inpamP,
const struct pam * const outpamP,
int const leftcol,
int const rightcol,
struct rowCutter ** const rowCutterPP) {
struct rowCutter * rowCutterP;
tuple * inputPointers;
tuple * outputPointers;
tuple * copyTuples;
tuple blackTuple;
tuple discardTuple;
int col;
assert(inpamP->depth >= outpamP->depth);
/* Entry condition. If this weren't true, we could not simply
treat an input tuple as an output tuple.
*/
copyTuples = pnm_allocpamrow(outpamP);
discardTuple = pnm_allocpamtuple(inpamP);
pnm_createBlackTuple(outpamP, &blackTuple);
MALLOCARRAY_NOFAIL(inputPointers, inpamP->width);
MALLOCARRAY_NOFAIL(outputPointers, outpamP->width);
/* Put in left padding */
for (col = leftcol; col < 0 && col-leftcol < outpamP->width; ++col)
outputPointers[col-leftcol] = blackTuple;
/* Put in extracted columns */
for (col = MAX(leftcol, 0);
col <= MIN(rightcol, inpamP->width-1);
++col) {
int const outcol = col - leftcol;
inputPointers[col] = outputPointers[outcol] = copyTuples[outcol];
}
/* Put in right padding */
for (col = MIN(rightcol, inpamP->width-1) + 1; col <= rightcol; ++col) {
if (col - leftcol >= 0) {
outputPointers[col-leftcol] = blackTuple;
}
}
/* Direct input pixels that are getting cut off to the discard tuple */
for (col = 0; col < MIN(leftcol, inpamP->width); ++col)
inputPointers[col] = discardTuple;
for (col = MAX(0, rightcol + 1); col < inpamP->width; ++col)
inputPointers[col] = discardTuple;
MALLOCVAR_NOFAIL(rowCutterP);
rowCutterP->inputWidth = inpamP->width;
rowCutterP->outputWidth = outpamP->width;
rowCutterP->inputPointers = inputPointers;
rowCutterP->outputPointers = outputPointers;
rowCutterP->copyTuples = copyTuples;
rowCutterP->discardTuple = discardTuple;
rowCutterP->blackTuple = blackTuple;
*rowCutterPP = rowCutterP;
}
static void
parseCommandLine(int argc, const char **argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Convert program invocation arguments (argc,argv) into a format the
program can use easily, struct cmdlineInfo. Validate arguments along
the way and exit program with message if invalid.
Note that some string information we return as *cmdlineP is in the storage
argv[] points to.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int maxvalSpec;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0;
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval, &maxvalSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!maxvalSpec)
cmdlineP->maxval = 255;
else {
if (cmdlineP->maxval > PAM_OVERALL_MAXVAL)
pm_error("The value you specified for -maxval (%u) is too big. "
"Max allowed is %u", cmdlineP->maxval,
PAM_OVERALL_MAXVAL);
if (cmdlineP->maxval < 1)
pm_error("You cannot specify 0 for -maxval");
}
if (argc-1 != 6) {
pm_error("Need 6 arguments: colorTopLeft, colorTopRight, "
"colorBottomLeft, colorBottomRight, width, height");
} else {
cmdlineP->colorTopLeft = pnm_parsecolor(argv[1], cmdlineP->maxval);
cmdlineP->colorTopRight = pnm_parsecolor(argv[2], cmdlineP->maxval);
cmdlineP->colorBottomLeft = pnm_parsecolor(argv[3], cmdlineP->maxval);
cmdlineP->colorBottomRight = pnm_parsecolor(argv[4], cmdlineP->maxval);
cmdlineP->cols = atoi(argv[5]);
cmdlineP->rows = atoi(argv[6]);
if (cmdlineP->cols <= 0)
pm_error("width argument must be a positive number. You "
"specified '%s'", argv[5]);
if (cmdlineP->rows <= 0)
pm_error("height argument must be a positive number. You "
"specified '%s'", argv[6]);
}
}
static void
parseCommandLine(int argc,
const char ** const argv,
CmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
optStruct3 opt;
unsigned int none, packbits, lzw, g3, g4, msb2lsb, lsb2msb, opt_2d, fill;
unsigned int flate, adobeflate;
char * indexbits;
char * resolutionunit;
unsigned int appendSpec, outputSpec, predictorSpec, rowsperstripSpec,
xresolutionSpec, yresolutionSpec, indexbitsSpec,
resolutionunitSpec, tagSpec;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "none", OPT_FLAG, NULL, &none, 0);
OPTENT3(0, "packbits", OPT_FLAG, NULL, &packbits, 0);
OPTENT3(0, "lzw", OPT_FLAG, NULL, &lzw, 0);
OPTENT3(0, "g3", OPT_FLAG, NULL, &g3, 0);
OPTENT3(0, "g4", OPT_FLAG, NULL, &g4, 0);
OPTENT3(0, "flate", OPT_FLAG, NULL, &flate, 0);
OPTENT3(0, "adobeflate", OPT_FLAG, NULL, &adobeflate, 0);
OPTENT3(0, "msb2lsb", OPT_FLAG, NULL, &msb2lsb, 0);
OPTENT3(0, "lsb2msb", OPT_FLAG, NULL, &lsb2msb, 0);
OPTENT3(0, "2d", OPT_FLAG, NULL, &opt_2d, 0);
OPTENT3(0, "fill", OPT_FLAG, NULL, &fill, 0);
OPTENT3(0, "minisblack", OPT_FLAG, NULL, &cmdlineP->minisblack, 0);
OPTENT3(0, "mb", OPT_FLAG, NULL, &cmdlineP->minisblack, 0);
OPTENT3(0, "miniswhite", OPT_FLAG, NULL, &cmdlineP->miniswhite, 0);
OPTENT3(0, "mw", OPT_FLAG, NULL, &cmdlineP->miniswhite, 0);
OPTENT3(0, "truecolor", OPT_FLAG, NULL, &cmdlineP->truecolor, 0);
OPTENT3(0, "color", OPT_FLAG, NULL, &cmdlineP->color, 0);
OPTENT3(0, "append", OPT_FLAG, NULL, &appendSpec, 0);
OPTENT3(0, "output", OPT_STRING, &cmdlineP->output,
&outputSpec, 0);
OPTENT3(0, "predictor", OPT_UINT, &cmdlineP->predictor,
&predictorSpec, 0);
OPTENT3(0, "rowsperstrip", OPT_UINT, &cmdlineP->rowsperstrip,
&rowsperstripSpec, 0);
OPTENT3(0, "xresolution", OPT_FLOAT, &cmdlineP->xresolution,
&xresolutionSpec, 0);
OPTENT3(0, "yresolution", OPT_FLOAT, &cmdlineP->yresolution,
&yresolutionSpec, 0);
OPTENT3(0, "resolutionunit", OPT_STRING, &resolutionunit,
&resolutionunitSpec, 0);
OPTENT3(0, "indexbits", OPT_STRING, &indexbits,
&indexbitsSpec, 0);
OPTENT3(0, "tag", OPT_NAMELIST, &cmdlineP->taglist, &tagSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char**)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (none + packbits + lzw + g3 + g4 + flate + adobeflate > 1)
pm_error("You specified more than one compression option. "
"Only one of -none, -packbits, -lze, -g3, and -g4 "
"is allowed.");
if (none)
cmdlineP->compression = COMPRESSION_NONE;
else if (packbits)
cmdlineP->compression = COMPRESSION_PACKBITS;
else if (lzw)
cmdlineP->compression = COMPRESSION_LZW;
else if (g3)
cmdlineP->compression = COMPRESSION_CCITTFAX3;
else if (g4)
cmdlineP->compression = COMPRESSION_CCITTFAX4;
else if (adobeflate)
cmdlineP->compression = COMPRESSION_ADOBE_DEFLATE;
else if (flate)
cmdlineP->compression = COMPRESSION_DEFLATE;
else
cmdlineP->compression = COMPRESSION_NONE;
if (msb2lsb + lsb2msb > 1)
pm_error("You specified both -msb2lsb and -lsb2msb. "
"These are conflicting options.");
if (msb2lsb)
cmdlineP->fillorder = FILLORDER_MSB2LSB;
else if (lsb2msb)
cmdlineP->fillorder = FILLORDER_LSB2MSB;
else
cmdlineP->fillorder = FILLORDER_MSB2LSB;
if (cmdlineP->miniswhite && cmdlineP->minisblack)
pm_error("You cannot specify both -miniswhite and -minisblack");
cmdlineP->g3options = 0; /* initial value */
if (opt_2d)
cmdlineP->g3options |= GROUP3OPT_2DENCODING;
if (fill)
cmdlineP->g3options |= GROUP3OPT_FILLBITS;
if (outputSpec) {
if (appendSpec)
cmdlineP->writeMethod = DIRECT_APPEND;
else
cmdlineP->writeMethod = DIRECT_CREATE;
} else
cmdlineP->writeMethod = TMPFILE;
if (predictorSpec) {
if (cmdlineP->predictor != 1 && cmdlineP->predictor != 2)
pm_error("-predictor may be only 1 or 2. You specified %d.",
cmdlineP->predictor);
} else
cmdlineP->predictor = -1;
if (rowsperstripSpec) {
if (cmdlineP->rowsperstrip < 1)
pm_error("-rowsperstrip must be positive. You specified %d.",
cmdlineP->rowsperstrip);
} else
cmdlineP->rowsperstrip = -1;
if (xresolutionSpec) {
if (cmdlineP->xresolution < 1)
pm_error("-xresolution must be positive. You specified %f.",
cmdlineP->xresolution);
} else
cmdlineP->xresolution = -1;
if (yresolutionSpec) {
if (cmdlineP->yresolution < 1)
pm_error("-yresolution must be positive. You specified %f.",
cmdlineP->yresolution);
} else
cmdlineP->yresolution = -1;
if (resolutionunitSpec) {
if (streq(resolutionunit, "inch"))
cmdlineP->resolutionunit = RESUNIT_INCH;
else if (streq(resolutionunit, "in"))
cmdlineP->resolutionunit = RESUNIT_INCH;
else if (streq(resolutionunit, "centimeter"))
cmdlineP->resolutionunit = RESUNIT_CENTIMETER;
else if (streq(resolutionunit, "cm"))
cmdlineP->resolutionunit = RESUNIT_CENTIMETER;
else if (streq(resolutionunit, "none"))
cmdlineP->resolutionunit = RESUNIT_NONE;
else if (streq(resolutionunit, "no"))
cmdlineP->resolutionunit = RESUNIT_NONE;
else
pm_error("The only acceptable values for -resolutionunit are "
"inch, centimeter, none, in, cm, and no. "
"You specified '%s'.", resolutionunit);
} else
cmdlineP->resolutionunit = RESUNIT_INCH;
if (indexbitsSpec) {
if (strstr(indexbits, "1"))
cmdlineP->indexsizeAllowed.b1 = TRUE;
else
cmdlineP->indexsizeAllowed.b1 = FALSE;
if (strstr(indexbits, "2"))
cmdlineP->indexsizeAllowed.b2 = TRUE;
else
cmdlineP->indexsizeAllowed.b2 = FALSE;
if (strstr(indexbits, "4"))
cmdlineP->indexsizeAllowed.b4 = TRUE;
else
cmdlineP->indexsizeAllowed.b4 = FALSE;
if (strstr(indexbits, "8"))
cmdlineP->indexsizeAllowed.b8 = TRUE;
else
cmdlineP->indexsizeAllowed.b8 = FALSE;
} else {
cmdlineP->indexsizeAllowed.b1 = FALSE;
cmdlineP->indexsizeAllowed.b2 = FALSE;
cmdlineP->indexsizeAllowed.b4 = FALSE;
cmdlineP->indexsizeAllowed.b8 = TRUE;
}
if (tagSpec)
validateTagList(cmdlineP->taglist);
else {
MALLOCARRAY_NOFAIL(cmdlineP->taglist, 1);
cmdlineP->taglist[0].name = NULL;
cmdlineP->taglist[0].value = NULL;
}
if (argc-1 == 0)
cmdlineP->inputFileName = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->inputFileName = argv[1];
}