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]; }