| 1 |
#ifndef lint |
| 2 |
static const char RCSid[] = "$Id: testBSDF.c,v 1.12 2017/05/15 22:15:40 greg Exp $"; |
| 3 |
#endif |
| 4 |
/* |
| 5 |
* Simple test program to demonstrate BSDF operation. |
| 6 |
* |
| 7 |
* G. Ward June 2015 |
| 8 |
*/ |
| 9 |
|
| 10 |
#define _USE_MATH_DEFINES |
| 11 |
#include <stdio.h> |
| 12 |
#include <stdlib.h> |
| 13 |
#include <math.h> |
| 14 |
#include <ctype.h> |
| 15 |
#include "rtio.h" |
| 16 |
#include "bsdf.h" |
| 17 |
|
| 18 |
static void |
| 19 |
Usage(const char *prog) |
| 20 |
{ |
| 21 |
printf("Usage: %s [bsdf_directory]\n", prog); |
| 22 |
printf("Input commands:\n"); |
| 23 |
printf(" L bsdf.xml\t\t\t Load (make active) given BSDF input file\n"); |
| 24 |
printf(" i\t\t\t\t Report general information (metadata)\n"); |
| 25 |
printf(" c\t\t\t\t Report diffuse and specular components\n"); |
| 26 |
printf(" q theta_i phi_i theta_o phi_o\t Query BSDF for given path (CIE-XYZ)\n"); |
| 27 |
printf(" s[r|t][s|d] N theta phi\t Generate N ray directions & colors at given incidence\n"); |
| 28 |
printf(" h[s|d] theta phi\t\t Report hemispherical scattering at given incidence\n"); |
| 29 |
printf(" r[s|d] theta phi\t\t Report hemispherical reflection at given incidence\n"); |
| 30 |
printf(" t[s|d] theta phi\t\t Report hemispherical transmission at given incidence\n"); |
| 31 |
printf(" a theta phi [t2 p2]\t\t Report resolution (in proj. steradians) for given direction(s)\n"); |
| 32 |
printf(" ^D\t\t\t\t Quit program\n"); |
| 33 |
} |
| 34 |
|
| 35 |
static void |
| 36 |
vec_from_deg(FVECT v, double theta, double phi) |
| 37 |
{ |
| 38 |
const double DEG = M_PI/180.; |
| 39 |
|
| 40 |
theta *= DEG; phi *= DEG; |
| 41 |
v[0] = v[1] = sin(theta); |
| 42 |
v[0] *= cos(phi); |
| 43 |
v[1] *= sin(phi); |
| 44 |
v[2] = cos(theta); |
| 45 |
} |
| 46 |
|
| 47 |
static void |
| 48 |
printXYZ(const char *intro, const SDValue *vp) |
| 49 |
{ |
| 50 |
if (vp->cieY <= 1e-9) { |
| 51 |
printf("%s0 0 0\n", intro); |
| 52 |
return; |
| 53 |
} |
| 54 |
printf("%s%.3e %.3e %.3e\n", intro, |
| 55 |
vp->spec.cx/vp->spec.cy*vp->cieY, |
| 56 |
vp->cieY, |
| 57 |
(1.-vp->spec.cx-vp->spec.cy)/ |
| 58 |
vp->spec.cy*vp->cieY); |
| 59 |
} |
| 60 |
|
| 61 |
int |
| 62 |
main(int argc, char *argv[]) |
| 63 |
{ |
| 64 |
const char *directory = NULL; |
| 65 |
char inp[512], path[512]; |
| 66 |
const SDData *bsdf = NULL; |
| 67 |
|
| 68 |
if (argc > 2 || (argc == 2 && argv[1][0] == '-')) { |
| 69 |
Usage(argv[0]); |
| 70 |
return 1; |
| 71 |
} |
| 72 |
if (argc == 2) |
| 73 |
directory = argv[1]; |
| 74 |
|
| 75 |
SDretainSet = SDretainBSDFs; /* keep BSDFs in memory */ |
| 76 |
|
| 77 |
/* loop on command */ |
| 78 |
while (fgets(inp, sizeof(inp), stdin)) { |
| 79 |
int sflags = SDsampAll; |
| 80 |
char *cp = inp; |
| 81 |
char *cp2; |
| 82 |
FVECT vin, vout; |
| 83 |
double proja[2]; |
| 84 |
int n, i; |
| 85 |
SDValue val; |
| 86 |
|
| 87 |
while (isspace(*cp)) cp++; |
| 88 |
|
| 89 |
switch (toupper(*cp)) { |
| 90 |
case 'L': /* load/activate BSDF input */ |
| 91 |
cp2 = cp = sskip2(cp, 1); |
| 92 |
if (!*cp) |
| 93 |
break; |
| 94 |
while (*cp) cp++; |
| 95 |
while (isspace(*--cp)) *cp = '\0'; |
| 96 |
if (directory) |
| 97 |
sprintf(path, "%s/%s", directory, cp2); |
| 98 |
else |
| 99 |
strcpy(path, cp2); |
| 100 |
if (bsdf) |
| 101 |
SDfreeCache(bsdf); |
| 102 |
bsdf = SDcacheFile(path); |
| 103 |
continue; |
| 104 |
case 'I': /* report general info. */ |
| 105 |
if (!bsdf) |
| 106 |
goto noBSDFerr; |
| 107 |
printf("Material: '%s'\n", bsdf->matn); |
| 108 |
printf("Manufacturer: '%s'\n", bsdf->makr); |
| 109 |
printf("Width, Height, Thickness (m): %.4e, %.4e, %.4e\n", |
| 110 |
bsdf->dim[0], bsdf->dim[1], bsdf->dim[2]); |
| 111 |
if (bsdf->mgf) |
| 112 |
printf("Has geometry: %lu bytes\n", |
| 113 |
(unsigned long)strlen(bsdf->mgf)); |
| 114 |
else |
| 115 |
printf("Has geometry: no\n"); |
| 116 |
continue; |
| 117 |
case 'C': /* report constant values */ |
| 118 |
if (!bsdf) |
| 119 |
goto noBSDFerr; |
| 120 |
if (bsdf->rf) |
| 121 |
printf("Peak front hemispherical reflectance: %.3e\n", |
| 122 |
bsdf->rLambFront.cieY + |
| 123 |
bsdf->rf->maxHemi); |
| 124 |
if (bsdf->rb) |
| 125 |
printf("Peak back hemispherical reflectance: %.3e\n", |
| 126 |
bsdf->rLambBack.cieY + |
| 127 |
bsdf->rb->maxHemi); |
| 128 |
if (bsdf->tf) |
| 129 |
printf("Peak front hemispherical transmittance: %.3e\n", |
| 130 |
bsdf->tLamb.cieY + bsdf->tf->maxHemi); |
| 131 |
if (bsdf->tb) |
| 132 |
printf("Peak back hemispherical transmittance: %.3e\n", |
| 133 |
bsdf->tLamb.cieY + bsdf->tb->maxHemi); |
| 134 |
printXYZ("Diffuse Front Reflectance: ", &bsdf->rLambFront); |
| 135 |
printXYZ("Diffuse Back Reflectance: ", &bsdf->rLambBack); |
| 136 |
printXYZ("Diffuse Transmittance: ", &bsdf->tLamb); |
| 137 |
continue; |
| 138 |
case 'Q': /* query BSDF value */ |
| 139 |
if (!bsdf) |
| 140 |
goto noBSDFerr; |
| 141 |
if (!*sskip2(cp,4)) |
| 142 |
break; |
| 143 |
vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2))); |
| 144 |
vec_from_deg(vout, atof(sskip2(cp,3)), atof(sskip2(cp,4))); |
| 145 |
if (!SDreportError(SDevalBSDF(&val, vout, vin, bsdf), stderr)) |
| 146 |
printXYZ("", &val); |
| 147 |
continue; |
| 148 |
case 'S': /* sample BSDF */ |
| 149 |
if (!bsdf) |
| 150 |
goto noBSDFerr; |
| 151 |
if (!*sskip2(cp,3)) |
| 152 |
break; |
| 153 |
if (toupper(cp[1]) == 'R') { |
| 154 |
sflags &= ~SDsampT; |
| 155 |
++cp; |
| 156 |
} else if (toupper(cp[1]) == 'T') { |
| 157 |
sflags &= ~SDsampR; |
| 158 |
++cp; |
| 159 |
} |
| 160 |
if (toupper(cp[1]) == 'S') |
| 161 |
sflags &= ~SDsampDf; |
| 162 |
else if (toupper(cp[1]) == 'D') |
| 163 |
sflags &= ~SDsampSp; |
| 164 |
i = n = atoi(sskip2(cp,1)); |
| 165 |
vec_from_deg(vin, atof(sskip2(cp,2)), atof(sskip2(cp,3))); |
| 166 |
while (i-- > 0) { |
| 167 |
VCOPY(vout, vin); |
| 168 |
if (SDreportError(SDsampBSDF(&val, vout, |
| 169 |
(i+rand()*(1./(RAND_MAX+.5)))/(double)n, |
| 170 |
sflags, bsdf), stderr)) |
| 171 |
break; |
| 172 |
printf("%.8f %.8f %.8f ", vout[0], vout[1], vout[2]); |
| 173 |
printXYZ("", &val); |
| 174 |
} |
| 175 |
continue; |
| 176 |
case 'H': /* hemispherical values */ |
| 177 |
case 'R': |
| 178 |
case 'T': |
| 179 |
if (!bsdf) |
| 180 |
goto noBSDFerr; |
| 181 |
if (!*sskip2(cp,2)) |
| 182 |
break; |
| 183 |
if (toupper(cp[0]) == 'R') |
| 184 |
sflags &= ~SDsampT; |
| 185 |
else if (toupper(cp[0]) == 'T') |
| 186 |
sflags &= ~SDsampR; |
| 187 |
if (toupper(cp[1]) == 'S') |
| 188 |
sflags &= ~SDsampDf; |
| 189 |
else if (toupper(cp[1]) == 'D') |
| 190 |
sflags &= ~SDsampSp; |
| 191 |
vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2))); |
| 192 |
printf("%.4e\n", SDdirectHemi(vin, sflags, bsdf)); |
| 193 |
continue; |
| 194 |
case 'A': /* resolution in proj. steradians */ |
| 195 |
if (!bsdf) |
| 196 |
goto noBSDFerr; |
| 197 |
if (!*sskip2(cp,2)) |
| 198 |
break; |
| 199 |
vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2))); |
| 200 |
if (*sskip2(cp,4)) { |
| 201 |
vec_from_deg(vout, atof(sskip2(cp,3)), atof(sskip2(cp,4))); |
| 202 |
if (SDreportError(SDsizeBSDF(proja, vout, vin, |
| 203 |
SDqueryMin+SDqueryMax, bsdf), stderr)) |
| 204 |
continue; |
| 205 |
} else if (SDreportError(SDsizeBSDF(proja, vin, NULL, |
| 206 |
SDqueryMin+SDqueryMax, bsdf), stderr)) |
| 207 |
continue; |
| 208 |
printf("%.4e %.4e\n", proja[0], proja[1]); |
| 209 |
continue; |
| 210 |
} |
| 211 |
Usage(argv[0]); |
| 212 |
continue; |
| 213 |
noBSDFerr: |
| 214 |
fprintf(stderr, "%s: First, use 'L' command to load BSDF\n", argv[0]); |
| 215 |
} |
| 216 |
return 0; |
| 217 |
} |
