/* ppmbrighten.c - allow user control over Value and Saturation of PPM file ** ** Copyright (C) 1989 by Jef Poskanzer. ** Copyright (C) 1990 by Brian Moffet. ** ** Permission to use, copy, modify, and distribute this software and its ** documentation for any purpose and without fee is hereby granted, provided ** that the above copyright notice appear in all copies and that both that ** copyright notice and this permission notice appear in supporting ** documentation. This software is provided "as is" without express or ** implied warranty. */ #include "pm_c_util.h" #include "ppm.h" #include "shhopt.h" #include "mallocvar.h" #define MULTI 1000 struct cmdlineInfo { /* All the information the user supplied in the command line, in a form easy for the program to use. */ const char * inputFilespec; /* '-' if stdin */ float saturation; float value; unsigned int normalize; }; 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 pm_optParseOptions3 on how to parse our options. */ optStruct3 opt; unsigned int option_def_index; unsigned int saturationSpec, valueSpec; int saturationOpt, valueOpt; MALLOCARRAY_NOFAIL(option_def, 100); option_def_index = 0; /* incremented by OPTENT3 */ OPTENT3(0, "saturation", OPT_INT, &saturationOpt, &saturationSpec, 0 ); OPTENT3(0, "value", OPT_INT, &valueOpt, &valueSpec, 0 ); OPTENT3(0, "normalize", OPT_FLAG, NULL, &cmdlineP->normalize, 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, argv, opt, sizeof(opt), 0); /* Uses and sets argc, argv, and some of *cmdlineP and others. */ if (saturationSpec) { if (saturationOpt < -100) pm_error("Saturation reduction cannot be more than 100%%. " "You specified %d", saturationOpt); else cmdlineP->saturation = 1.0 + (float)saturationOpt / 100; } else cmdlineP->saturation = 1.0; if (valueSpec) { if (valueOpt < -100) pm_error("Value reduction cannot be more than 100%%. " "You specified %d", valueOpt); else cmdlineP->value = 1.0 + (float)valueOpt / 100; } else cmdlineP->value = 1.0; if (argc-1 < 1) cmdlineP->inputFilespec = "-"; else if (argc-1 == 1) cmdlineP->inputFilespec = argv[1]; else pm_error("Program takes at most one argument: file specification"); } static __inline__ unsigned int mod(int const dividend, unsigned int const divisor) { int remainder = dividend % (int)divisor; if (remainder < 0) return divisor + remainder; else return (unsigned int) remainder; } static void RGBtoHSV(pixel const color, pixval const maxval, unsigned int * const hP, unsigned int * const sP, unsigned int * const vP) { unsigned int const R = (MULTI * PPM_GETR(color) + maxval - 1) / maxval; unsigned int const G = (MULTI * PPM_GETG(color) + maxval - 1) / maxval; unsigned int const B = (MULTI * PPM_GETB(color) + maxval - 1) / maxval; unsigned int s, v; unsigned int t; unsigned int sector; v = MAX(R, MAX(G, B)); t = MIN(R, MIN(G, B)); if (v == 0) s = 0; else s = ((v - t)*MULTI)/v; if (s == 0) sector = 0; else { unsigned int const cr = (MULTI * (v - R))/(v - t); unsigned int const cg = (MULTI * (v - G))/(v - t); unsigned int const cb = (MULTI * (v - B))/(v - t); if (R == v) sector = mod((int)(cb - cg), 6*MULTI); else if (G == v) sector = mod((int)((2*MULTI) + cr - cb), 6*MULTI); else if (B == v) sector = mod((int)((4*MULTI) + cg - cr), 6*MULTI); else pm_error("Internal error: neither r, g, nor b is maximum"); } *hP = sector * 60; *sP = s; *vP = v; } static void HSVtoRGB(unsigned int const h, unsigned int const s, unsigned int const v, pixval const maxval, pixel * const colorP) { unsigned int R, G, B; if (s == 0) { R = v; G = v; B = v; } else { unsigned int const sectorSize = 60 * MULTI; /* Color wheel is divided into six 60 degree sectors. */ unsigned int const sector = (h/sectorSize); /* The sector in which our color resides. Value is in 0..5 */ unsigned int const f = (h - sector*sectorSize)/60; /* The fraction of the way the color is from one side of our sector to the other side, going clockwise. Value is in [0, MULTI). */ unsigned int const m = (v * (MULTI - s)) / MULTI; unsigned int const n = (v * (MULTI - (s * f)/MULTI)) / MULTI; unsigned int const k = (v * (MULTI - (s * (MULTI - f))/MULTI)) / MULTI; switch (sector) { case 0: R = v; G = k; B = m; break; case 1: R = n; G = v; B = m; break; case 2: R = m; G = v; B = k; break; case 3: R = m; G = n; B = v; break; case 4: R = k; G = m; B = v; break; case 5: R = v; G = m; B = n; break; default: pm_error("Invalid H value passed to HSVtoRGB: %u/%u", h, MULTI); } } PPM_ASSIGN(*colorP, (R * maxval) / MULTI, (G * maxval) / MULTI, (B * maxval) / MULTI); } static void getMinMax(FILE * const ifP, int const cols, int const rows, pixval const maxval, int const format, unsigned int * const minValueP, unsigned int * const maxValueP) { pixel * pixelrow; unsigned int minValue, maxValue; int row; pixelrow = ppm_allocrow(cols); maxValue = 0; minValue = MULTI; for (row = 0; row < rows; ++row) { unsigned int col; ppm_readppmrow(ifP, pixelrow, cols, maxval, format); for (col = 0; col < cols; ++col) { unsigned int H, S, V; RGBtoHSV(pixelrow[col], maxval, &H, &S, &V); maxValue = MAX(maxValue, V); minValue = MIN(minValue, V); } } ppm_freerow(pixelrow); *minValueP = minValue; *maxValueP = maxValue; } int main(int argc, char * argv[]) { struct cmdlineInfo cmdline; FILE * ifP; pixval minValue, maxValue; pixel * pixelrow; pixval maxval; int rows, cols, format, row; ppm_init(&argc, argv); parseCommandLine(argc, argv, &cmdline); if (cmdline.normalize) ifP = pm_openr_seekable(cmdline.inputFilespec); else ifP = pm_openr(cmdline.inputFilespec); ppm_readppminit(ifP, &cols, &rows, &maxval, &format); if (cmdline.normalize) { pm_filepos rasterPos; pm_tell2(ifP, &rasterPos, sizeof(rasterPos)); getMinMax(ifP, cols, rows, maxval, format, &minValue, &maxValue); pm_seek2(ifP, &rasterPos, sizeof(rasterPos)); if (maxValue > minValue) { pm_message("Minimum value %u%% of full intensity " "being remapped to zero.", (minValue*100+MULTI/2)/MULTI); pm_message("Maximum value %u%% of full intensity " "being remapped to full.", (maxValue*100+MULTI/2)/MULTI); } else pm_message("Sole intensity value %u%% of full intensity " "not being remapped", (minValue*100+MULTI/2)/MULTI); } pixelrow = ppm_allocrow(cols); ppm_writeppminit(stdout, cols, rows, maxval, 0); for (row = 0; row < rows; ++row) { unsigned int col; ppm_readppmrow(ifP, pixelrow, cols, maxval, format); for (col = 0; col < cols; ++col) { unsigned int H, S, V; RGBtoHSV(pixelrow[col], maxval, &H, &S, &V); if (cmdline.normalize) { if (maxValue > minValue) { V -= minValue; V = (V * MULTI) / (MULTI - (minValue+MULTI-maxValue)); } } S = MIN(MULTI, (unsigned int) (S * cmdline.saturation + 0.5)); V = MIN(MULTI, (unsigned int) (V * cmdline.value + 0.5)); HSVtoRGB(H, S, V, maxval, &pixelrow[col]); } ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0); } ppm_freerow(pixelrow); pm_close(ifP); /* If the program failed, it previously aborted with nonzero completion code, via various function calls. */ return 0; }