16 |
|
|
17 |
|
char *progname; /* global argv[0] */ |
18 |
|
|
19 |
< |
/* Data types for matrix loading */ |
19 |
> |
/* Data types for file loading */ |
20 |
|
enum {DTfromHeader, DTascii, DTfloat, DTdouble, DTrgbe, DTxyze}; |
21 |
|
|
22 |
|
/* A color coefficient matrix -- vectors have ncols==1 */ |
38 |
|
CMATRIX *cm; |
39 |
|
|
40 |
|
if ((nrows <= 0) | (ncols <= 0)) |
41 |
< |
return(NULL); |
41 |
> |
error(USER, "attempt to create empty matrix"); |
42 |
|
cm = (CMATRIX *)malloc(sizeof(CMATRIX) + |
43 |
|
3*sizeof(COLORV)*(nrows*ncols - 1)); |
44 |
|
if (cm == NULL) |
125 |
|
break; |
126 |
|
default: |
127 |
|
error(USER, "unexpected data type in cm_load()"); |
128 |
– |
return(NULL); |
128 |
|
} |
129 |
|
if (nrows <= 0) { /* don't know length? */ |
130 |
|
int guessrows = 147; /* usually big enough */ |
134 |
|
long endpos = ftell(fp); |
135 |
|
long elemsiz = 3*(dtype==DTfloat ? |
136 |
|
sizeof(float) : sizeof(double)); |
137 |
< |
guessrows = (endpos - startpos)/elemsiz; |
137 |
> |
|
138 |
> |
if ((endpos - startpos) % (ncols*elemsiz)) { |
139 |
> |
sprintf(errmsg, |
140 |
> |
"improper length for binary file '%s'", |
141 |
> |
fname); |
142 |
> |
error(USER, errmsg); |
143 |
> |
} |
144 |
> |
guessrows = (endpos - startpos)/(ncols*elemsiz); |
145 |
|
if (fseek(fp, startpos, SEEK_SET) < 0) { |
146 |
|
sprintf(errmsg, |
147 |
|
"fseek() error on file '%s'", |
148 |
|
fname); |
149 |
|
error(SYSTEM, errmsg); |
150 |
|
} |
151 |
< |
if ((endpos - startpos) % elemsiz == 0) |
146 |
< |
nrows = guessrows; /* confident */ |
151 |
> |
nrows = guessrows; /* we're confident */ |
152 |
|
} |
153 |
|
} |
154 |
|
cm = cm_alloc(guessrows, ncols); |
160 |
|
int maxrow = (nrows > 0 ? nrows : 32000); |
161 |
|
int r, c; |
162 |
|
for (r = 0; r < maxrow; r++) { |
163 |
< |
if (r >= cm->nrows) /* need more space? */ |
163 |
> |
if (r >= cm->nrows) /* need more space? */ |
164 |
|
cm = cm_resize(cm, 2*cm->nrows); |
165 |
|
for (c = 0; c < ncols; c++) { |
166 |
|
COLORV *cv = cm_lval(cm,r,c); |
167 |
|
if (fscanf(fp, COLSPEC, cv, cv+1, cv+2) != 3) |
168 |
< |
if ((nrows <= 0) & (r > 0) & (c == 0)) { |
168 |
> |
if ((nrows <= 0) & (r > 0) & !c) { |
169 |
|
cm = cm_resize(cm, maxrow=r); |
170 |
|
break; |
171 |
|
} else |
193 |
|
if (nread == cm->nrows*cm->ncols) |
194 |
|
/* need more space? */ |
195 |
|
cm = cm_resize(cm, 2*cm->nrows); |
196 |
< |
else if (nread % cm->ncols == 0) |
196 |
> |
else if (nread && !(nread % cm->ncols)) |
197 |
|
/* seem to be done */ |
198 |
|
cm = cm_resize(cm, nread/cm->ncols); |
199 |
|
else /* ended mid-row */ |
215 |
|
copycolor(cvp, dc); |
216 |
|
cvp += 3; |
217 |
|
} |
213 |
– |
|
218 |
|
} else /* dtype == DTfloat */ { |
219 |
|
float fc[3]; /* load from float */ |
220 |
|
COLORV *cvp = cm->cmem; |
294 |
|
cm_bsdf(const struct BSDF_data *bsdf) |
295 |
|
{ |
296 |
|
CMATRIX *cm = cm_alloc(bsdf->nout, bsdf->ninc); |
297 |
< |
COLORV *mp = cm->cmem; |
297 |
> |
int nbadohm = 0; |
298 |
> |
int nneg = 0; |
299 |
|
int r, c; |
300 |
|
|
301 |
< |
for (r = 0; r < cm->nrows; r++) |
302 |
< |
for (c = 0; c < cm->ncols; c++, mp += 3) |
303 |
< |
mp[0] = mp[1] = mp[2] = BSDF_value(bsdf,c,r); |
301 |
> |
for (c = 0; c < cm->ncols; c++) { |
302 |
> |
float dom = getBSDF_incohm(bsdf,c); |
303 |
> |
FVECT v; |
304 |
> |
|
305 |
> |
if (dom <= .0) { |
306 |
> |
nbadohm++; |
307 |
> |
continue; |
308 |
> |
} |
309 |
> |
if (!getBSDF_incvec(v,bsdf,c) || v[2] > FTINY) |
310 |
> |
error(USER, "illegal incoming BTDF direction"); |
311 |
> |
dom *= -v[2]; |
312 |
> |
|
313 |
> |
for (r = 0; r < cm->nrows; r++) { |
314 |
> |
float f = BSDF_value(bsdf,c,r); |
315 |
> |
COLORV *mp = cm_lval(cm,r,c); |
316 |
> |
|
317 |
> |
if (f <= .0) { |
318 |
> |
nneg += (f < -FTINY); |
319 |
> |
f = .0f; |
320 |
> |
} |
321 |
> |
mp[0] = mp[1] = mp[2] = f * dom; |
322 |
> |
} |
323 |
> |
} |
324 |
> |
if (nneg || nbadohm) { |
325 |
> |
sprintf(errmsg, |
326 |
> |
"BTDF has %d negatives and %d bad incoming solid angles", |
327 |
> |
nneg, nbadohm); |
328 |
> |
error(WARNING, errmsg); |
329 |
> |
} |
330 |
|
return(cm); |
331 |
|
} |
332 |
|
|
369 |
|
error(SYSTEM, "out of memory in sum_images()"); |
370 |
|
pmat = cm_alloc(myYR, myXR); |
371 |
|
memset(pmat->cmem, 0, sizeof(COLOR)*myXR*myYR); |
372 |
+ |
/* finish header */ |
373 |
+ |
fputformat(myDT==DTrgbe ? COLRFMT : CIEFMT, stdout); |
374 |
+ |
fputc('\n', stdout); |
375 |
+ |
fprtresolu(myXR, myYR, stdout); |
376 |
+ |
fflush(stdout); |
377 |
|
} else if ((dt != myDT) | (xr != myXR) | (yr != myYR)) { |
378 |
|
sprintf(errmsg, "picture '%s' format/size mismatch", |
379 |
|
fname); |
396 |
|
fclose(fp); /* done this picture */ |
397 |
|
} |
398 |
|
free(scanline); |
363 |
– |
/* finish header */ |
364 |
– |
fputformat(myDT==DTrgbe ? COLRFMT : CIEFMT, stdout); |
365 |
– |
fputc('\n', stdout); |
366 |
– |
fprtresolu(myXR, myYR, stdout); |
399 |
|
/* write scanlines */ |
400 |
|
for (y = 0; y < myYR; y++) |
401 |
|
if (fwritescan((COLOR *)cm_lval(pmat, y, 0), myXR, stdout) < 0) |
422 |
|
int |
423 |
|
main(int argc, char *argv[]) |
424 |
|
{ |
425 |
< |
CMATRIX *tvec, *Dmat, *Tmat, *vtmp, *cvec; |
425 |
> |
CMATRIX *tvec, *Dmat, *Tmat, *ivec, *cvec; |
426 |
|
struct BSDF_data *btdf; |
427 |
|
|
428 |
|
progname = argv[0]; |
432 |
|
progname); |
433 |
|
return(1); |
434 |
|
} |
435 |
+ |
/* load Tregenza vector */ |
436 |
|
tvec = cm_load(argv[4], 0, 1, DTascii); /* argv[4]==NULL iff argc==4 */ |
437 |
< |
Dmat = cm_load(argv[3], 0, tvec->nrows, DTfromHeader); |
437 |
> |
/* load BTDF */ |
438 |
|
btdf = load_BSDF(argv[2]); |
439 |
|
if (btdf == NULL) |
440 |
|
return(1); |
441 |
< |
if (btdf->ninc != Dmat->nrows) { |
442 |
< |
sprintf(errmsg, "Incoming BTDF dir (%d) mismatch to D (%d)", |
410 |
< |
btdf->ninc, Dmat->nrows); |
411 |
< |
error(USER, errmsg); |
412 |
< |
} |
441 |
> |
/* load Daylight matrix */ |
442 |
> |
Dmat = cm_load(argv[3], btdf->ninc, tvec->nrows, DTfromHeader); |
443 |
|
/* multiply vector through */ |
444 |
< |
vtmp = cm_multiply(Dmat, tvec); |
444 |
> |
ivec = cm_multiply(Dmat, tvec); |
445 |
|
cm_free(Dmat); cm_free(tvec); |
446 |
|
Tmat = cm_bsdf(btdf); /* convert BTDF to matrix */ |
447 |
|
free_BSDF(btdf); |
448 |
< |
cvec = cm_multiply(Tmat, vtmp); /* cvec = component vector */ |
449 |
< |
cm_free(Tmat); cm_free(vtmp); |
448 |
> |
cvec = cm_multiply(Tmat, ivec); /* cvec = component vector */ |
449 |
> |
cm_free(Tmat); cm_free(ivec); |
450 |
|
if (hasDecimalSpec(argv[1])) { /* generating image */ |
451 |
|
SET_FILE_BINARY(stdout); |
452 |
|
newheader("RADIANCE", stdout); |