| 1 |
+ |
#include "color.h" |
| 2 |
|
#ifndef lint |
| 3 |
< |
static const char RCSid[] = "$Id$"; |
| 3 |
> |
static const char RCSid[] = |
| 4 |
> |
"$Id$"; |
| 5 |
|
#endif |
| 6 |
|
/* Main function for generating spectral sky */ |
| 7 |
|
/* Cloudy sky computed as weight average of clear and cie overcast sky */ |
| 10 |
|
#include "copyright.h" |
| 11 |
|
#include "resolu.h" |
| 12 |
|
#include "rtio.h" |
| 11 |
– |
#include "view.h" |
| 13 |
|
#include <ctype.h> |
| 14 |
|
#ifdef _WIN32 |
| 15 |
|
#include <windows.h> |
| 62 |
|
#endif |
| 63 |
|
} |
| 64 |
|
|
| 65 |
+ |
inline static float deg2rad(float deg) { return deg * (PI / 180.); } |
| 66 |
+ |
|
| 67 |
|
static int cvthour(char *hs, int *tsolar, double *hour) { |
| 68 |
|
char *cp = hs; |
| 69 |
|
int i, j; |
| 134 |
|
} |
| 135 |
|
} |
| 136 |
|
|
| 137 |
< |
char *join_paths(const char *path1, const char *path2) { |
| 137 |
> |
static char *join_paths(const char *path1, const char *path2) { |
| 138 |
|
size_t len1 = strlen(path1); |
| 139 |
|
size_t len2 = strlen(path2); |
| 140 |
|
int need_separator = (path1[len1 - 1] != DIRSEP); |
| 162 |
|
return (a * x + b * y) / (a + b); |
| 163 |
|
} |
| 164 |
|
|
| 165 |
< |
static double get_zenith_brightness(const double sundir[3]) { |
| 165 |
> |
static double get_overcast_zenith_brightness(const double sundir[3]) { |
| 166 |
|
double zenithbr; |
| 167 |
|
if (sundir[2] < 0) { |
| 168 |
|
zenithbr = 0; |
| 181 |
|
|
| 182 |
|
static void write_header(const int argc, char **argv, const double cloud_cover, |
| 183 |
|
const double grefl, const int res) { |
| 184 |
+ |
int i; |
| 185 |
|
printf("# "); |
| 186 |
< |
for (int i = 0; i < argc; i++) { |
| 186 |
> |
for (i = 0; i < argc; i++) { |
| 187 |
|
printf("%s ", argv[i]); |
| 188 |
|
} |
| 189 |
|
printf("\n"); |
| 190 |
< |
printf("#Cloud cover: %g\n#Ground reflectance: %g\n#Sky map resolution: %d\n\n", |
| 191 |
< |
cloud_cover, grefl, res); |
| 190 |
> |
printf( |
| 191 |
> |
"#Cloud cover: %g\n#Ground reflectance: %g\n#Sky map resolution: %d\n\n", |
| 192 |
> |
cloud_cover, grefl, res); |
| 193 |
|
} |
| 194 |
|
|
| 195 |
< |
static void write_rad(const double *sun_radiance, const FVECT sundir, |
| 196 |
< |
const char skyfile[PATH_MAX], |
| 197 |
< |
const char grndfile[PATH_MAX]) { |
| 195 |
> |
static void write_rad(const double *sun_radiance, const double intensity, |
| 196 |
> |
const FVECT sundir, const char *ddir, |
| 197 |
> |
const char *skyfile) { |
| 198 |
|
if (sundir[2] > 0) { |
| 199 |
|
printf("void spectrum sunrad\n0\n0\n22 380 780 "); |
| 200 |
< |
/* Normalize to one */ |
| 201 |
< |
double sum = 0.0; |
| 202 |
< |
for (int i = 0; i < NSSAMP; ++i) { |
| 198 |
< |
sum += sun_radiance[i]; |
| 200 |
> |
int i; |
| 201 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 202 |
> |
printf("%.3f ", sun_radiance[i]); |
| 203 |
|
} |
| 200 |
– |
double mean = sum / NSSAMP; |
| 201 |
– |
for (int i = 0; i < NSSAMP; ++i) { |
| 202 |
– |
printf("%.3f ", sun_radiance[i] / mean); |
| 203 |
– |
} |
| 204 |
– |
double intensity = mean * WVLSPAN; |
| 204 |
|
printf("\n\nsunrad light solar\n0\n0\n3 %.1f %.1f %.1f\n\n", intensity, |
| 205 |
|
intensity, intensity); |
| 206 |
|
printf("solar source sun\n0\n0\n4 %f %f %f 0.533\n\n", sundir[0], sundir[1], |
| 207 |
|
sundir[2]); |
| 208 |
|
} |
| 209 |
< |
printf("void specpict skymap\n8 noop %s fisheye.cal fish_u fish_v -rx 90 " |
| 210 |
< |
"-mx\n0\n0\n\n", |
| 209 |
> |
printf("void specpict skyfunc\n5 noop %s . 'Atan2(Dy,Dx)/PI+1' " |
| 210 |
> |
"'1-Acos(Dz)/PI'\n0\n0\n\n", |
| 211 |
|
skyfile); |
| 213 |
– |
|
| 214 |
– |
printf("void specpict grndmap\n8 noop %s fisheye.cal fish_u fish_v -rx -90 " |
| 215 |
– |
"-my\n0\n0\n\n", |
| 216 |
– |
grndfile); |
| 217 |
– |
printf("void mixfunc skyfunc\n4 skymap grndmap if(Dz,1,0) .\n0\n0\n"); |
| 212 |
|
} |
| 213 |
|
|
| 214 |
|
static void write_hsr_header(FILE *fp, RESOLU *res) { |
| 215 |
< |
float wvsplit[4] = {380, 480, 588, |
| 222 |
< |
780}; /* RGB wavelength limits+partitions (nm) */ |
| 215 |
> |
float wvsplit[4] = {380, 480, 588, 780}; |
| 216 |
|
newheader("RADIANCE", fp); |
| 217 |
|
fputncomp(NSSAMP, fp); |
| 218 |
|
fputwlsplit(wvsplit, fp); |
| 221 |
|
fputsresolu(res, fp); |
| 222 |
|
} |
| 223 |
|
|
| 224 |
+ |
static inline float frac(float x) { return x - floor(x); } |
| 225 |
+ |
|
| 226 |
|
int gen_spect_sky(DATARRAY *tau_clear, DATARRAY *scat_clear, |
| 227 |
|
DATARRAY *scat1m_clear, DATARRAY *irrad_clear, |
| 228 |
|
const double cloud_cover, const FVECT sundir, |
| 229 |
< |
const double grefl, const int res, const char *outname) { |
| 229 |
> |
const double grefl, const int res, const char *outname, |
| 230 |
> |
const char *ddir, const double dirnorm, const double difhor) { |
| 231 |
|
char skyfile[PATH_MAX]; |
| 232 |
< |
char grndfile[PATH_MAX]; |
| 233 |
< |
if (!snprintf(skyfile, sizeof(skyfile), "%s_sky.hsr", outname)) { |
| 232 |
> |
if (!snprintf(skyfile, sizeof(skyfile), "%s%c%s_sky.hsr", ddir, DIRSEP, |
| 233 |
> |
outname)) { |
| 234 |
|
fprintf(stderr, "Error setting sky file name\n"); |
| 235 |
|
return 0; |
| 236 |
|
}; |
| 237 |
< |
if (!snprintf(grndfile, sizeof(grndfile), "%s_ground.hsr", outname)) { |
| 238 |
< |
fprintf(stderr, "Error setting ground file name\n"); |
| 239 |
< |
return 0; |
| 244 |
< |
} |
| 245 |
< |
RESOLU rs = {PIXSTANDARD, res, res}; |
| 237 |
> |
int xres = res; |
| 238 |
> |
int yres = xres / 2; |
| 239 |
> |
RESOLU rs = {PIXSTANDARD, xres, yres}; |
| 240 |
|
FILE *skyfp = fopen(skyfile, "w"); |
| 247 |
– |
FILE *grndfp = fopen(grndfile, "w"); |
| 248 |
– |
write_hsr_header(grndfp, &rs); |
| 241 |
|
write_hsr_header(skyfp, &rs); |
| 250 |
– |
VIEW skyview = {VT_ANG, {0., 0., 0.}, {0., 0., 1.}, {0., 1., 0.}, 1., |
| 251 |
– |
180., 180., 0., 0., 0., |
| 252 |
– |
0., {0., 0., 0.}, {0., 0., 0.}, 0., 0.}; |
| 253 |
– |
VIEW grndview = { |
| 254 |
– |
VT_ANG, {0., 0., 0.}, {0., 0., -1.}, {0., 1., 0.}, 1., 180., 180., 0., 0., |
| 255 |
– |
0., 0., {0., 0., 0.}, {0., 0., 0.}, 0., 0.}; |
| 256 |
– |
setview(&skyview); |
| 257 |
– |
setview(&grndview); |
| 242 |
|
|
| 243 |
|
CNDX[3] = NSSAMP; |
| 244 |
|
|
| 245 |
< |
FVECT view_point = {0, 0, ER}; |
| 245 |
> |
FVECT view_point = {0, 0, ER + 10}; |
| 246 |
|
const double radius = VLEN(view_point); |
| 247 |
|
const double sun_ct = fdot(view_point, sundir) / radius; |
| 248 |
< |
for (unsigned int j = 0; j < res; ++j) { |
| 249 |
< |
for (unsigned int i = 0; i < res; ++i) { |
| 250 |
< |
RREAL loc[2]; |
| 251 |
< |
FVECT rorg = {0}; |
| 252 |
< |
FVECT rdir_sky = {0}; |
| 253 |
< |
FVECT rdir_grnd = {0}; |
| 254 |
< |
SCOLOR sky_radiance = {0}; |
| 255 |
< |
SCOLOR ground_radiance = {0}; |
| 248 |
> |
|
| 249 |
> |
double overcast_zenithbr = get_overcast_zenith_brightness(sundir); |
| 250 |
> |
double overcast_grndbr = overcast_zenithbr * GNORM; |
| 251 |
> |
|
| 252 |
> |
double dif_ratio = 1; |
| 253 |
> |
if (difhor > 0) { |
| 254 |
> |
DATARRAY *indirect_irradiance_clear = get_indirect_irradiance(irrad_clear, radius, sun_ct); |
| 255 |
> |
double overcast_ghi = overcast_zenithbr * 7.0 * PI / 9.0; |
| 256 |
> |
double diffuse_irradiance = 0; |
| 257 |
> |
int l; |
| 258 |
> |
for (l = 0; l < NSSAMP; ++l) { |
| 259 |
> |
diffuse_irradiance += indirect_irradiance_clear->arr.d[l] * 20; /* 20nm interval */ |
| 260 |
> |
} |
| 261 |
> |
free(indirect_irradiance_clear); |
| 262 |
> |
diffuse_irradiance = wmean2(diffuse_irradiance, overcast_ghi, cloud_cover); |
| 263 |
> |
if (diffuse_irradiance > 0) { |
| 264 |
> |
dif_ratio = difhor / WHTEFFICACY / diffuse_irradiance / 1.15; /* fudge */ |
| 265 |
> |
} |
| 266 |
> |
} |
| 267 |
> |
int i, j, k; |
| 268 |
> |
for (j = 0; j < yres; ++j) { |
| 269 |
> |
for (i = 0; i < xres; ++i) { |
| 270 |
> |
SCOLOR radiance = {0}; |
| 271 |
|
SCOLR sky_sclr = {0}; |
| 273 |
– |
SCOLR ground_sclr = {0}; |
| 272 |
|
|
| 273 |
< |
pix2loc(loc, &rs, i, j); |
| 274 |
< |
viewray(rorg, rdir_sky, &skyview, loc[0], loc[1]); |
| 275 |
< |
viewray(rorg, rdir_grnd, &grndview, loc[0], loc[1]); |
| 273 |
> |
float px = i / (xres - 1.0); |
| 274 |
> |
float py = j / (yres - 1.0); |
| 275 |
> |
float lambda = ((1 - py) * PI) - (PI / 2.0); |
| 276 |
> |
float phi = (px * 2.0 * PI) - PI; |
| 277 |
|
|
| 278 |
< |
const double mu_sky = fdot(view_point, rdir_sky) / radius; |
| 279 |
< |
const double nu_sky = fdot(rdir_sky, sundir); |
| 278 |
> |
FVECT rdir = {cos(lambda) * cos(phi), cos(lambda) * sin(phi), |
| 279 |
> |
sin(lambda)}; |
| 280 |
|
|
| 281 |
< |
const double mu_grnd = fdot(view_point, rdir_grnd) / radius; |
| 282 |
< |
const double nu_grnd = fdot(rdir_grnd, sundir); |
| 281 |
> |
const double mu = fdot(view_point, rdir) / radius; |
| 282 |
> |
const double nu = fdot(rdir, sundir); |
| 283 |
|
|
| 284 |
< |
get_sky_radiance(scat_clear, scat1m_clear, radius, mu_sky, sun_ct, nu_sky, |
| 285 |
< |
sky_radiance); |
| 286 |
< |
get_ground_radiance(tau_clear, scat_clear, scat1m_clear, irrad_clear, |
| 287 |
< |
view_point, rdir_grnd, radius, mu_grnd, sun_ct, |
| 288 |
< |
nu_grnd, grefl, sundir, ground_radiance); |
| 284 |
> |
/* hit ground */ |
| 285 |
> |
if (rdir[2] < 0) { |
| 286 |
> |
get_ground_radiance(tau_clear, scat_clear, scat1m_clear, irrad_clear, |
| 287 |
> |
view_point, rdir, radius, mu, sun_ct, nu, grefl, |
| 288 |
> |
sundir, radiance); |
| 289 |
> |
} else { |
| 290 |
> |
get_sky_radiance(scat_clear, scat1m_clear, radius, mu, sun_ct, nu, |
| 291 |
> |
radiance); |
| 292 |
> |
} |
| 293 |
|
|
| 294 |
< |
for (int k = 0; k < NSSAMP; ++k) { |
| 295 |
< |
sky_radiance[k] *= WVLSPAN; |
| 293 |
< |
ground_radiance[k] *= WVLSPAN; |
| 294 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 295 |
> |
radiance[k] *= WVLSPAN; |
| 296 |
|
} |
| 297 |
|
|
| 298 |
|
if (cloud_cover > 0) { |
| 299 |
< |
double zenithbr = get_zenith_brightness(sundir); |
| 300 |
< |
double grndbr = zenithbr * GNORM; |
| 301 |
< |
double skybr = get_overcast_brightness(rdir_sky[2], zenithbr); |
| 302 |
< |
for (int k = 0; k < NSSAMP; ++k) { |
| 303 |
< |
sky_radiance[k] = |
| 304 |
< |
wmean2(sky_radiance[k], skybr * D6415[k], cloud_cover); |
| 305 |
< |
ground_radiance[k] = |
| 306 |
< |
wmean2(ground_radiance[k], grndbr * D6415[k], cloud_cover); |
| 299 |
> |
double skybr = get_overcast_brightness(rdir[2], overcast_zenithbr); |
| 300 |
> |
if (rdir[2] < 0) { |
| 301 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 302 |
> |
radiance[k] = wmean2(radiance[k], overcast_grndbr * D6415[k], cloud_cover); |
| 303 |
> |
} |
| 304 |
> |
} else { |
| 305 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 306 |
> |
radiance[k] = wmean2(radiance[k], skybr * D6415[k], cloud_cover); |
| 307 |
> |
} |
| 308 |
|
} |
| 309 |
|
} |
| 310 |
|
|
| 311 |
< |
scolor2scolr(sky_sclr, sky_radiance, 20); |
| 312 |
< |
putbinary(sky_sclr, LSCOLR, 1, skyfp); |
| 311 |
> |
for (k = 0; k < NSSAMP; ++k) { |
| 312 |
> |
radiance[k] *= dif_ratio; |
| 313 |
> |
} |
| 314 |
|
|
| 315 |
< |
scolor2scolr(ground_sclr, ground_radiance, 20); |
| 316 |
< |
putbinary(ground_sclr, LSCOLR, 1, grndfp); |
| 315 |
> |
scolor2scolr(sky_sclr, radiance, NSSAMP); |
| 316 |
> |
putbinary(sky_sclr, LSCOLR, 1, skyfp); |
| 317 |
|
} |
| 318 |
|
} |
| 319 |
|
fclose(skyfp); |
| 316 |
– |
fclose(grndfp); |
| 320 |
|
|
| 321 |
|
/* Get solar radiance */ |
| 322 |
|
double sun_radiance[NSSAMP] = {0}; |
| 323 |
|
get_solar_radiance(tau_clear, scat_clear, scat1m_clear, sundir, radius, |
| 324 |
|
sun_ct, sun_radiance); |
| 325 |
|
if (cloud_cover > 0) { |
| 326 |
< |
double zenithbr = get_zenith_brightness(sundir); |
| 327 |
< |
double skybr = get_overcast_brightness(sundir[2], zenithbr); |
| 328 |
< |
for (int i = 0; i < NSSAMP; ++i) { |
| 326 |
> |
double skybr = get_overcast_brightness(sundir[2], overcast_zenithbr); |
| 327 |
> |
int i; |
| 328 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 329 |
|
sun_radiance[i] = |
| 330 |
|
wmean2(sun_radiance[i], D6415[i] * skybr / WVLSPAN, cloud_cover); |
| 331 |
|
} |
| 332 |
|
} |
| 333 |
|
|
| 334 |
< |
write_rad(sun_radiance, sundir, skyfile, grndfile); |
| 334 |
> |
/* Normalize */ |
| 335 |
> |
double sum = 0.0; |
| 336 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 337 |
> |
sum += sun_radiance[i]; |
| 338 |
> |
} |
| 339 |
> |
double mean = sum / NSSAMP; |
| 340 |
> |
for (i = 0; i < NSSAMP; ++i) { |
| 341 |
> |
sun_radiance[i] /= mean; |
| 342 |
> |
} |
| 343 |
> |
double intensity = mean * WVLSPAN; |
| 344 |
> |
if (dirnorm > 0) { |
| 345 |
> |
intensity = dirnorm / SOLOMG / WHTEFFICACY; |
| 346 |
> |
} |
| 347 |
> |
|
| 348 |
> |
write_rad(sun_radiance, intensity, sundir, ddir, skyfile); |
| 349 |
|
return 1; |
| 350 |
|
} |
| 351 |
|
|
| 368 |
|
static void set_rayleigh_density_profile(Atmosphere *atmos, char *tag, |
| 369 |
|
const int is_summer, |
| 370 |
|
const double s_latitude) { |
| 354 |
– |
/* Set rayleigh density profile */ |
| 371 |
|
if (fabs(s_latitude * 180.0 / PI) > ARCTIC_LAT) { |
| 372 |
|
tag[0] = 's'; |
| 373 |
|
if (is_summer) { |
| 440 |
|
int got_meridian = 0; |
| 441 |
|
double grefl = 0.2; |
| 442 |
|
double ccover = 0.0; |
| 443 |
< |
int res = 128; |
| 443 |
> |
int res = 64; |
| 444 |
|
double aod = AOD0_CA; |
| 445 |
|
char *outname = "out"; |
| 446 |
|
char *mie_path = getpath("mie_ca.dat", getrlibpath(), R_OK); |
| 447 |
|
char mie_name[20] = "mie_ca"; |
| 448 |
|
char lstag[3]; |
| 449 |
|
char *ddir = "."; |
| 450 |
+ |
int i; |
| 451 |
+ |
double dirnorm = 0; /* direct normal illuminance */ |
| 452 |
+ |
double difhor = 0; /* diffuse horizontal illuminance */ |
| 453 |
|
|
| 454 |
< |
if (!strcmp(argv[1], "-defaults")) { |
| 454 |
> |
if (argc == 2 && !strcmp(argv[1], "-defaults")) { |
| 455 |
|
printf("-i %d\t\t\t\t#scattering order\n", sorder); |
| 456 |
|
printf("-g %f\t\t\t#ground reflectance\n", grefl); |
| 457 |
|
printf("-c %f\t\t\t#cloud cover\n", ccover); |
| 459 |
|
printf("-d %f\t\t\t#broadband aerosol optical depth\n", AOD0_CA); |
| 460 |
|
printf("-f %s\t\t\t\t#output name (-f)\n", outname); |
| 461 |
|
printf("-p %s\t\t\t\t#atmos data directory\n", ddir); |
| 462 |
< |
exit(1); |
| 462 |
> |
exit(0); |
| 463 |
|
} |
| 464 |
|
|
| 465 |
|
if (argc < 4) { |
| 466 |
|
fprintf(stderr, |
| 467 |
|
"Usage: %s month day hour -y year -a lat -o lon -m tz -d aod -r " |
| 468 |
< |
"res -n nproc -c ccover -l mie -g grefl -f outpath\n", |
| 468 |
> |
"res -n nproc -c ccover -l mie -L dirnorm_illum difhor_illum " |
| 469 |
> |
"-g grefl -f outpath\n", |
| 470 |
|
argv[0]); |
| 471 |
|
return 0; |
| 472 |
|
} |
| 488 |
|
exit(1); |
| 489 |
|
} |
| 490 |
|
|
| 491 |
< |
for (int i = 4; i < argc; i++) { |
| 491 |
> |
for (i = 4; i < argc; i++) { |
| 492 |
|
if (argv[i][0] == '-') { |
| 493 |
|
switch (argv[i][1]) { |
| 494 |
|
case 'a': |
| 526 |
|
case 'o': |
| 527 |
|
s_longitude = atof(argv[++i]) * (PI / 180.0); |
| 528 |
|
break; |
| 529 |
+ |
case 'L': |
| 530 |
+ |
dirnorm = atof(argv[++i]); |
| 531 |
+ |
difhor = atof(argv[++i]); |
| 532 |
+ |
break; |
| 533 |
|
case 'p': |
| 534 |
|
ddir = argv[++i]; |
| 535 |
|
break; |
| 571 |
|
|
| 572 |
|
char gsdir[PATH_MAX]; |
| 573 |
|
size_t siz = strlen(ddir); |
| 574 |
< |
if (ISDIRSEP(ddir[siz-1])) |
| 575 |
< |
ddir[siz-1] = '\0'; |
| 574 |
> |
if (ISDIRSEP(ddir[siz - 1])) |
| 575 |
> |
ddir[siz - 1] = '\0'; |
| 576 |
|
snprintf(gsdir, PATH_MAX, "%s%catmos_data", ddir, DIRSEP); |
| 553 |
– |
printf("gsdir: %s\n", gsdir); |
| 577 |
|
if (!make_directory(gsdir)) { |
| 578 |
|
fprintf(stderr, "Failed creating atmos_data directory"); |
| 579 |
|
exit(1); |
| 599 |
|
write_header(argc, argv, ccover, grefl, res); |
| 600 |
|
|
| 601 |
|
if (!gen_spect_sky(tau_clear_dp, scat_clear_dp, scat1m_clear_dp, |
| 602 |
< |
irrad_clear_dp, ccover, sundir, grefl, res, outname)) { |
| 602 |
> |
irrad_clear_dp, ccover, sundir, grefl, res, outname, ddir, |
| 603 |
> |
dirnorm, difhor)) { |
| 604 |
|
fprintf(stderr, "gen_spect_sky failed\n"); |
| 605 |
|
exit(1); |
| 606 |
|
} |
