10 |
|
#include <ctype.h> |
11 |
|
#include "standard.h" |
12 |
|
#include "platform.h" |
13 |
+ |
#include "paths.h" |
14 |
|
#include "color.h" |
15 |
|
#include "resolu.h" |
16 |
|
#include "bsdf.h" |
17 |
+ |
#include "bsdf_m.h" |
18 |
|
|
19 |
|
char *progname; /* global argv[0] */ |
20 |
|
|
293 |
|
} |
294 |
|
} |
295 |
|
|
296 |
< |
/* convert a BSDF to our matrix representation */ |
296 |
> |
/* Convert a BSDF to our matrix representation */ |
297 |
|
static CMATRIX * |
298 |
< |
cm_bsdf(const struct BSDF_data *bsdf) |
298 |
> |
cm_bsdf(const COLOR bsdfLamb, const COLOR specCol, const SDMat *bsdf) |
299 |
|
{ |
300 |
|
CMATRIX *cm = cm_alloc(bsdf->nout, bsdf->ninc); |
301 |
|
int nbadohm = 0; |
302 |
|
int nneg = 0; |
303 |
|
int r, c; |
304 |
< |
|
304 |
> |
/* reciprocity is "transparent" */ |
305 |
|
for (c = 0; c < cm->ncols; c++) { |
306 |
< |
float dom = getBSDF_incohm(bsdf,c); |
307 |
< |
FVECT v; |
308 |
< |
|
307 |
< |
if (dom <= .0) { |
308 |
< |
nbadohm++; |
309 |
< |
continue; |
310 |
< |
} |
311 |
< |
if (!getBSDF_incvec(v,bsdf,c) || v[2] > FTINY) |
312 |
< |
error(USER, "illegal incoming BTDF direction"); |
313 |
< |
dom *= -v[2]; |
306 |
> |
const double dom = mBSDF_incohm(bsdf,c); |
307 |
> |
/* projected solid angle */ |
308 |
> |
nbadohm += (dom <= 0); |
309 |
|
|
310 |
|
for (r = 0; r < cm->nrows; r++) { |
311 |
< |
float f = BSDF_value(bsdf,c,r); |
311 |
> |
float f = mBSDF_value(bsdf,c,r); |
312 |
|
COLORV *mp = cm_lval(cm,r,c); |
313 |
< |
|
314 |
< |
if (f <= .0) { |
313 |
> |
/* check BSDF value */ |
314 |
> |
if ((f <= 0) | (dom <= 0)) { |
315 |
|
nneg += (f < -FTINY); |
316 |
|
f = .0f; |
317 |
|
} |
318 |
< |
mp[0] = mp[1] = mp[2] = f * dom; |
318 |
> |
copycolor(mp, specCol); |
319 |
> |
scalecolor(mp, f); |
320 |
> |
addcolor(mp, bsdfLamb); |
321 |
> |
scalecolor(mp, dom); |
322 |
|
} |
323 |
|
} |
324 |
< |
if (nneg || nbadohm) { |
324 |
> |
if (nneg | nbadohm) { |
325 |
|
sprintf(errmsg, |
326 |
|
"BTDF has %d negatives and %d bad incoming solid angles", |
327 |
|
nneg, nbadohm); |
330 |
|
return(cm); |
331 |
|
} |
332 |
|
|
333 |
+ |
/* Load and convert a matrix BSDF from the given XML file */ |
334 |
+ |
static CMATRIX * |
335 |
+ |
cm_loadBSDF(char *fname) |
336 |
+ |
{ |
337 |
+ |
CMATRIX *Tmat; |
338 |
+ |
char *fpath; |
339 |
+ |
SDError ec; |
340 |
+ |
SDData myBSDF; |
341 |
+ |
COLOR bsdfLamb, specCol; |
342 |
+ |
/* find path to BSDF file */ |
343 |
+ |
fpath = getpath(fname, getrlibpath(), R_OK); |
344 |
+ |
if (fpath == NULL) { |
345 |
+ |
sprintf(errmsg, "cannot find BSDF file '%s'", fname); |
346 |
+ |
error(USER, errmsg); |
347 |
+ |
} |
348 |
+ |
SDclearBSDF(&myBSDF, fname); /* load XML and check type */ |
349 |
+ |
ec = SDloadFile(&myBSDF, fpath); |
350 |
+ |
if (ec) |
351 |
+ |
error(USER, transSDError(ec)); |
352 |
+ |
if (myBSDF.tf == NULL || myBSDF.tf->ncomp != 1 || |
353 |
+ |
myBSDF.tf->comp[0].func != &SDhandleMtx) { |
354 |
+ |
sprintf(errmsg, "unsupported BSDF '%s'", fpath); |
355 |
+ |
error(USER, errmsg); |
356 |
+ |
} |
357 |
+ |
/* convert BTDF to matrix */ |
358 |
+ |
ccy2rgb(&myBSDF.tLamb.spec, myBSDF.tLamb.cieY/PI, bsdfLamb); |
359 |
+ |
ccy2rgb(&myBSDF.tf->comp[0].cspec[0], 1., specCol); |
360 |
+ |
Tmat = cm_bsdf(bsdfLamb, specCol, (SDMat *)myBSDF.tf->comp[0].dist); |
361 |
+ |
/* free BSDF and return */ |
362 |
+ |
SDfreeBSDF(&myBSDF); |
363 |
+ |
return(Tmat); |
364 |
+ |
} |
365 |
+ |
|
366 |
|
/* Sum together a set of images and write result to stdout */ |
367 |
|
static int |
368 |
|
sum_images(const char *fspec, const CMATRIX *cv, FILE *fout) |
382 |
|
int dt, xr, yr; |
383 |
|
COLORV *psp; |
384 |
|
/* check for zero */ |
385 |
< |
if ((scv[RED] == .0) & (scv[GRN] == .0) & (scv[BLU] == .0)) |
385 |
> |
if ((scv[RED] == 0) & (scv[GRN] == 0) & (scv[BLU] == 0)) |
386 |
|
continue; |
387 |
|
/* open next picture */ |
388 |
|
sprintf(fname, fspec, i); |
444 |
|
static int |
445 |
|
hasNumberFormat(const char *s) |
446 |
|
{ |
447 |
< |
while (*s && *s != '%') |
448 |
< |
s++; |
449 |
< |
if (!*s) |
450 |
< |
return(0); |
451 |
< |
do |
452 |
< |
++s; |
453 |
< |
while (isdigit(*s)); |
454 |
< |
|
455 |
< |
return(*s == 'd' | *s == 'i' | *s == 'o' | *s == 'x' | *s == 'X'); |
447 |
> |
while (*s) { |
448 |
> |
while (*s != '%') |
449 |
> |
if (!*s++) |
450 |
> |
return(0); |
451 |
> |
if (*++s == '%') { /* ignore "%%" */ |
452 |
> |
++s; |
453 |
> |
continue; |
454 |
> |
} |
455 |
> |
while (isdigit(*s)) /* field length */ |
456 |
> |
++s; |
457 |
> |
/* field we'll use? */ |
458 |
> |
if ((*s == 'd') | (*s == 'i') | (*s == 'o') | |
459 |
> |
(*s == 'x') | (*s == 'X')) |
460 |
> |
return(1); |
461 |
> |
} |
462 |
> |
return(0); /* didn't find one */ |
463 |
|
} |
464 |
|
|
465 |
|
int |
478 |
|
|
479 |
|
if (argc > 3) { /* VTDs expression */ |
480 |
|
CMATRIX *svec, *Dmat, *Tmat, *ivec; |
443 |
– |
struct BSDF_data *btdf; |
481 |
|
/* get sky vector */ |
482 |
|
svec = cm_load(argv[4], 0, 1, DTascii); |
483 |
|
/* load BSDF */ |
484 |
< |
btdf = load_BSDF(argv[2]); |
448 |
< |
if (btdf == NULL) |
449 |
< |
return(1); |
484 |
> |
Tmat = cm_loadBSDF(argv[2]); |
485 |
|
/* load Daylight matrix */ |
486 |
< |
Dmat = cm_load(argv[3], btdf->ninc, svec->nrows, DTfromHeader); |
486 |
> |
Dmat = cm_load(argv[3], Tmat->ncols, svec->nrows, DTfromHeader); |
487 |
|
/* multiply vector through */ |
488 |
|
ivec = cm_multiply(Dmat, svec); |
489 |
|
cm_free(Dmat); cm_free(svec); |
455 |
– |
Tmat = cm_bsdf(btdf); /* convert BTDF to matrix */ |
456 |
– |
free_BSDF(btdf); |
490 |
|
cvec = cm_multiply(Tmat, ivec); /* cvec = component vector */ |
491 |
|
cm_free(Tmat); cm_free(ivec); |
492 |
|
} else { /* else just use sky vector */ |