/* Write header to the given output stream */
static void
printheader(FILE *fout, const char *info)
{
extern char VersionID[];
/* copy octree header */
if (octname[0] == '!') {
newheader("RADIANCE", fout);
fputs(octname+1, fout);
if (octname[strlen(octname)-1] != '\n')
fputc('\n', fout);
} else {
FILE *fin = fopen(octname, (outfmt=='a') ? "r" : "rb");
if (fin == NULL)
quit(1);
checkheader(fin, OCTFMT, fout);
fclose(fin);
}
printargs(gargc-1, gargv, fout); /* add our command */
fprintf(fout, "SOFTWARE= %s\n", VersionID);
fputnow(fout);
fputs("NCOMP=3\n", fout); /* always RGB */
if (info != NULL) /* add extra info if given */
fputs(info, fout);
fputformat(formstr(outfmt), fout);
fputc('\n', fout); /* empty line ends header */
}
static void
initambfile( /* initialize ambient file */
int cre8
)
{
extern char *progname, *octname;
static char *mybuf = NULL;
#ifdef F_SETLKW
aflock(cre8 ? F_WRLCK : F_RDLCK);
#endif
SET_FILE_BINARY(ambfp);
if (mybuf == NULL)
mybuf = (char *)bmalloc(BUFSIZ+8);
setbuf(ambfp, mybuf);
if (cre8) { /* new file */
newheader("RADIANCE", ambfp);
fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
progname, colval(ambval,RED),
colval(ambval,GRN), colval(ambval,BLU),
ambvwt, ambounce, ambacc);
fprintf(ambfp, "-ad %d -as %d -ar %d ",
ambdiv, ambssamp, ambres);
if (octname != NULL)
fputs(octname, ambfp);
fputc('\n', ambfp);
fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
fputnow(ambfp);
fputformat(AMBFMT, ambfp);
fputc('\n', ambfp);
putambmagic(ambfp);
} else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
error(USER, "bad ambient file");
}
void
writepict( /* write the picture to a file */
char *s
)
{
static char buf[128];
char *fname;
FILE *fp;
COLR *scanline;
int y;
/* XXX relies on words.c 2.11 behavior */
if (nextword(buf, sizeof(buf), s) == NULL && !buf[0]) {
error(COMMAND, "no file");
return;
}
if ((fname = getpath(buf, NULL, 0)) == NULL ||
(fp = fopen(fname, "w")) == NULL) {
sprintf(errmsg, "cannot open \"%s\"", buf);
error(COMMAND, errmsg);
return;
}
SET_FILE_BINARY(fp);
(*dev->comout)("writing \"");
(*dev->comout)(fname);
(*dev->comout)("\"...\n");
/* write header */
newheader("RADIANCE", fp);
fputs(progname, fp);
fprintview(&ourview, fp);
if (octname != NULL)
fprintf(fp, " %s\n", octname);
else
putc('\n', fp);
fprintf(fp, "SOFTWARE= %s\n", VersionID);
fputnow(fp);
if (exposure != 1.0)
fputexpos(exposure, fp);
if (dev->pixaspect != 1.0)
fputaspect(dev->pixaspect, fp);
fputformat(COLRFMT, fp);
putc('\n', fp);
fprtresolu(hresolu, vresolu, fp);
scanline = (COLR *)malloc(hresolu*sizeof(COLR));
if (scanline == NULL) {
error(COMMAND, "not enough memory!");
fclose(fp);
unlink(fname);
return;
}
for (y = vresolu-1; y >= 0; y--) {
getpictcolrs(y, scanline, &ptrunk, hresolu, vresolu);
if (fwritecolrs(scanline, hresolu, fp) < 0)
break;
}
free((void *)scanline);
if (fclose(fp) < 0)
error(COMMAND, "write error");
}
/* Write our BSDF mesh interpolant out to the given binary stream */
void
save_bsdf_rep(FILE *ofp)
{
RBFNODE *rbf;
MIGRATION *mig;
int i, n;
/* finish header */
fprintf(ofp, "SYMMETRY=%d\n", !single_plane_incident * inp_coverage);
fprintf(ofp, "IO_SIDES= %d %d\n", input_orient, output_orient);
fprintf(ofp, "GRIDRES=%d\n", grid_res);
fprintf(ofp, "BSDFMIN=%g\n", bsdf_min);
fputformat(BSDFREP_FMT, ofp);
fputc('\n', ofp);
/* write each DSF */
for (rbf = dsf_list; rbf != NULL; rbf = rbf->next) {
putint(rbf->ord, 4, ofp);
putflt(rbf->invec[0], ofp);
putflt(rbf->invec[1], ofp);
putflt(rbf->invec[2], ofp);
putflt(rbf->vtotal, ofp);
putint(rbf->nrbf, 4, ofp);
for (i = 0; i < rbf->nrbf; i++) {
putflt(rbf->rbfa[i].peak, ofp);
putint(rbf->rbfa[i].crad, 2, ofp);
putint(rbf->rbfa[i].gx, 1, ofp);
putint(rbf->rbfa[i].gy, 1, ofp);
}
}
putint(-1, 4, ofp); /* terminator */
/* write each migration matrix */
for (mig = mig_list; mig != NULL; mig = mig->next) {
int zerocnt = 0;
putint(mig->rbfv[0]->ord, 4, ofp);
putint(mig->rbfv[1]->ord, 4, ofp);
/* write out as sparse data */
n = mtx_nrows(mig) * mtx_ncols(mig);
for (i = 0; i < n; i++) {
if (zerocnt == 0xff) {
putint(0xff, 1, ofp); zerocnt = 0;
}
if (mig->mtx[i] != 0) {
putint(zerocnt, 1, ofp); zerocnt = 0;
putflt(mig->mtx[i], ofp);
} else
++zerocnt;
}
putint(zerocnt, 1, ofp);
}
putint(-1, 4, ofp); /* terminator */
putint(-1, 4, ofp);
if (fflush(ofp) == EOF) {
fprintf(stderr, "%s: error writing BSDF interpolant\n",
progname);
exit(1);
}
}
/* Write matrix to file type indicated by dtype */
int
rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
{
RMATRIX *mydm = NULL;
int ok = 1;
if ((rm == NULL) | (fp == NULL))
return(0);
/* complete header */
if (rm->info)
fputs(rm->info, fp);
if (dtype == DTfromHeader)
dtype = rm->dtype;
else if ((dtype == DTrgbe) & (rm->dtype == DTxyze))
dtype = DTxyze;
else if ((dtype == DTxyze) & (rm->dtype == DTrgbe))
dtype = DTrgbe;
if ((dtype != DTrgbe) & (dtype != DTxyze)) {
fprintf(fp, "NROWS=%d\n", rm->nrows);
fprintf(fp, "NCOLS=%d\n", rm->ncols);
fprintf(fp, "NCOMP=%d\n", rm->ncomp);
} else if (rm->ncomp != 3) { /* wrong # components? */
double cmtx[3];
if (rm->ncomp != 1) /* only convert grayscale */
return(0);
cmtx[0] = cmtx[1] = cmtx[2] = 1;
mydm = rmx_transform(rm, 3, cmtx);
if (mydm == NULL)
return(0);
rm = mydm;
}
fputformat((char *)cm_fmt_id[dtype], fp);
fputc('\n', fp);
switch (dtype) { /* write data */
case DTascii:
ok = rmx_write_ascii(rm, fp);
break;
case DTfloat:
ok = rmx_write_float(rm, fp);
break;
case DTdouble:
ok = rmx_write_double(rm, fp);
break;
case DTrgbe:
case DTxyze:
fprtresolu(rm->ncols, rm->nrows, fp);
ok = rmx_write_rgbe(rm, fp);
break;
default:
return(0);
}
ok &= (fflush(fp) == 0);
rmx_free(mydm);
return(ok);
}
static void
picdebug(void) /* put out debugging picture */
{
static COLOR blkcol = BLKCOLOR;
COLOR *scan;
int y, i;
register int x, rg;
if (fseek(stdin, 0L, 0) == EOF) {
fprintf(stderr, "%s: cannot seek on input picture\n", progname);
exit(1);
}
getheader(stdin, NULL, NULL); /* skip input header */
fgetresolu(&xmax, &ymax, stdin);
/* allocate scanline */
scan = (COLOR *)malloc(xmax*sizeof(COLOR));
if (scan == NULL) {
perror(progname);
exit(1);
}
/* finish debug header */
fputformat(COLRFMT, debugfp);
putc('\n', debugfp);
fprtresolu(xmax, ymax, debugfp);
/* write debug picture */
for (y = ymax-1; y >= 0; y--) {
if (freadscan(scan, xmax, stdin) < 0) {
fprintf(stderr, "%s: error rereading input picture\n",
progname);
exit(1);
}
for (x = 0; x < xmax; x++) {
rg = chartndx(x, y, &i);
if (rg == RG_CENT) {
if (!(1L<<i & gmtflags) || (x+y)&07) {
copycolor(scan[x], mbRGB[i]);
clipgamut(scan[x], bright(scan[x]),
CGAMUT, colmin, colmax);
} else
copycolor(scan[x], blkcol);
} else if (rg == RG_CORR)
cvtcolor(scan[x], scan[x]);
else if (rg != RG_ORIG)
copycolor(scan[x], blkcol);
}
if (fwritescan(scan, xmax, debugfp) < 0) {
fprintf(stderr, "%s: error writing debugging picture\n",
progname);
exit(1);
}
}
/* clean up */
fclose(debugfp);
free((void *)scan);
}
static void
mapimage(void) /* map picture and send to stdout */
{
COLOR *scan;
comphist(); /* generate adaptation histogram */
check2do(); /* modify what2do flags */
if (what2do&DO_VEIL)
compveil(); /* compute veil image */
if (!(what2do&DO_LINEAR))
if (mkbrmap() < 0) /* make tone map */
what2do |= DO_LINEAR; /* failed! -- use linear */
#if ADJ_VEIL
else if (what2do&DO_VEIL)
adjveil(); /* else adjust veil image */
#endif
if (what2do&DO_LINEAR) {
if (scalef <= FTINY) {
if (what2do&DO_HSENS)
scalef = htcontrs(Lb(0.5*(Bldmax+Bldmin))) /
htcontrs(Lb(bwavg));
else
scalef = Lb(0.5*(Bldmax+Bldmin)) / Lb(bwavg);
scalef *= WHTEFFICACY/(inpexp*ldmax);
}
fputexpos(inpexp*scalef, stdout); /* record exposure */
if (lumf == cielum) scalef /= WHTEFFICACY;
}
fputformat(COLRFMT, stdout); /* complete header */
putchar('\n');
fputsresolu(&inpres, stdout); /* resolution doesn't change */
/* condition our image */
for (scan = firstscan(); scan != NULL; scan = nextscan())
if (fwritescan(scan, scanlen(&inpres), stdout) < 0) {
fprintf(stderr, "%s: scanline write error\n",
progname);
exit(1);
}
}
int
main(
int argc,
char *argv[]
)
{
int ncolumns = 0;
int autolabel = 0;
int curcol = 0, x0 = 0, curx = 0, cury = 0, spacing = 0;
int xsgn, ysgn;
char *thislabel;
int an;
SET_DEFAULT_BINARY();
SET_FILE_BINARY(stdin);
SET_FILE_BINARY(stdout);
progname = argv[0];
for (an = 1; an < argc && argv[an][0] == '-'; an++)
switch (argv[an][1]) {
case 'h':
echoheader = !echoheader;
break;
case 'x':
xsiz = atoi(argv[++an]);
break;
case 'y':
ysiz = atoi(argv[++an]);
break;
case 'b':
setcolr(bgcolr, atof(argv[an+1]),
atof(argv[an+2]),
atof(argv[an+3]));
an += 3;
break;
case 'a':
ncolumns = atoi(argv[++an]);
break;
case 's':
spacing = atoi(argv[++an]);
break;
case 'o':
curx = x0 = atoi(argv[++an]);
cury = atoi(argv[++an]);
break;
case 'l':
switch (argv[an][2]) {
case 'a':
autolabel++;
break;
case 'h':
labelht = atoi(argv[++an]);
break;
case '\0':
goto dofiles;
default:
goto userr;
}
break;
case '\0':
case 't':
goto dofiles;
default:
goto userr;
}
dofiles:
newheader("RADIANCE", stdout);
fputnow(stdout);
for (nfile = 0; an < argc; nfile++) {
if (nfile >= MAXFILE)
goto toomany;
thislabel = NULL;
input[nfile].flags = 0;
xsgn = ysgn = '-';
while (an < argc && (argv[an][0] == '-' || argv[an][0] == '+'
|| argv[an][0] == '=')) {
switch (argv[an][1]) {
case 't':
checkthresh = 1;
if (argv[an][0] == '-') {
input[nfile].flags |= HASMIN;
input[nfile].thmin = atof(argv[an+1]);
} else if (argv[an][0] == '+') {
input[nfile].flags |= HASMAX;
input[nfile].thmax = atof(argv[an+1]);
} else
goto userr;
an++;
break;
case 'l':
if (strcmp(argv[an], "-l"))
goto userr;
thislabel = argv[++an];
break;
case '+':
case '-':
case '0':
if (argv[an][0] != '=')
goto userr;
xsgn = argv[an][1];
ysgn = argv[an][2];
if (ysgn != '+' && ysgn != '-' && ysgn != '0')
goto userr;
break;
case '\0':
if (argv[an][0] == '-')
goto getfile;
goto userr;
default:
goto userr;
}
an++;
}
getfile:
if (argc-an < (ncolumns ? 1 : 3))
goto userr;
if (autolabel && thislabel == NULL)
thislabel = argv[an];
if (!strcmp(argv[an], "-")) {
input[nfile].name = StandardInput;
input[nfile].fp = stdin;
} else {
if (argv[an][0] == '!') {
input[nfile].name = Command;
input[nfile].fp = popen(argv[an]+1, "r");
} else {
input[nfile].name = argv[an];
input[nfile].fp = fopen(argv[an], "r");
}
if (input[nfile].fp == NULL) {
perror(argv[an]);
quit(1);
}
}
an++;
/* get header */
if (echoheader)
printf("%s:\n", input[nfile].name);
getheader(input[nfile].fp, headline, NULL);
if (wrongformat) {
fprintf(stderr, "%s: incompatible input format\n",
input[nfile].name);
quit(1);
}
/* get picture size */
if (fgetresolu(&input[nfile].xres, &input[nfile].yres,
input[nfile].fp) < 0) {
fprintf(stderr, "%s: bad picture size\n",
input[nfile].name);
quit(1);
}
if (ncolumns > 0) {
if (curcol >= ncolumns) {
cury = ymax + spacing;
curx = x0;
curcol = 0;
}
input[nfile].xloc = curx;
input[nfile].yloc = cury;
curx += input[nfile].xres + spacing;
curcol++;
} else {
input[nfile].xloc = atoi(argv[an++]);
if (xsgn == '+')
input[nfile].xloc -= input[nfile].xres;
else if (xsgn == '0')
input[nfile].xloc -= input[nfile].xres/2;
input[nfile].yloc = atoi(argv[an++]);
if (ysgn == '+')
input[nfile].yloc -= input[nfile].yres;
else if (ysgn == '0')
input[nfile].yloc -= input[nfile].yres/2;
}
if (input[nfile].xloc < xmin)
xmin = input[nfile].xloc;
if (input[nfile].yloc < ymin)
ymin = input[nfile].yloc;
if (input[nfile].xloc+input[nfile].xres > xmax)
xmax = input[nfile].xloc+input[nfile].xres;
if (input[nfile].yloc+input[nfile].yres > ymax)
ymax = input[nfile].yloc+input[nfile].yres;
if (thislabel != NULL) {
if (++nfile >= MAXFILE)
goto toomany;
input[nfile].name = Label;
input[nfile].flags = 0;
input[nfile].xres = input[nfile-1].xres;
input[nfile].yres = labelht;
if ((input[nfile].fp = lblopen(thislabel,
&input[nfile].xres,
&input[nfile].yres)) == NULL)
goto labelerr;
input[nfile].xloc = input[nfile-1].xloc;
input[nfile].yloc = input[nfile-1].yloc +
input[nfile-1].yres-input[nfile].yres;
}
}
if (xsiz <= 0)
xsiz = xmax;
else if (xsiz > xmax)
xmax = xsiz;
if (ysiz <= 0)
ysiz = ymax;
else if (ysiz > ymax)
ymax = ysiz;
/* add new header info. */
printargs(argc, argv, stdout);
if (strcmp(ourfmt, PICFMT))
fputformat(ourfmt, stdout); /* print format if known */
putchar('\n');
fprtresolu(xsiz, ysiz, stdout);
compos();
quit(0);
userr:
fprintf(stderr,
"Usage: %s [-h][-x xr][-y yr][-b r g b][-a n][-s p][-o x0 y0][-la][-lh h] ",
progname);
fprintf(stderr, "[-t min1][+t max1][-l lab][=SS] pic1 x1 y1 ..\n");
quit(1);
toomany:
fprintf(stderr, "%s: only %d files and labels allowed\n",
progname, MAXFILE);
quit(1);
labelerr:
fprintf(stderr, "%s: error opening label\n", progname);
quit(1);
return 1; /* pro forma return */
}
int
main( /* compile a .OBJ file into a mesh */
int argc,
char *argv[]
)
{
int nmatf = 0;
char pathnames[12800];
char *pns = pathnames;
char *matinp[128];
char *cp;
int i, j;
progname = argv[0];
ofun[OBJ_FACE].funp = o_face;
for (i = 1; i < argc && argv[i][0] == '-'; i++)
switch (argv[i][1]) {
case 'n': /* set limit */
objlim = atoi(argv[++i]);
break;
case 'r': /* resolution limit */
resolu = atoi(argv[++i]);
break;
case 'a': /* material file */
matinp[nmatf++] = argv[++i];
break;
case 'l': /* library material */
cp = getpath(argv[++i], getrlibpath(), R_OK);
if (cp == NULL) {
sprintf(errmsg,
"cannot find library material: '%s'",
argv[i]);
error(USER, errmsg);
}
matinp[nmatf++] = strcpy(pns, cp);
while (*pns++)
;
break;
case 'w': /* supress warnings */
nowarn = 1;
break;
default:
sprintf(errmsg, "unknown option: '%s'", argv[i]);
error(USER, errmsg);
break;
}
if (i < argc-2)
error(USER, "too many file arguments");
/* initialize mesh */
cvinit(i==argc-2 ? argv[i+1] : "<stdout>");
/* load material input */
for (j = 0; j < nmatf; j++)
readobj(matinp[j]);
/* read .OBJ file into triangles */
if (i == argc)
wfreadobj(NULL);
else
wfreadobj(argv[i]);
cvmeshbounds(); /* set octree boundaries */
if (i == argc-2) /* open output file */
if (freopen(argv[i+1], "w", stdout) == NULL)
error(SYSTEM, "cannot open output file");
SET_FILE_BINARY(stdout);
newheader("RADIANCE", stdout); /* new binary file header */
printargs(i<argc ? i+1 : argc, argv, stdout);
fputformat(MESHFMT, stdout);
fputc('\n', stdout);
mincusize = ourmesh->mcube.cusize / resolu - FTINY;
for (i = 0; i < nobjects; i++) /* add triangles to octree */
if (objptr(i)->otype == OBJ_FACE)
addface(&ourmesh->mcube, i);
/* optimize octree */
ourmesh->mcube.cutree = combine(ourmesh->mcube.cutree);
if (ourmesh->mcube.cutree == EMPTY)
error(WARNING, "mesh is empty");
cvmesh(); /* convert mesh and leaf nodes */
writemesh(ourmesh, stdout); /* write mesh to output */
/* printmeshstats(ourmesh, stderr); */
quit(0);
return 0; /* pro forma return */
}
int
main( /* convert object files to an octree */
int argc,
char *argv[]
)
{
FVECT bbmin, bbmax;
char *infile = NULL;
int inpfrozen = 0;
int outflags = IO_ALL;
OBJECT startobj;
int i;
progname = argv[0] = fixargv0(argv[0]);
ot_initotypes();
for (i = 1; i < argc && argv[i][0] == '-'; i++)
switch (argv[i][1]) {
case '\0': /* scene from stdin */
goto breakopt;
case 'i': /* input octree */
infile = argv[++i];
break;
case 'b': /* bounding cube */
thescene.cuorg[0] = atof(argv[++i]) - OMARGIN;
thescene.cuorg[1] = atof(argv[++i]) - OMARGIN;
thescene.cuorg[2] = atof(argv[++i]) - OMARGIN;
thescene.cusize = atof(argv[++i]) + 2*OMARGIN;
break;
case 'n': /* set limit */
objlim = atoi(argv[++i]);
break;
case 'r': /* resolution limit */
resolu = atoi(argv[++i]);
break;
case 'f': /* freeze octree */
outflags &= ~IO_FILES;
break;
case 'w': /* supress warnings */
nowarn = 1;
break;
default:
sprintf(errmsg, "unknown option: '%s'", argv[i]);
error(USER, errmsg);
break;
}
breakopt:
SET_FILE_BINARY(stdout);
if (infile != NULL) { /* get old octree & objects */
if (thescene.cusize > FTINY)
error(USER, "only one of '-b' or '-i'");
nfiles = readoct(infile, IO_ALL, &thescene, ofname);
if (nfiles == 0)
inpfrozen++;
} else
newheader("RADIANCE", stdout); /* new binary file header */
printargs(argc, argv, stdout);
fputformat(OCTFMT, stdout);
printf("\n");
startobj = nobjects; /* previous objects already converted */
for ( ; i < argc; i++) /* read new scene descriptions */
if (!strcmp(argv[i], "-")) { /* from stdin */
readobj(NULL);
outflags &= ~IO_FILES;
} else { /* from file */
if (nfiles >= MAXOBJFIL)
error(INTERNAL, "too many scene files");
readobj(ofname[nfiles++] = argv[i]);
}
ofname[nfiles] = NULL;
if (inpfrozen && outflags & IO_FILES) {
error(WARNING, "frozen octree");
outflags &= ~IO_FILES;
}
/* find bounding box */
bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
for (i = startobj; i < nobjects; i++)
add2bbox(objptr(i), bbmin, bbmax);
/* set/check cube */
if (thescene.cusize == 0.0) {
if (bbmin[0] <= bbmax[0]) {
for (i = 0; i < 3; i++) {
bbmin[i] -= OMARGIN;
bbmax[i] += OMARGIN;
}
for (i = 0; i < 3; i++)
if (bbmax[i] - bbmin[i] > thescene.cusize)
thescene.cusize = bbmax[i] - bbmin[i];
for (i = 0; i < 3; i++)
thescene.cuorg[i] =
(bbmax[i]+bbmin[i]-thescene.cusize)*.5;
}
} else {
for (i = 0; i < 3; i++)
if (bbmin[i] < thescene.cuorg[i] ||
bbmax[i] > thescene.cuorg[i] + thescene.cusize)
error(USER, "boundary does not encompass scene");
}
mincusize = thescene.cusize / resolu - FTINY;
for (i = startobj; i < nobjects; i++) /* add new objects */
addobject(&thescene, i);
thescene.cutree = combine(thescene.cutree); /* optimize */
writeoct(outflags, &thescene, ofname); /* write structures to stdout */
quit(0);
return 0; /* pro forma return */
}
int
main(
int argc,
char **argv
)
{
double d, expval = 1.0;
int i;
progname = argv[0];
mybright = &rgb_bright; /* default */
for (i = 1; i < argc; i++)
if (argv[i][0] == '-' || argv[i][0] == '+')
switch (argv[i][1]) {
case 'h': /* header */
header = argv[i][0] == '+';
break;
case 'H': /* resolution string */
resolution = argv[i][0] == '+';
break;
case 's': /* skip bytes in header */
skipbytes = atol(argv[++i]);
break;
case 'u': /* unique values */
uniq = argv[i][0] == '-';
break;
case 'o': /* original values */
original = argv[i][0] == '-';
break;
case 'g': /* gamma correction */
gamcor = atof(argv[i+1]);
if (argv[i][0] == '+')
gamcor = 1.0/gamcor;
i++;
break;
case 'e': /* exposure correction */
d = atof(argv[i+1]);
if (argv[i+1][0] == '-' || argv[i+1][0] == '+')
d = pow(2.0, d);
if (argv[i][0] == '-')
expval *= d;
scalecolor(exposure, d);
doexposure++;
i++;
break;
case 'R': /* reverse byte sequence */
if (argv[i][0] == '-') {
ord[0]=BLU; ord[1]=GRN; ord[2]=RED;
} else {
ord[0]=RED; ord[1]=GRN; ord[2]=BLU;
}
break;
case 'r': /* reverse conversion */
reverse = argv[i][0] == '-';
break;
case 'n': /* non-interleaved RGB */
interleave = argv[i][0] == '+';
break;
case 'b': /* brightness values */
putprim = argv[i][0] == '-' ? BRIGHT : ALL;
break;
case 'p': /* primary controls */
switch (argv[i][2]) {
/* these two options affect -r conversion */
case '\0':
myprims[RED][CIEX] = atof(argv[++i]);
myprims[RED][CIEY] = atof(argv[++i]);
myprims[GRN][CIEX] = atof(argv[++i]);
myprims[GRN][CIEY] = atof(argv[++i]);
myprims[BLU][CIEX] = atof(argv[++i]);
myprims[BLU][CIEY] = atof(argv[++i]);
myprims[WHT][CIEX] = atof(argv[++i]);
myprims[WHT][CIEY] = atof(argv[++i]);
outprims = myprims;
break;
case 'x': case 'X': outprims = NULL; break;
/* the following options affect +r only */
case 'r': case 'R': putprim = RED; break;
case 'g': case 'G': putprim = GRN; break;
case 'b': case 'B': putprim = BLU; break;
default: goto unkopt;
}
break;
case 'd': /* data only (no indices) */
dataonly = argv[i][0] == '-';
switch (argv[i][2]) {
case '\0':
case 'a': /* ascii */
format = 'a';
fmtid = "ascii";
break;
case 'i': /* integer */
format = 'i';
fmtid = "ascii";
break;
case 'b': /* byte */
dataonly = 1;
format = 'b';
fmtid = "byte";
break;
case 'W': /* 16-bit swapped */
swapbytes = 1;
case 'w': /* 16-bit */
dataonly = 1;
format = 'w';
fmtid = "16-bit";
break;
case 'F': /* swapped floats */
swapbytes = 1;
case 'f': /* float */
dataonly = 1;
format = 'f';
fmtid = "float";
break;
case 'D': /* swapped doubles */
swapbytes = 1;
case 'd': /* double */
dataonly = 1;
format = 'd';
fmtid = "double";
break;
default:
goto unkopt;
}
break;
case 'x': /* x resolution */
case 'X': /* x resolution */
resolution = 0;
if (argv[i][0] == '-')
picres.rt |= XDECR;
picres.xr = atoi(argv[++i]);
break;
case 'y': /* y resolution */
case 'Y': /* y resolution */
resolution = 0;
if (argv[i][0] == '-')
picres.rt |= YDECR;
if (picres.xr == 0)
picres.rt |= YMAJOR;
picres.yr = atoi(argv[++i]);
break;
default:
unkopt:
fprintf(stderr, "%s: unknown option: %s\n",
progname, argv[i]);
quit(1);
break;
}
else
break;
/* recognize special formats */
if (dataonly && format == 'b') {
if (putprim == ALL)
fmtid = "24-bit_rgb";
else
fmtid = "8-bit_grey";
}
if (dataonly && format == 'w') {
if (putprim == ALL)
fmtid = "48-bit_rgb";
else
fmtid = "16-bit_grey";
}
/* assign reverse ordering */
rord[ord[0]] = 0;
rord[ord[1]] = 1;
rord[ord[2]] = 2;
/* get input */
if (i == argc) {
fin = stdin;
} else if (i < argc) {
if ((fin = fopen(argv[i], "r")) == NULL) {
fprintf(stderr, "%s: can't open file \"%s\"\n",
progname, argv[i]);
quit(1);
}
if (reverse && putprim != BRIGHT && i == argc-3) {
if ((fin2 = fopen(argv[i+1], "r")) == NULL) {
fprintf(stderr, "%s: can't open file \"%s\"\n",
progname, argv[i+1]);
quit(1);
}
if ((fin3 = fopen(argv[i+2], "r")) == NULL) {
fprintf(stderr, "%s: can't open file \"%s\"\n",
progname, argv[i+2]);
quit(1);
}
interleave = -1;
} else if (i != argc-1)
fin = NULL;
if (reverse && putprim != BRIGHT && !interleave) {
fin2 = fopen(argv[i], "r");
fin3 = fopen(argv[i], "r");
}
if (skipbytes && (fseek(fin, skipbytes, 0) || (fin2 != NULL &&
(fseek(fin2, skipbytes, 0) ||
fseek(fin3, skipbytes, 0))))) {
fprintf(stderr, "%s: cannot skip %ld bytes on input\n",
progname, skipbytes);
quit(1);
}
}
if (fin == NULL) {
fprintf(stderr, "%s: bad # file arguments\n", progname);
quit(1);
}
if (reverse) {
#ifdef _WIN32
SET_FILE_BINARY(stdout);
if (format != 'a' && format != 'i')
SET_FILE_BINARY(fin);
#endif
/* get header */
if (header) {
if (checkheader(fin, fmtid, stdout) < 0) {
fprintf(stderr, "%s: wrong input format\n",
progname);
quit(1);
}
if (fin2 != NULL) {
getheader(fin2, NULL, NULL);
getheader(fin3, NULL, NULL);
}
} else
newheader("RADIANCE", stdout);
/* get resolution */
if ((resolution && !fgetsresolu(&picres, fin)) ||
picres.xr <= 0 || picres.yr <= 0) {
fprintf(stderr, "%s: missing resolution\n", progname);
quit(1);
}
if (resolution && fin2 != NULL) {
RESOLU pres2;
if (!fgetsresolu(&pres2, fin2) ||
pres2.rt != picres.rt ||
pres2.xr != picres.xr ||
pres2.yr != picres.yr ||
!fgetsresolu(&pres2, fin3) ||
pres2.rt != picres.rt ||
pres2.xr != picres.xr ||
pres2.yr != picres.yr) {
fprintf(stderr, "%s: resolution mismatch\n",
progname);
quit(1);
}
}
/* add to header */
printargs(i, argv, stdout);
if (expval < .99 || expval > 1.01)
fputexpos(expval, stdout);
if (outprims != NULL) {
if (outprims != stdprims)
fputprims(outprims, stdout);
fputformat(COLRFMT, stdout);
} else /* XYZ data */
fputformat(CIEFMT, stdout);
putchar('\n');
fputsresolu(&picres, stdout); /* always put resolution */
valtopix();
} else {
#ifdef _WIN32
SET_FILE_BINARY(fin);
if (format != 'a' && format != 'i')
SET_FILE_BINARY(stdout);
#endif
/* get header */
getheader(fin, checkhead, NULL);
if (wrongformat) {
fprintf(stderr,
"%s: input not a Radiance RGBE picture\n",
progname);
quit(1);
}
if (!fgetsresolu(&picres, fin)) {
fprintf(stderr, "%s: missing resolution\n", progname);
quit(1);
}
if (header) {
printargs(i, argv, stdout);
if (expval < .99 || expval > 1.01)
fputexpos(expval, stdout);
fputformat(fmtid, stdout);
putchar('\n');
}
if (resolution) /* put resolution */
fputsresolu(&picres, stdout);
pixtoval();
}
quit(0);
return 0; /* pro forma return */
}
static void
clrdebug(void) /* put out debug picture from color input */
{
static COLR blkclr = BLKCOLR;
COLR mbclr[24], cvclr[24], orclr[24];
COLR *scan;
COLOR ctmp, ct2;
int y, i;
register int x, rg;
/* convert colors */
for (i = 0; i < 24; i++) {
copycolor(ctmp, mbRGB[i]);
clipgamut(ctmp, bright(ctmp), CGAMUT, cblack, cwhite);
setcolr(mbclr[i], colval(ctmp,RED),
colval(ctmp,GRN), colval(ctmp,BLU));
if (inpflags & 1L<<i) {
copycolor(ctmp, inpRGB[i]);
clipgamut(ctmp, bright(ctmp), CGAMUT, cblack, cwhite);
setcolr(orclr[i], colval(ctmp,RED),
colval(ctmp,GRN), colval(ctmp,BLU));
if (rawmap)
copycolr(cvclr[i], mbclr[i]);
else {
bresp(ctmp, inpRGB[i]);
colortrans(ct2, solmat, ctmp);
clipgamut(ct2, bright(ct2), CGAMUT,
cblack, cwhite);
setcolr(cvclr[i], colval(ct2,RED),
colval(ct2,GRN),
colval(ct2,BLU));
}
}
}
/* allocate scanline */
scan = (COLR *)malloc(xmax*sizeof(COLR));
if (scan == NULL) {
perror(progname);
exit(1);
}
/* finish debug header */
fputformat(COLRFMT, debugfp);
putc('\n', debugfp);
fprtresolu(xmax, ymax, debugfp);
/* write debug picture */
for (y = ymax-1; y >= 0; y--) {
for (x = 0; x < xmax; x++) {
rg = chartndx(x, y, &i);
if (rg == RG_CENT) {
if (!(1L<<i & gmtflags) || (x+y)&07)
copycolr(scan[x], mbclr[i]);
else
copycolr(scan[x], blkclr);
} else if (rg == RG_BORD || !(1L<<i & inpflags))
copycolr(scan[x], blkclr);
else if (rg == RG_ORIG)
copycolr(scan[x], orclr[i]);
else /* rg == RG_CORR */
copycolr(scan[x], cvclr[i]);
}
if (fwritecolrs(scan, xmax, debugfp) < 0) {
fprintf(stderr, "%s: error writing debugging picture\n",
progname);
exit(1);
}
}
/* clean up */
fclose(debugfp);
free((void *)scan);
}
int
main(
int argc,
char *argv[]
)
{
static char picfmt[MAXFMTLEN] = PICFMT;
int rval;
FILE *fin;
SET_DEFAULT_BINARY();
SET_FILE_BINARY(stdout);
progname = argv[0];
while (argc > 2 && argv[1][0] == '-') {
switch (argv[1][1]) {
case 'c':
correctorder = 1;
break;
case 'r':
ccw = 1;
break;
default:
goto userr;
}
argc--; argv++;
}
if (argc != 2 && argc != 3)
goto userr;
if ((fin = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "%s: cannot open\n", argv[1]);
exit(1);
}
if (argc == 3 && freopen(argv[2], "w", stdout) == NULL) {
fprintf(stderr, "%s: cannot open\n", argv[2]);
exit(1);
}
/* transfer header */
if ((rval = checkheader(fin, picfmt, stdout)) < 0) {
fprintf(stderr, "%s: not a Radiance picture\n", progname);
exit(1);
}
if (rval)
fputformat(picfmt, stdout);
/* add new header info. */
fputs(progname, stdout);
if (ccw) fputs(" -r", stdout);
if (correctorder) fputs(" -c", stdout);
fputs("\n\n", stdout);
/* get picture size */
if ((order = fgetresolu(&xres, &yres, fin)) < 0) {
fprintf(stderr, "%s: bad picture size\n", progname);
exit(1);
}
/* write new picture size */
fputresolu(neworder(), yres, xres, stdout);
/* compute buffer capacity */
nrows = sizeof(buf)/sizeof(COLR)/yres;
if (ccw) /* rotate the image */
rotateccw(fin);
else
rotatecw(fin);
exit(0);
userr:
fprintf(stderr, "Usage: %s [-r][-c] infile [outfile]\n", progname);
exit(1);
}
int
main(
int argc,
char *argv[]
)
{
struct hdStruct head;
int dither = 1;
int reverse = 0;
int ncolors = 256;
int greyscale = 0;
int i;
SET_DEFAULT_BINARY();
SET_FILE_BINARY(stdin);
SET_FILE_BINARY(stdout);
progname = argv[0];
samplefac = 0;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1]) {
case 'd':
dither = !dither;
break;
case 'g':
gamv = atof(argv[++i]);
break;
case 'r':
reverse = !reverse;
break;
case 'b':
greyscale = 1;
break;
case 'e':
if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
goto userr;
bradj = atoi(argv[++i]);
break;
case 'c':
ncolors = atoi(argv[++i]);
break;
case 'n':
samplefac = atoi(argv[++i]);
break;
default:
goto userr;
}
else
break;
if (i < argc-2)
goto userr;
if (i <= argc-1 && freopen(argv[i], "r", stdin) == NULL) {
sprintf(errmsg, "cannot open input \"%s\"", argv[i]);
quiterr(errmsg);
}
if (i == argc-2 && freopen(argv[i+1], "w", stdout) == NULL) {
sprintf(errmsg, "cannot open output \"%s\"", argv[i+1]);
quiterr(errmsg);
}
if (reverse) {
/* get header */
if (getthead(&head, NULL, stdin) < 0)
quiterr("bad targa file");
if (!goodpic(&head))
quiterr("incompatible format");
xmax = head.x;
ymax = head.y;
/* put header */
newheader("RADIANCE", stdout);
printargs(i, argv, stdout);
fputformat(COLRFMT, stdout);
putchar('\n');
fprtresolu(xmax, ymax, stdout);
/* convert file */
tg2ra(&head);
} else {
if (getrhead(&head, stdin) < 0)
quiterr("bad Radiance input");
/* write header */
putthead(&head, NULL, stdout);
/* convert file */
if (greyscale)
getgrey(ncolors);
else
getmapped(ncolors, dither);
/* write data */
writetarga(&head, tarData, stdout);
}
quiterr(NULL);
userr:
fprintf(stderr,
"Usage: %s [-d][-n samp][-c ncolors][-b][-g gamv][-e +/-stops] input [output]\n",
progname);
fprintf(stderr, " Or: %s -r [-g gamv][-e +/-stops] [input [output]]\n",
progname);
exit(1);
}
int
main(
int argc,
char *argv[]
)
{
char inpbuf[2];
int gryflag = 0;
int binflag = 1;
int reverse = 0;
int ptype;
int i;
progname = argv[0];
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1]) {
case 's':
maxval = atoi(argv[++i]) & 0xffff;
break;
case 'b':
gryflag = 1;
break;
case 'g':
gamcor = atof(argv[++i]);
break;
case 'e':
if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
goto userr;
bradj = atoi(argv[++i]);
break;
case 'a':
binflag = 0;
break;
case 'r':
reverse = !reverse;
break;
default:
goto userr;
}
else
break;
if (i < argc-2)
goto userr;
if (i <= argc-1 && freopen(argv[i], "r", stdin) == NULL) {
fprintf(stderr, "%s: can't open input \"%s\"\n",
progname, argv[i]);
exit(1);
}
if (i == argc-2 && freopen(argv[i+1], "w", stdout) == NULL) {
fprintf(stderr, "%s: can't open output \"%s\"\n",
progname, argv[i+1]);
exit(1);
}
if (maxval < 256)
setcolrgam(gamcor);
if (reverse) {
/* get header */
if (read(fileno(stdin), inpbuf, 2) != 2 || inpbuf[0] != 'P')
quiterr("input not a Poskanzer Pixmap");
ptype = inpbuf[1];
#ifdef _WIN32
if (ptype > 4)
SET_FILE_BINARY(stdin);
SET_FILE_BINARY(stdout);
#endif
xmax = scanint(stdin);
ymax = scanint(stdin);
maxval = scanint(stdin);
/* put header */
newheader("RADIANCE", stdout);
printargs(i, argv, stdout);
fputformat(COLRFMT, stdout);
putchar('\n');
fprtresolu(xmax, ymax, stdout);
/* convert file */
if (maxval >= 256)
switch (ptype) {
case '2':
ppm2ra2(agryscan2);
break;
case '5':
ppm2ra2(bgryscan2);
break;
case '3':
ppm2ra2(aclrscan2);
break;
case '6':
ppm2ra2(bclrscan2);
break;
default:
quiterr("unsupported Pixmap type");
}
else
switch (ptype) {
case '2':
ppm2ra(agryscan);
break;
case '5':
ppm2ra(bgryscan);
break;
case '3':
ppm2ra(aclrscan);
break;
case '6':
ppm2ra(bclrscan);
break;
default:
quiterr("unsupported Pixmap type");
}
} else {
#ifdef _WIN32
SET_FILE_BINARY(stdin);
if (binflag)
SET_FILE_BINARY(stdout);
#endif
/* get header info. */
if (checkheader(stdin, COLRFMT, NULL) < 0 ||
fgetresolu(&xmax, &ymax, stdin) < 0)
quiterr("bad picture format");
/* write PPM header */
printf("P%1d\n%d %d\n%u\n", (gryflag?2:3)+(binflag?3:0),
xmax, ymax, maxval);
/* convert file */
if (maxval >= 256)
ra2ppm2(binflag, gryflag);
else
ra2ppm(binflag, gryflag);
}
exit(0);
userr:
fprintf(stderr,
"Usage: %s [-r][-a][-b][-s maxv][-g gamma][-e +/-stops] [input [output]]\n",
progname);
exit(1);
}
int
main(
int argc,
char *argv[]
)
{
int original;
double f;
int a;
SET_DEFAULT_BINARY();
SET_FILE_BINARY(stdin);
SET_FILE_BINARY(stdout);
progname = argv[0];
/* scan options */
for (a = 1; a < argc; a++) {
if (argv[a][0] == '-')
switch (argv[a][1]) {
case 'x':
case 'y':
a++;
continue;
case 'w':
nowarn = !nowarn;
continue;
case 'h':
echoheader = !echoheader;
continue;
case 'f':
case 'e':
a++;
continue;
}
break;
}
newheader("RADIANCE", stdout); /* start header */
fputnow(stdout);
/* process files */
for (nfiles = 0; nfiles < MAXINP; nfiles++) {
setcolor(input[nfiles].coef, 1.0, 1.0, 1.0);
setcolor(input[nfiles].expos, 1.0, 1.0, 1.0);
input[nfiles].vw = stdview;
input[nfiles].pa = 1.0;
}
nfiles = 0;
original = 0;
for ( ; a < argc; a++) {
if (nfiles >= MAXINP) {
eputs(argv[0]);
eputs(": too many picture files\n");
quit(1);
}
if (argv[a][0] == '-')
switch (argv[a][1]) {
case '\0':
input[nfiles].name = StandardInput;
input[nfiles].fp = stdin;
break;
case 'o':
original++;
continue;
case 's':
f = atof(argv[++a]);
scalecolor(input[nfiles].coef, f);
continue;
case 'c':
colval(input[nfiles].coef,RED)*=atof(argv[++a]);
colval(input[nfiles].coef,GRN)*=atof(argv[++a]);
colval(input[nfiles].coef,BLU)*=atof(argv[++a]);
continue;
default:
goto usage;
}
else {
if (argv[a][0] == '!') {
input[nfiles].name = Command;
input[nfiles].fp = popen(argv[a]+1, "r");
} else {
input[nfiles].name = argv[a];
input[nfiles].fp = fopen(argv[a], "r");
}
if (input[nfiles].fp == NULL) {
perror(argv[a]);
quit(1);
}
}
checkfile();
if (original) {
colval(input[nfiles].coef,RED) /=
colval(input[nfiles].expos,RED);
colval(input[nfiles].coef,GRN) /=
colval(input[nfiles].expos,GRN);
colval(input[nfiles].coef,BLU) /=
colval(input[nfiles].expos,BLU);
setcolor(input[nfiles].expos, 1.0, 1.0, 1.0);
}
nfiles++;
original = 0;
}
init(); /* set constants */
/* go back and get expressions */
for (a = 1; a < argc; a++) {
if (argv[a][0] == '-')
switch (argv[a][1]) {
case 'x':
varset(vxres, ':', eval(argv[++a]));
continue;
case 'y':
varset(vyres, ':', eval(argv[++a]));
continue;
case 'w':
continue;
case 'h':
continue;
case 'f':
fcompile(argv[++a]);
continue;
case 'e':
scompile(argv[++a], NULL, 0);
continue;
}
break;
}
/* set/get output resolution */
if (!vardefined(vxres))
varset(vxres, ':', (double)xmax);
if (!vardefined(vyres))
varset(vyres, ':', (double)ymax);
xres = varvalue(vxres) + .5;
yres = varvalue(vyres) + .5;
if (xres <= 0 || yres <= 0) {
eputs(argv[0]);
eputs(": illegal output resolution\n");
quit(1);
}
/* complete header */
printargs(argc, argv, stdout);
if (strcmp(ourfmt, PICFMT))
fputformat(ourfmt, stdout); /* print format if known */
putchar('\n');
fprtresolu(xres, yres, stdout);
/* combine pictures */
combine();
quit(0);
usage:
eputs("Usage: ");
eputs(argv[0]);
eputs(
" [-w][-h][-x xr][-y yr][-e expr][-f file] [ [-o][-s f][-c r g b] hdr ..]\n");
quit(1);
return 1; /* pro forma return */
}