ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/radiance/ray/src/util/evalglare.c

Comparing ray/src/util/evalglare.c (file contents):
Revision 2.1 by greg, Wed Aug 12 23:07:59 2015 UTC vs.
Revision 2.8 by greg, Fri Aug 31 16:01:45 2018 UTC

#	Line 1 | Line 1
1	<	/* EVALGLARE V1.17
2	<	* Evalglare Software License, Version 1.0
1	>	#ifndef lint
2	>	static const char RCSid[] = "$Id$";
3	>	#endif
4	>	/* EVALGLARE V2.06
5	>	* Evalglare Software License, Version 2.0
6		*
7	<	* Copyright (c) 1995 - 2015 Fraunhofer ISE, EPFL.
7	>	* Copyright (c) 1995 - 2016 Fraunhofer ISE, EPFL.
8		* All rights reserved.
9		*
10		*
#	Line 20 | Line 23
23		* 3. The end-user documentation included with the redistribution,
24		*           if any, must include the following acknowledgments:
25		*             "This product includes the evalglare software,
26	<	developed at Fraunhofer ISE by J. Wienold" and
26	>	developed at Fraunhofer ISE and EPFL by J. Wienold" and
27		*             "This product includes Radiance software
28		*                 (http://radsite.lbl.gov/)
29		*                 developed by the Lawrence Berkeley National Laboratory
#	Line 28 | Line 31
31		*       Alternately, this acknowledgment may appear in the software itself,
32		*       if and wherever such third-party acknowledgments normally appear.
33		*
34	<	* 4. The names "Evalglare," and "Fraunhofer ISE" must
34	>	* 4. The names "Evalglare," "EPFL" and "Fraunhofer ISE" must
35		*       not be used to endorse or promote products derived from this
36		*       software without prior written permission. For written
37		*       permission, please contact [email protected]
38		*
39		* 5. Products derived from this software may not be called "evalglare",
40		*       nor may "evalglare" appear in their name, without prior written
41	<	*       permission of Fraunhofer ISE.
41	>	*       permission of EPFL.
42		*
43		* Redistribution and use in source and binary forms, WITH
44		* modification, are permitted provided that the following conditions
#	Line 45 | Line 48
48		* conditions 1.-5. apply
49		*
50		* 6. In order to ensure scientific correctness, any modification in source code imply fulfilling all following comditions:
51	<	*     a) A written permission from Fraunhofer ISE. For written permission, please contact [email protected].
51	>	*     a) A written permission from EPFL. For written permission, please contact [email protected].
52		*     b) The permission can be applied via email and must contain the applied changes in source code and at least two example calculations,
53		*        comparing the results of the modified version and the current version of evalglare.
54		*     b) Any redistribution of a modified version of evalglare must contain following note:
#	Line 275 | Line 278
278		remove of age factor due to non proven statistical evidence
279		*/
280
281	<	#define EVALGLARE
281	>	/* evalglare.c, v1.18 2015/11/10 add masking, UDP, PSGV, DGI_mod, UGR_exp and zoning. For zoning and band luminance, a statistical package from C. Reetz was added in order to derive median, std_dev, percentiles.
282	>	memory leakage was checked and is o.k.
283	>	*/
284
285	+	/* evalglare.c, v1.19 2015/12/04 sorting subroutines in statistical package changed by. C. Reetz, adding Position index weighted Luminance evaluation (mean and median of entire image, only in detailed output available)
286	+	*/
287	+	/* evalglare.c, v1.20 2015/12/21 removing -ansi gcc-option in makefile for the standalone version, adding DGR as output since VCP equation seems not to match with original publication
288	+	*/
289	+	/* evalglare.c, v1.21 2016/03/15 add a new pixel-overflow-correction option -N
290	+	*/
291	+	/* evalglare.c, v1.22 2016/03/22 fixed problem using -N option and angular distance calculation, when actual pixel equals disk-center (arccos returned nan)
292	+	*/
293	+	/* evalglare.c, v1.23 2016/04/18 fixed problem making black corners for -vth fish-eye images
294	+	*/
295	+	/* evalglare.c, v1.24 2016/04/26 significant speed improvement for 2nd glare source scan: for other glare sources will not be searched any more, when the 8 surrounding pixels have the same glare source number! Smaller speed improvement in the first glare source scan: remembering if pixel before was also a glare source, then no search for surrounding glare sources is applied.
296	+	changed masking threshold to 0.05 cd/m2
297	+	*/
298	+	/* evalglare.c, v1.25 2016/04/27 removed the change on the first glare source scan: in few cases glare sources are not merged together in the same way as before. Although the difference is marginal, this algorithm was removed in order to be consistent to the existing results.
299	+	*/
300	+	/* evalglare.c, v1.26 2016/04/28 removed the bug Lb getting nan in case all glare source pixels are above the peak extraction limit.
301	+	The calculation of the average source lumiance and solid angle was adapted to be more robust for extreme cases.
302	+	In case no glare source is found, the values of the glare metrics, relying only on glare sources, is set to zero (100 for VCP) to avoid nan and -inf in the output.
303	+	Changed glare section output when 0 glare source are found to have the same amount of columns than when glare sources are found
304	+	*/
305	+	/* evalglare.c, v1.27 2016/06/13 include a warning, if -vtv is in the header. Check, if the corners are black AND -vtv is used ->stopping (stopping can be avoided by using the forcing option -f ). Check, if an invalid exposure is in the header -> stopping in any case.
306	+	*/
307	+	/* evalglare.c, v1.28 2016/07/08 small code changes in the section of calculating the E_glare (disability) for each glare source.
308	+	*/
309	+	/* evalglare.c, v1.29 2016/07/12 change threshold for the black corner to 2cd/m2.
310	+	*/
311	+	/* evalglare.c, v1.30 2016/07/28 change zonal output: If just one zone is specified, only one zone shows up in the output (bug removal).
312	+	*/
313	+	/* evalglare.c, v1.31 2016/08/02  bug removal: default output did not calculate the amout of glare sources before and therefore no_glaresources was set to zero causing dgi,ugr being set to zero as well. Now renumbering of the glare sources and calculation of the amount of glare sources is done for all output versions.
314	+	*/
315	+	/* evalglare.c, v2.00 2016/11/15  add of a second fast calculation mode for annual calculations, activted by -2. Output: dgp,ugr
316	+	*/
317	+	/* evalglare.c, v2.01 2016/11/16  change of -2 option (now -2 dir_illum). External provision of the direct illuminance necessary, since the sun interpolation of daysim is causing problems in calculation of the background luminance.
318	+	*/
319	+	/* evalglare.c, v2.02 2017/02/28  change of warning message, when invalid exposure setting is found. Reason: tab removal is not in all cases the right measure - it depends which tool caused the invalid exposure entry   */
320	+
321	+	/* evalglare.c, v2.03 2017/08/04  ad of -O option - disk replacement by providing luminance, not documented
322	+	*/
323	+
324	+	/* evalglare.c, v2.04 2017/08/04  adding -q option: use of Ev/pi as background luminance. not documented. no combination with -n option!!!
325	+	*/
326	+
327	+	/* evalglare.c, v2.05 2018/08/28  change of the -q option for the choice of the background luminance calculation mode: 0: CIE method (Ev-Edir)/pi, 1: mathematical correct average background luminance, 2: Ev/pi.
328	+	change of default options:
329	+	- cosinus weighted calculation of the background luminance (according to CIE) is now default.
330	+	- absolute threshold for the glare source detection is now default (2000cd/m2), based on study of C. Pierson
331	+	*/
332	+
333	+	/* evalglare.c, v2.06 2018/08/29
334	+	change of default value of multiplier b to 5.0, if task options (-t or -T ) are activated AND -b NOT used. To be downward compatible when using the task method.
335	+	*/
336	+
337	+
338	+	#define EVALGLARE
339		#define PROGNAME "evalglare"
340	<	#define VERSION "1.17 release 15.07.2015 by EPFL, J.Wienold"
340	>	#define VERSION "2.06 release 29.08.2018 by EPFL, J.Wienold"
341		#define RELEASENAME PROGNAME " " VERSION
342
343	<	#include "rtio.h"
285	<	#include "platform.h"
343	>
344		#include "pictool.h"
345	+	#include "rtio.h"
346		#include <math.h>
347		#include <string.h>
348	+	#include "platform.h"
349	+	#include "muc_randvar.h"
350	+
351		char *progname;
352
353		/* subroutine to add a pixel to a glare source */
#	Line 561 | Line 623 | double get_task_lum(pict * p, int x, int y, float r, i
623		return av_lum;
624		}
625
564	–	/* subroutine for calculation of band luminance */
565	–	double get_band_lum(pict * p, float r, int task_color)
566	–	{
567	–	int x_min, x_max, y_min, y_max, ix, iy, y_mid;
568	–	double r_actual, av_lum, omega_sum, act_lum;
626
627
571	–	x_max = pict_get_xsize(p) - 1;
572	–	y_max = pict_get_ysize(p) - 1;
573	–	x_min = 0;
574	–	y_min = 0;
575	–	y_mid = rint(y_max/2);
628
629
578	–
579	–	av_lum = 0.0;
580	–	omega_sum = 0.0;
581	–
582	–	for (iy = y_min; iy <= y_max; iy++) {
583	–	for (ix = x_min; ix <= x_max; ix++) {
584	–
585	–	/*                      if (DOT(pict_get_cached_dir(p,ix,iy),p->view.vdir) < 0.0)
586	–	continue;*/
587	–	r_actual =
588	–	acos(DOT(pict_get_cached_dir(p, ix, y_mid),
589	–	pict_get_cached_dir(p, ix, iy))) ;
590	–	act_lum = luminance(pict_get_color(p, ix, iy));
591	–
592	–	if ((r_actual <= r) || (iy == y_mid) ) {
593	–	act_lum = luminance(pict_get_color(p, ix, iy));
594	–	av_lum += pict_get_omega(p, ix, iy) * act_lum;
595	–	omega_sum += pict_get_omega(p, ix, iy);
596	–	if (task_color == 1) {
597	–	pict_get_color(p, ix, iy)[RED] = 0.0;
598	–	pict_get_color(p, ix, iy)[GRN] = act_lum / WHTEFFICACY / CIE_gf;
599	–	pict_get_color(p, ix, iy)[BLU] = 0.0;
600	–	}
601	–	}
602	–	}
603	–	}
604	–
605	–	av_lum = av_lum / omega_sum;
606	–	/*    printf("average luminance of band %f \n",av_lum);*/
607	–	/*      printf("solid angle of band %f \n",omega_sum);*/
608	–	return av_lum;
609	–	}
610	–
611	–
612	–
613	–
614	–
630		/* subroutine for coloring the glare sources
631		red is used only for explicit call of the subroutine with acol=0  , e.g. for disability glare
632		-1: set to grey*/
#	Line 623 | Line 638 | int setglcolor(pict * p, int x, int y, int acol, int u
638		l=u_r+u_g+u_b ;
639
640		pcol[RED][0] = 1.0 / CIE_rf;
641	<	pcol[GRN][0] = 0.;
642	<	pcol[BLU][0] = 0.;
641	>	pcol[GRN][0] = 0.0 / CIE_gf;
642	>	pcol[BLU][0] = 0.0 / CIE_bf;
643
644	<	pcol[RED][1] = 0.;
644	>	pcol[RED][1] = 0.0 / CIE_rf;
645		pcol[GRN][1] = 1.0 / CIE_gf;
646	<	pcol[BLU][1] = 0.;
646	>	pcol[BLU][1] = 0.0 / CIE_bf;
647
648	<	pcol[RED][2] = 0.;
649	<	pcol[GRN][2] = 0.;
650	<	pcol[BLU][2] = 1 / CIE_bf;
648	>	pcol[RED][2] = 0.15 / CIE_rf;
649	>	pcol[GRN][2] = 0.15 / CIE_gf;
650	>	pcol[BLU][2] = 0.7 / CIE_bf;
651
652	<	pcol[RED][3] = 1.0 / (1.0 - CIE_bf);
653	<	pcol[GRN][3] = 1.0 / (1.0 - CIE_bf);
654	<	pcol[BLU][3] = 0.;
652	>	pcol[RED][3] = .5 / CIE_rf;
653	>	pcol[GRN][3] = .5 / CIE_gf;
654	>	pcol[BLU][3] = 0.0 / CIE_bf;
655
656	<	pcol[RED][4] = 1.0 / (1.0 - CIE_gf);
657	<	pcol[GRN][4] = 0.;
658	<	pcol[BLU][4] = 1.0 / (1.0 - CIE_gf);
656	>	pcol[RED][4] = .5 / CIE_rf;
657	>	pcol[GRN][4] = .0 / CIE_gf;
658	>	pcol[BLU][4] = .5 / CIE_bf ;
659
660	<	pcol[RED][5] = 0.;
661	<	pcol[GRN][5] = 1.0 / (1.0 - CIE_rf);
662	<	pcol[BLU][5] = 1.0 / (1.0 - CIE_rf);
660	>	pcol[RED][5] = .0 / CIE_rf;
661	>	pcol[GRN][5] = .5 / CIE_gf;
662	>	pcol[BLU][5] = .5 / CIE_bf;
663
664	<	pcol[RED][6] = 0.;
665	<	pcol[GRN][6] = 1.0 / (1.0 - CIE_rf);
666	<	pcol[BLU][6] = 1.0 / (1.0 - CIE_rf);
664	>	pcol[RED][6] = 0.333 / CIE_rf;
665	>	pcol[GRN][6] = 0.333 / CIE_gf;
666	>	pcol[BLU][6] = 0.333 / CIE_bf;
667
668
669		pcol[RED][999] = 1.0 / WHTEFFICACY;
#	Line 659 | Line 674 | int setglcolor(pict * p, int x, int y, int acol, int u
674		pcol[RED][998] = u_r /(l* CIE_rf) ;
675		pcol[GRN][998] = u_g /(l* CIE_gf);
676		pcol[BLU][998] = u_b /(l* CIE_bf);
677	<	/*        printf("CIE_rf,CIE_gf,CIE_bf,l=%f %f %f %f\n",CIE_rf,CIE_gf,CIE_bf,l);*/
677	>	/*        printf("CIE_rf,CIE_gf,CIE_bf,l=%f %f %f %f %f\n",CIE_rf,CIE_gf,CIE_bf,l,WHTEFFICACY); */
678		icol = acol ;
679		if ( acol == -1) {icol=999;
680		}else{if (acol>0){icol = acol % 5 +1;
#	Line 672 | Line 687 | int setglcolor(pict * p, int x, int y, int acol, int u
687		pict_get_color(p, x, y)[RED] = pcol[RED][icol] * act_lum / WHTEFFICACY;
688		pict_get_color(p, x, y)[GRN] = pcol[GRN][icol] * act_lum / WHTEFFICACY;
689		pict_get_color(p, x, y)[BLU] = pcol[BLU][icol] * act_lum / WHTEFFICACY;
690	<
690	>	/*        printf("x,y,lum_before,lum_after,diff %i %i %f %f %f\n",x,y, act_lum,luminance(pict_get_color(p, x, y)), act_lum-luminance(pict_get_color(p, x, y))); */
691		return icol;
692		}
693
#	Line 724 | Line 739 | void add_secondary_gs(pict * p, int x, int y, float r,
739
740		/* color pixel of gs */
741
742	<	icol = setglcolor(p, x, y, act_gs, uniform_gs, u_r, u_g , u_b);
742	>	/*              icol = setglcolor(p, x, y, act_gs, uniform_gs, u_r, u_g , u_b); */
743
744		}
745		}
#	Line 764 | Line 779 | void split_pixel_from_gs(pict * p, int x, int y, int n
779
780		/* color pixel of new gs */
781
782	<	icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b);
782	>	/*      icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b); */
783	>
784
769	–
785		}
786
787		/* subroutine for the calculation of the position index */
#	Line 797 | Line 812 | float get_posindex(pict * p, float x, float y, int pos
812		tau = tau * deg;
813		sigma = sigma * deg;
814
815	+	if (postype == 1) {
816	+	/* KIM  model */
817	+	posindex = exp ((sigma-(-0.000009*tau*tau*tau+0.0014*tau*tau+0.0866*tau+21.633))/(-0.000009*tau*tau*tau+0.0013*tau*tau+0.0853*tau+8.772));
818	+	}else{
819	+	/* Guth model, equation from IES lighting handbook */
820		posindex =
821		exp((35.2 - 0.31889 * tau -
822		1.22 * exp(-2 * tau / 9)) / 1000 * sigma + (21 +
#	Line 818 | Line 838 | float get_posindex(pict * p, float x, float y, int pos
838
839		posindex = 1 + fact * r;
840		}
841	<	if (posindex > 16)
841	>	if (posindex > 16)
842		posindex = 16;
843	+	}
844
845		return posindex;
846
#	Line 1032 | Line 1053 | return;
1053
1054		}
1055
1056	<	/* subroutine for the calculation of the daylight glare index */
1056	>	/* subroutine for the calculation of the daylight glare index DGI*/
1057
1058
1059		float get_dgi(pict * p, float lum_backg, int igs, int posindex_2)
#	Line 1059 | Line 1080 | float get_dgi(pict * p, float lum_backg, int igs, int
1080		return dgi;
1081
1082		}
1083	+	/* subroutine for the calculation of the modified daylight glare index DGI_mod (Fisekis2003)
1084	+	several glare sources are taken into account and summed up, original equation has no summary
1085	+	*/
1086
1087	+
1088	+	float get_dgi_mod(pict * p, float lum_a, int igs, int posindex_2)
1089	+	{
1090	+	float dgi_mod, sum_glare, omega_s;
1091	+	int i;
1092	+
1093	+
1094	+	sum_glare = 0;
1095	+	omega_s = 0;
1096	+
1097	+	for (i = 0; i <= igs; i++) {
1098	+
1099	+	if (pict_get_npix(p, i) > 0) {
1100	+	omega_s =
1101	+	pict_get_av_omega(p, i) / get_posindex(p,pict_get_av_posx(p,i), pict_get_av_posy(p,i),posindex_2) /
1102	+	get_posindex(p, pict_get_av_posx(p, i), pict_get_av_posy(p, i), posindex_2);
1103	+	sum_glare += 0.478 * pow(pict_get_av_lum(p, i), 1.6) * pow(omega_s,0.8) / (pow(lum_a,0.85) + 0.07 * pow(pict_get_av_omega(p, i),0.5) * pict_get_av_lum(p, i));
1104	+	/*    printf("i,sum_glare %i %f\n",i,sum_glare); */
1105	+	}
1106	+	}
1107	+	dgi_mod = 10 * log10(sum_glare);
1108	+
1109	+	return dgi_mod;
1110	+
1111	+	}
1112	+
1113		/* subroutine for the calculation of the daylight glare probability */
1114		double
1115		get_dgp(pict * p, double E_v, int igs, double a1, double a2, double a3,
#	Line 1100 | Line 1150 | get_dgp(pict * p, double E_v, int igs, double a1, doub
1150		}
1151
1152		/* subroutine for the calculation of the visual comfort probability */
1153	<	float get_vcp(pict * p, double lum_a, int igs, int posindex_2)
1153	>	float get_dgr(pict * p, double lum_a, int igs, int posindex_2)
1154		{
1155	<	float vcp;
1156	<	double sum_glare, dgr;
1155	>	float dgr;
1156	>	double sum_glare;
1157		int i, i_glare;
1158
1159
#	Line 1129 | Line 1179 | float get_vcp(pict * p, double lum_a, int igs, int pos
1179		}
1180		dgr = pow(sum_glare, pow(i_glare, -0.0914));
1181
1182	+
1183	+
1184	+	return dgr;
1185	+
1186	+	}
1187	+
1188	+	float get_vcp(float dgr )
1189	+	{
1190	+	float vcp;
1191	+
1192		vcp = 50 * erf((6.347 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1193		if (dgr > 750) {
1194		vcp = 0;
#	Line 1136 | Line 1196 | float get_vcp(pict * p, double lum_a, int igs, int pos
1196		if (dgr < 20) {
1197		vcp = 100;
1198		}
1139	–
1140	–
1199		return vcp;
1200
1201		}
1202
1203	+
1204		/* subroutine for the calculation of the unified glare rating */
1205		float get_ugr(pict * p, double lum_backg, int igs, int posindex_2)
1206		{
#	Line 1165 | Line 1224 | float get_ugr(pict * p, double lum_backg, int igs, int
1224		}
1225		}
1226		ugr = 8 * log10(0.25 / lum_backg * sum_glare);
1227	<
1227	>	if (sum_glare==0) {
1228	>	ugr=0.0;
1229	>	}
1230	>	if (lum_backg<=0) {
1231	>	ugr=-99.0;
1232	>	}
1233	>
1234		return ugr;
1235
1236		}
1237	+	/* subroutine for the calculation of the experimental unified glare rating (Fisekis 2003)*/
1238	+	float get_ugr_exp(pict * p, double lum_backg, double lum_a, int igs, int posindex_2)
1239	+	{
1240	+	float ugr_exp;
1241	+	double sum_glare;
1242	+	int i, i_glare;
1243
1244
1245	+	sum_glare = 0;
1246	+	i_glare = 0;
1247	+	for (i = 0; i <= igs; i++) {
1248	+
1249	+	if (pict_get_npix(p, i) > 0) {
1250	+	i_glare = i_glare + 1;
1251	+	sum_glare +=
1252	+	pow(1 /get_posindex(p, pict_get_av_posx(p, i), pict_get_av_posy(p, i), posindex_2),2) *pict_get_av_lum(p, i)* pict_get_av_omega(p, i);
1253	+
1254	+	}
1255	+	}
1256	+	ugr_exp =8 * log10(lum_a) + 8 * log10(sum_glare/lum_backg);
1257	+
1258	+	return ugr_exp;
1259	+
1260	+	}
1261	+	/* subroutine for the calculation of the unified glare probability (Hirning 2014)*/
1262	+	float get_ugp(pict * p, double lum_backg, int igs, int posindex_2)
1263	+	{
1264	+	float ugp;
1265	+	double sum_glare;
1266	+	int i, i_glare;
1267	+
1268	+
1269	+	sum_glare = 0;
1270	+	i_glare = 0;
1271	+	for (i = 0; i <= igs; i++) {
1272	+
1273	+	if (pict_get_npix(p, i) > 0) {
1274	+	i_glare = i_glare + 1;
1275	+	sum_glare +=
1276	+	pow(pict_get_av_lum(p, i) /
1277	+	get_posindex(p, pict_get_av_posx(p, i),
1278	+	pict_get_av_posy(p, i), posindex_2),
1279	+	2) * pict_get_av_omega(p, i);
1280	+
1281	+	}
1282	+	}
1283	+	ugp = 0.26 * log10(0.25 / lum_backg * sum_glare);
1284	+
1285	+	return ugp;
1286	+
1287	+	}
1288	+
1289	+
1290		/* subroutine for the calculation of the disability glare according to Poynter */
1291		float get_disability(pict * p, double lum_backg, int igs)
1292		{
#	Line 1218 | Line 1334 | float get_disability(pict * p, double lum_backg, int i
1334
1335		/* subroutine for the calculation of the cie glare index */
1336
1337	<	float
1222	<	get_cgi(pict * p, double E_v, double E_v_dir, int igs, int posindex_2)
1337	>	float get_cgi(pict * p, double E_v, double E_v_dir, int igs, int posindex_2)
1338		{
1339		float cgi;
1340		double sum_glare;
#	Line 1243 | Line 1358 | get_cgi(pict * p, double E_v, double E_v_dir, int igs,
1358		cgi = 8 * log10((2 * (1 + E_v_dir / 500) / E_v) * sum_glare);
1359
1360		return cgi;
1361	+	}
1362
1363	+	/* subroutine for the calculation of the PGSV; is only applied, when masking is done, since it refers only to the window. Important: masking area must be the window! */
1364	+	float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av)
1365	+	{
1366	+	float pgsv;
1367	+	double Lb;
1368	+
1369	+	Lb = (E_v-E_mask)/1.414213562373;
1370	+
1371	+	pgsv =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1372	+
1373	+
1374	+	return pgsv;
1375		}
1376
1377	+	/* subroutine for the calculation of the PGSV_saturation; is only applied, when masking is done, since it refers only to the window. Important: masking area must be the window! */
1378	+	float get_pgsv_sat(double E_v)
1379	+	{
1380	+	float pgsv_sat;
1381
1382	+	pgsv_sat =3.3-(0.57+3.3)/pow((1+E_v/1.414213562373/1250),1.7);
1383	+
1384	+
1385	+	return pgsv_sat;
1386	+	}
1387	+
1388	+
1389	+
1390	+
1391		#ifdef  EVALGLARE
1392
1393
#	Line 1258 | Line 1399 | int main(int argc, char **argv)
1399		{
1400		#define CLINEMAX 4095 /* memory allocated for command line string */
1401		pict *p = pict_create();
1402	<	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, y1, fill, yfillmax, yfillmin,
1403	<	ext_vill, set_lum_max, set_lum_max2, task_color, i_splitstart,
1404	<	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,
1405	<	igs, actual_igs, icol, xt, yt, change, before_igs, sgs, splithigh,uniform_gs,
1406	<	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx, rmy,apply_disability,band_calc,band_color;
1407	<	double  lum_total_max,age_corr_factor,age,dgp_ext,dgp,low_light_corr,omega_cos_contr, setvalue, lum_ideal, E_v_contr, sigma,
1408	<	E_vl_ext, lum_max, new_lum_max, r_center,
1409	<	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,
1410	<	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang,
1411	<	l_max, lum_backg, lum_backg_cos, omega_sources, lum_sources,
1412	<	lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum;
1413	<	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit,
1402	>	pict *pm = pict_create();
1403	>	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1404	>	ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,
1405	>	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,x_zone,y_zone, i_z1, i_z2, thres_activate,
1406	>	igs, actual_igs, lastpixelwas_gs, icol, xt, yt, change,checkpixels, before_igs, sgs, splithigh,uniform_gs,x_max, y_max,y_mid,
1407	>	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx,rmy,apply_disability,band_calc,band_color,masking,i_mask,no_glaresources,force;
1408	>	double  LUM_replace,lum_total_max,age_corr_factor,age,dgp_ext,dgp,low_light_corr,omega_cos_contr, setvalue, lum_ideal, E_v_contr, sigma,om,delta_E,
1409	>	E_vl_ext, lum_max, new_lum_max, r_center, ugp, ugr_exp, dgi_mod,lum_a, pgsv,E_v_mask,pgsv_sat,angle_disk,dist,n_corner_px,zero_corner_px,
1410	>	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,dir_ill,
1411	>	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang, angle_z1, angle_z2,per_95_band,per_75_band,pos,
1412	>	l_max, lum_backg, lum_backg_cos, omega_sources, lum_sources,per_75_mask,per_95_mask,per_75_z1,per_95_z1,per_75_z2,per_95_z2,
1413	>	lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum,
1414	>	lum_mask[1],lum_mask_av,lum_mask_std[1],lum_mask_median[1],omega_mask,bbox[2],
1415	>	lum_band[1],lum_band_av,lum_band_std[1],lum_band_median[1],omega_band,bbox_band[2],
1416	>	lum_z1[1],lum_z1_av,lum_z1_std[1],lum_z1_median[1],omega_z1,bbox_z1[2],
1417	>	lum_z2[1],lum_z2_av,lum_z2_std[1],lum_z2_median[1],omega_z2,bbox_z2[2],
1418	>	lum_pos[1],lum_nopos_median[1],lum_pos_median[1],lum_pos2_median[1],lum_pos_mean,lum_pos2_mean;
1419	>	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,
1420		abs_max, Lveil;
1421	<	char file_out[500], file_out2[500], version[500];
1421	>	char maskfile[500],file_out[500], file_out2[500], version[500];
1422		char *cline;
1423		VIEW userview = STDVIEW;
1424		int gotuserview = 0;
1425	+	struct muc_rvar* s_mask;
1426	+	s_mask = muc_rvar_create();
1427	+	muc_rvar_set_dim(s_mask, 1);
1428	+	muc_rvar_clear(s_mask);
1429	+	struct muc_rvar* s_band;
1430	+	s_band = muc_rvar_create();
1431	+	muc_rvar_set_dim(s_band, 1);
1432	+	muc_rvar_clear(s_band);
1433	+	struct muc_rvar* s_z1;
1434	+	s_z1 = muc_rvar_create();
1435	+	muc_rvar_set_dim(s_z1, 1);
1436	+	muc_rvar_clear(s_z1);
1437
1438	+	struct muc_rvar* s_z2;
1439	+	s_z2 = muc_rvar_create();
1440	+	muc_rvar_set_dim(s_z2, 1);
1441	+	muc_rvar_clear(s_z2);
1442	+
1443	+	struct muc_rvar* s_noposweight;
1444	+	s_noposweight = muc_rvar_create();
1445	+	muc_rvar_set_dim(s_noposweight, 1);
1446	+	muc_rvar_clear(s_noposweight);
1447	+
1448	+	struct muc_rvar* s_posweight;
1449	+	s_posweight = muc_rvar_create();
1450	+	muc_rvar_set_dim(s_posweight, 1);
1451	+	muc_rvar_clear(s_posweight);
1452	+
1453	+	struct muc_rvar* s_posweight2;
1454	+	s_posweight2 = muc_rvar_create();
1455	+	muc_rvar_set_dim(s_posweight2, 1);
1456	+	muc_rvar_clear(s_posweight2);
1457	+
1458		/*set required user view parameters to invalid values*/
1459	<	uniform_gs = 0;
1459	>	dir_ill=0.0;
1460	>	delta_E=0.0;
1461	>	no_glaresources=0;
1462	>	n_corner_px=0;
1463	>	zero_corner_px=0;
1464	>	force=0;
1465	>	dist=0.0;
1466	>	u_r=0.33333;
1467	>	u_g=0.33333;
1468	>	u_b=0.33333;
1469	>	band_angle=0;
1470	>	angle_z1=0;
1471	>	angle_z2=0;
1472	>	x_zone=0;
1473	>	y_zone=0;
1474	>	per_75_z2=0;
1475	>	per_95_z2=0;
1476	>	lum_pos_mean=0;
1477	>	lum_pos2_mean=0;
1478	>	lum_band_av = 0.0;
1479	>	omega_band = 0.0;
1480	>	pgsv = 0.0 ;
1481	>	pgsv_sat = 0.0 ;
1482	>	E_v_mask = 0.0;
1483	>	lum_z1_av = 0.0;
1484	>	omega_z1 = 0.0;
1485	>	lum_z2_av = 0.0;
1486	>	omega_z2 = 0.0 ;
1487	>	i_z1 = 0;
1488	>	i_z2 = 0;
1489	>	zones = 0;
1490	>	lum_z2_av = 0.0;
1491	>	uniform_gs = 0;
1492		apply_disability = 0;
1493		disability_thresh = 0;
1494		Lveil_cie_sum=0.0;
#	Line 1297 | Line 1508 | int main(int argc, char **argv)
1508		omegat = 0.0;
1509		yt = 0;
1510		xt = 0;
1511	+	x_disk=0;
1512	+	y_disk=0;
1513	+	angle_disk=0;
1514		yfillmin = 0;
1515		yfillmax = 0;
1516		cut_view = 0;
#	Line 1305 | Line 1519 | int main(int argc, char **argv)
1519		omega_cos_contr = 0.0;
1520		lum_ideal = 0.0;
1521		max_angle = 0.2;
1522	<	lum_thres = 5.0;
1522	>	lum_thres = 2000.0;
1523		task_lum = 0;
1524		sgs = 0;
1525		splithigh = 1;
#	Line 1323 | Line 1537 | int main(int argc, char **argv)
1537		c1 = 5.87e-05;
1538		c2 = 0.092;
1539		c3 = 0.159;
1540	<	non_cos_lb = 1;
1540	>	non_cos_lb = 0;
1541		posindex_2 = 0;
1542		task_color = 0;
1543		limit = 50000.0;
1544		set_lum_max = 0;
1545		set_lum_max2 = 0;
1546	+	img_corr=0;
1547		abs_max = 0;
1548		progname = argv[0];
1549		E_v_contr = 0.0;
1550	<	strcpy(version, "1.15 release 05.02.2015 by J.Wienold");
1550	>	strcpy(version, "1.19 release 09.12.2015 by J.Wienold");
1551		low_light_corr=1.0;
1552		output = 0;
1553		calc_vill = 0;
1554		band_avlum = -99;
1555		band_calc = 0;
1556	+	masking = 0;
1557	+	lum_mask[0]=0.0;
1558	+	lum_mask_av=0.0;
1559	+	omega_mask=0.0;
1560	+	i_mask=0;
1561	+	actual_igs=0;
1562	+	LUM_replace=0;
1563	+	thres_activate=0;
1564		/* command line for output picture*/
1565
1566		cline = (char *) malloc(CLINEMAX+1);
#	Line 1379 | Line 1602 | int main(int argc, char **argv)
1602		printf("age factor not supported any more \n");
1603		exit(1);
1604		break;
1605	+	case 'A':
1606	+	masking = 1;
1607	+	detail_out = 1;
1608	+	strcpy(maskfile, argv[++i]);
1609	+	pict_read(pm,maskfile );
1610	+
1611	+	break;
1612		case 'b':
1613		lum_thres = atof(argv[++i]);
1614	+	thres_activate = 1;
1615		break;
1616		case 'c':
1617		checkfile = 1;
#	Line 1398 | Line 1629 | int main(int argc, char **argv)
1629		case 's':
1630		sgs = 1;
1631		break;
1632	+	case 'f':
1633	+	force = 1;
1634	+	break;
1635		case 'k':
1636		apply_disability = 1;
1637		disability_thresh = atof(argv[++i]);
#	Line 1406 | Line 1640 | int main(int argc, char **argv)
1640		case 'p':
1641		posindex_picture = 1;
1642		break;
1643	+	case 'P':
1644	+	posindex_2 = atoi(argv[++i]);
1645	+	break;
1646	+
1647
1648		case 'y':
1649		splithigh = 1;
#	Line 1436 | Line 1674 | int main(int argc, char **argv)
1674		detail_out2 = 1;
1675		break;
1676		case 'm':
1677	+	img_corr = 1;
1678		set_lum_max = 1;
1679		lum_max = atof(argv[++i]);
1680		new_lum_max = atof(argv[++i]);
#	Line 1444 | Line 1683 | int main(int argc, char **argv)
1683		break;
1684
1685		case 'M':
1686	+	img_corr = 1;
1687		set_lum_max2 = 1;
1688		lum_max = atof(argv[++i]);
1689		E_vl_ext = atof(argv[++i]);
1690		strcpy(file_out2, argv[++i]);
1691		/*                      printf("max lum set to %f\n",new_lum_max);*/
1692		break;
1693	<	case 'n':
1693	>	case 'N':
1694	>	img_corr = 1;
1695	>	set_lum_max2 = 2;
1696	>	x_disk = atoi(argv[++i]);
1697	>	y_disk = atoi(argv[++i]);
1698	>	angle_disk = atof(argv[++i]);
1699	>	E_vl_ext = atof(argv[++i]);
1700	>	strcpy(file_out2, argv[++i]);
1701	>	/*                      printf("max lum set to %f\n",new_lum_max);*/
1702	>	break;
1703	>	case 'O':
1704	>	img_corr = 1;
1705	>	set_lum_max2 = 3;
1706	>	x_disk = atoi(argv[++i]);
1707	>	y_disk = atoi(argv[++i]);
1708	>	angle_disk = atof(argv[++i]);
1709	>	LUM_replace = atof(argv[++i]);
1710	>	strcpy(file_out2, argv[++i]);
1711	>	/*                      printf("max lum set to %f\n",new_lum_max);*/
1712	>	break;
1713	>
1714	>
1715	>	/* deactivated          case 'n':
1716		non_cos_lb = 0;
1717		break;
1718	+	*/
1719	+	case 'q':
1720	+	non_cos_lb = atoi(argv[++i]);
1721	+	break;
1722
1723		case 't':
1724		task_lum = 1;
#	Line 1469 | Line 1735 | int main(int argc, char **argv)
1735		omegat = atof(argv[++i]);
1736		task_color = 1;
1737		break;
1738	+	case 'l':
1739	+	zones = 1;
1740	+	x_zone = atoi(argv[++i]);
1741	+	y_zone = atoi(argv[++i]);
1742	+	angle_z1 = atof(argv[++i]);
1743	+	angle_z2 = -1;
1744	+	break;
1745	+	case 'L':
1746	+	zones = 2;
1747	+	x_zone = atoi(argv[++i]);
1748	+	y_zone = atoi(argv[++i]);
1749	+	angle_z1 = atof(argv[++i]);
1750	+	angle_z2 = atof(argv[++i]);
1751	+	break;
1752	+
1753	+
1754		case 'B':
1755		band_calc = 1;
1756		band_angle = atof(argv[++i]);
#	Line 1505 | Line 1787 | int main(int argc, char **argv)
1787		case '1':
1788		output = 1;
1789		break;
1790	+	case '2':
1791	+	output = 2;
1792	+	dir_ill = atof(argv[++i]);
1793	+	break;
1794
1795		case 'v':
1796		if (argv[i][2] == '\0') {
#	Line 1534 | Line 1820 | int main(int argc, char **argv)
1820		}
1821		}
1822
1823	+	/* set multiplier for task method to 5, if not specified */
1824	+
1825	+	if ( task_lum == 1 && thres_activate == 0){
1826	+	lum_thres = 5.0;
1827	+	}
1828		/*fast calculation, if gendgp_profile is used: No Vertical illuminance calculation, only dgp is calculated*/
1829
1830	<	if (output == 1 && ext_vill == 1) {
1830	>	if (output == 1 && ext_vill == 1 ) {
1831		calcfast=1;
1832		}
1833	+
1834	+	if (output == 2 && ext_vill == 1 ) {
1835	+	calcfast=2;
1836	+	}
1837	+
1838	+	/*masking and zoning cannot be applied at the same time*/
1839
1840	+	if (masking ==1 && zones >0) {
1841	+	fprintf(stderr,  " masking and zoning cannot be activated at the same time!\n");
1842	+	exit(1);
1843	+	}
1844	+
1845		/* read picture file */
1846		if (i == argc) {
1847		SET_FILE_BINARY(stdin);
#	Line 1573 | Line 1875 | if (output == 1 && ext_vill == 1) {
1875		return EXIT_FAILURE;
1876		}
1877
1878	+
1879	+
1880		/*                fprintf(stderr,"Picture read!");*/
1881
1882		/* command line for output picture*/
1883
1884		pict_set_comment(p, cline);
1885
1886	+	/* several checks */
1887		if (p->view.type == VT_PAR) {
1888	<	fprintf(stderr, "wrong view type! must not be parallel ! \n");
1888	>	fprintf(stderr, "error: wrong view type! must not be parallel ! \n");
1889		exit(1);
1890		}
1891
1892	+	if (p->view.type == VT_PER) {
1893	+	fprintf(stderr, "warning: image has perspective view type specified in header ! \n");
1894	+	}
1895
1896	+	if (masking == 1) {
1897	+
1898	+	if (!pict_get_xsize(p)==pict_get_xsize(pm) || !pict_get_ysize(p)==pict_get_ysize(pm)) {
1899	+	fprintf(stderr, "error: masking image has other resolution than main image ! \n");
1900	+	fprintf(stderr, "size must be identical \n");
1901	+	printf("resolution main image : %dx%d\n",pict_get_xsize(p),pict_get_ysize(p));
1902	+	printf("resolution masking image : %dx%d\n",pict_get_xsize(pm),pict_get_ysize(pm));
1903	+	exit(1);
1904	+
1905	+	}
1906	+
1907	+	}
1908	+	/*      printf("resolution: %dx%d\n",pict_get_xsize(p),pict_get_ysize(p)); */
1909	+
1910		/* Check size of search radius */
1911		rmx = (pict_get_xsize(p) / 2);
1912		rmy = (pict_get_ysize(p) / 2);
#	Line 1629 | Line 1951 | if (output == 1 && ext_vill == 1) {
1951		avlum = 0.0;
1952		pict_new_gli(p);
1953		igs = 0;
1954	+	pict_get_z1_gsn(p,igs) = 0;
1955	+	pict_get_z2_gsn(p,igs) = 0;
1956
1957	+
1958		/* cut out GUTH field of view and exit without glare evaluation */
1959		if (cut_view==2) {
1960		if (cut_view_type==1) {
#	Line 1696 | Line 2021 | if (cut_view==2) {
2021		if (calcfast == 0) {
2022		for (x = 0; x < pict_get_xsize(p); x++)
2023		for (y = 0; y < pict_get_ysize(p); y++) {
2024	+	lum = luminance(pict_get_color(p, x, y));
2025	+	dist=sqrt((x-rmx)*(x-rmx)+(y-rmy)*(y-rmy));
2026	+	if (dist>((rmx+rmy)/2)) {
2027	+	n_corner_px=n_corner_px+1;
2028	+	if (lum<7.0) {
2029	+	zero_corner_px=zero_corner_px+1;
2030	+	}
2031	+	}
2032	+
2033	+
2034		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2035		if (pict_is_validpixel(p, x, y)) {
1701	–	lum = luminance(pict_get_color(p, x, y));
2036		if (fill == 1 && y >= yfillmax) {
2037		y1 = y - 1;
2038		lum = luminance(pict_get_color(p, x, y1));
#	Line 1711 | Line 2045 | if (cut_view==2) {
2045		abs_max = lum;
2046		}
2047		/* set luminance restriction, if -m is set */
2048	<	if (set_lum_max == 1 && lum >= lum_max) {
2049	<	pict_get_color(p, x, y)[RED] = new_lum_max / 179.0;
2050	<	pict_get_color(p, x, y)[GRN] = new_lum_max / 179.0;
2051	<	pict_get_color(p, x, y)[BLU] = new_lum_max / 179.0;
2052	<	/*                                    printf("old lum, new lum %f %f \n",lum,luminance(pict_get_color(p,x,y))); */
2053	<	lum = luminance(pict_get_color(p, x, y));
2048	>	if (img_corr == 1 ) {
2049	>	if (set_lum_max == 1 && lum >= lum_max) {
2050	>	pict_get_color(p, x, y)[RED] = new_lum_max / 179.0;
2051	>	pict_get_color(p, x, y)[GRN] = new_lum_max / 179.0;
2052	>	pict_get_color(p, x, y)[BLU] = new_lum_max / 179.0;
2053	>	/*                                                      printf("old lum, new lum %f %f \n",lum,luminance(pict_get_color(p,x,y))); */
2054	>	lum = luminance(pict_get_color(p, x, y));
2055	>	}
2056	>	if (set_lum_max2 == 1 && lum >= lum_max) {
2057
2058	<	}
2059	<	if (set_lum_max2 == 1 && lum >= lum_max) {
2058	>	E_v_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* lum;
2059	>	omega_cos_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* 1;
2060	>	}
2061	>	if (set_lum_max2 == 2 ) {
2062	>	r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2063	>	if (x_disk == x && y_disk==y ) r_actual=0.0;
2064
2065	<	E_v_contr +=
2066	<	DOT(p->view.vdir,
2067	<	pict_get_cached_dir(p, x,
2068	<	y)) * pict_get_omega(p,
2069	<	x,
2070	<	y)
2071	<	* lum;
2072	<	omega_cos_contr +=
2073	<	DOT(p->view.vdir,
2074	<	pict_get_cached_dir(p, x,
1734	<	y)) * pict_get_omega(p,
1735	<	x,
1736	<	y)
1737	<	* 1;
2065	>	act_lum = luminance(pict_get_color(p, x, y));
2066	>
2067	>	if (r_actual <= angle_disk) {
2068	>	E_v_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* lum;
2069	>	omega_cos_contr += DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* 1;
2070	>	}
2071	>
2072	>
2073	>
2074	>	}
2075		}
2076	+	om = pict_get_omega(p, x, y);
2077	+	sang += om;
2078	+	E_v += DOT(p->view.vdir, pict_get_cached_dir(p, x,y)) * om *lum;
2079	+	avlum += om * lum;
2080	+	pos=get_posindex(p, x, y,posindex_2);
2081
2082	+	lum_pos[0]=lum;
2083	+	muc_rvar_add_sample(s_noposweight,lum_pos);
2084	+	lum_pos[0]=lum/pos;
2085	+	lum_pos_mean+=lum_pos[0]*om;
2086	+	muc_rvar_add_sample(s_posweight, lum_pos);
2087	+	lum_pos[0]=lum_pos[0]/pos;
2088	+	lum_pos2_mean+=lum_pos[0]*om;
2089	+	muc_rvar_add_sample(s_posweight2,lum_pos);
2090
2091	<	sang += pict_get_omega(p, x, y);
2092	<	E_v +=
1743	<	DOT(p->view.vdir,
1744	<	pict_get_cached_dir(p, x,
1745	<	y)) * pict_get_omega(p, x,
1746	<	y) *
1747	<	lum;
1748	<	avlum +=
1749	<	pict_get_omega(p, x,
1750	<	y) * luminance(pict_get_color(p, x,
1751	<	y));
2091	>
2092	>
2093		} else {
2094		pict_get_color(p, x, y)[RED] = 0.0;
2095		pict_get_color(p, x, y)[GRN] = 0.0;
2096		pict_get_color(p, x, y)[BLU] = 0.0;
2097
2098		}
2099	<	}
2099	>	}else {
2100	>	pict_get_color(p, x, y)[RED] = 0.0;
2101	>	pict_get_color(p, x, y)[GRN] = 0.0;
2102	>	pict_get_color(p, x, y)[BLU] = 0.0;
2103	>
2104	>	}
2105		}
2106
2107	<	if (set_lum_max2 == 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) {
2107	>	/* check if image has black corners AND a perspective view */
2108
2109	+	if (zero_corner_px/n_corner_px > 0.70 && (p->view.type == VT_PER) ) {
2110	+	printf (" corner pixels are to  %f %% black! \n",zero_corner_px/n_corner_px*100);
2111	+	printf("error! The image has black corners AND header contains a perspective view type definition !!!\n") ;
2112	+
2113	+	if (force==0) {
2114	+	printf("stopping...!!!!\n") ;
2115	+
2116	+	exit(1);
2117	+	}
2118	+	}
2119	+
2120	+
2121	+
2122	+
2123	+	lum_pos_mean= lum_pos_mean/sang;
2124	+	lum_pos2_mean= lum_pos2_mean/sang;
2125	+
2126	+	if ((set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0 ) || set_lum_max2==3) {
2127	+
2128	+	if (set_lum_max2<3){
2129		lum_ideal = (E_vl_ext - E_v + E_v_contr) / omega_cos_contr;
2130	+	if (set_lum_max2 == 2 && lum_ideal >= 2e9) {
2131	+	printf("warning! luminance of replacement pixels would be larger than 2e9 cd/m2. Value set to 2e9cd/m2!\n") ;
2132	+	}
2133	+
2134		if (lum_ideal > 0 && lum_ideal < setvalue) {
2135		setvalue = lum_ideal;
2136		}
2137	<	printf
1768	<	("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2137	>	printf("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2138		lum_ideal, setvalue, E_vl_ext, E_v, E_v_contr);
2139	+	}else{setvalue=LUM_replace;
2140	+	}
2141
2142	<
2142	>
2143		for (x = 0; x < pict_get_xsize(p); x++)
2144		for (y = 0; y < pict_get_ysize(p); y++) {
2145		if (pict_get_hangle
2146		(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2147		if (pict_is_validpixel(p, x, y)) {
2148		lum = luminance(pict_get_color(p, x, y));
2149	+
2150	+
2151		if (set_lum_max2 == 1 && lum >= lum_max) {
2152
2153		pict_get_color(p, x, y)[RED] =
#	Line 1784 | Line 2157 | if (cut_view==2) {
2157		pict_get_color(p, x, y)[BLU] =
2158		setvalue / 179.0;
2159
2160	+	}else{ if(set_lum_max2 >1 ) {
2161	+	r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2162	+	if (x_disk == x && y_disk==y ) r_actual=0.0;
2163	+
2164	+	if (r_actual <= angle_disk) {
2165	+
2166	+	pict_get_color(p, x, y)[RED] =
2167	+	setvalue / 179.0;
2168	+	pict_get_color(p, x, y)[GRN] =
2169	+	setvalue / 179.0;
2170	+	pict_get_color(p, x, y)[BLU] =
2171	+	setvalue / 179.0;
2172	+
2173	+	}
2174		}
2175	+	}
2176		}
2177		}
2178		}
2179	+
2180
2181		pict_write(p, file_out2);
2182	<
2182	>	exit(1);
2183		}
2184		if (set_lum_max == 1) {
2185		pict_write(p, file_out2);
#	Line 1850 | Line 2239 | if (cut_view==1) {
2239		lum_source = lum_thres;
2240		}
2241
2242	<	/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2242	>	/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2243
2244		/* first glare source scan: find primary glare sources */
2245	<	for (x = 0; x < pict_get_xsize(p); x++)
2245	>	for (x = 0; x < pict_get_xsize(p); x++) {
2246	>	/*                lastpixelwas_gs=0; */
2247		for (y = 0; y < pict_get_ysize(p); y++) {
2248		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2249		if (pict_is_validpixel(p, x, y)) {
#	Line 1862 | Line 2252 | if (cut_view==1) {
2252		if (act_lum >lum_total_max) {
2253		lum_total_max=act_lum;
2254		}
2255	<
2256	<	actual_igs =
2257	<	find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2255	>	/* speed improvement first scan: when last pixel was glare source, then use this glare source number instead of searching.
2256	>	has been deactivated with v1.25
2257	>
2258	>	if (lastpixelwas_gs==0 || search_pix <= 1.0 ) { */
2259	>	actual_igs = find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2260	>	/*  }*/
2261		if (actual_igs == 0) {
2262		igs = igs + 1;
2263		pict_new_gli(p);
2264		pict_get_lum_min(p, igs) = HUGE_VAL;
2265		pict_get_Eglare(p,igs) = 0.0;
2266		pict_get_Dglare(p,igs) = 0.0;
2267	+	pict_get_z1_gsn(p,igs) = 0;
2268	+	pict_get_z2_gsn(p,igs) = 0;
2269		actual_igs = igs;
2270	+
2271		}
2272	<	icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2272	>	/* no coloring any more here            icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2273		pict_get_gsn(p, x, y) = actual_igs;
2274		pict_get_pgs(p, x, y) = 1;
2275		add_pixel_to_gs(p, x, y, actual_igs);
2276	+	/*                                                lastpixelwas_gs=actual_igs; */
2277
2278		} else {
2279		pict_get_pgs(p, x, y) = 0;
2280	+	/*                                               lastpixelwas_gs=0;*/
2281		}
2282		}
2283		}
2284	<	}
2284	>	}
2285	>	}
2286		/*      pict_write(p,"firstscan.pic");   */
2287
2288	<	if (calcfast == 1 ) {
2288	>
2289	>
2290	>
2291	>	if (calcfast ==1 || search_pix <= 1.0 || calcfast == 2 ) {
2292		skip_second_scan=1;
2293		}
2294	+
2295
2296		/* second glare source scan: combine glare sources facing each other */
2297		change = 1;
2298	+	i = 0;
2299		while (change == 1 && skip_second_scan==0) {
2300		change = 0;
2301	<	for (x = 0; x < pict_get_xsize(p); x++)
2301	>	i = i+1;
2302	>	for (x = 0; x < pict_get_xsize(p); x++) {
2303		for (y = 0; y < pict_get_ysize(p); y++) {
1899	–	before_igs = pict_get_gsn(p, x, y);
2304		if (pict_get_hangle
2305		(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2306	<	if (pict_is_validpixel(p, x, y) && before_igs > 0) {
2306	>	checkpixels=1;
2307	>	before_igs = pict_get_gsn(p, x, y);
2308	>
2309	>	/* speed improvement: search for other nearby glare sources only, when at least one adjacend pixel has another glare source number  */
2310	>	if (x >1 && x<pict_get_xsize(p)-2 && y >1 && y<pict_get_ysize(p)-2 )   {
2311	>	x1=x-1;
2312	>	x2=x+1;
2313	>	y1=y-1;
2314	>	y2=y+1;
2315	>	if (before_igs == pict_get_gsn(p, x1, y) && before_igs == pict_get_gsn(p, x2, y) && before_igs == pict_get_gsn(p, x, y1) && before_igs == pict_get_gsn(p, x, y2) && before_igs == pict_get_gsn(p, x1, y1) && before_igs == pict_get_gsn(p, x2, y1) && before_igs == pict_get_gsn(p, x1, y2) && before_igs == pict_get_gsn(p, x2, y2) ) {
2316	>	checkpixels = 0;
2317	>	actual_igs = before_igs;
2318	>	}  }
2319	>
2320	>
2321	>	if (pict_is_validpixel(p, x, y) && before_igs > 0 && checkpixels==1) {
2322		actual_igs =
2323		find_near_pgs(p, x, y, max_angle, before_igs,
2324		igs, 1);
#	Line 1908 | Line 2327 | if (calcfast == 1 ) {
2327		}
2328		if (before_igs > 0) {
2329		actual_igs = pict_get_gsn(p, x, y);
2330	<	icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2330	>	/*      icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2331		}
2332
2333		}
2334		}
2335		}
2336		/*      pict_write(p,"secondscan.pic");*/
2337	+	}}
2338
1919	–	}
1920	–
2339		/*smoothing: add secondary glare sources */
2340		i_max = igs;
2341		if (sgs == 1) {
#	Line 1974 | Line 2392 | if (calcfast == 1 ) {
2392		if (i_splitstart == (igs + 1)) {
2393		igs = igs + 1;
2394		pict_new_gli(p);
2395	+	pict_get_z1_gsn(p,igs) = 0;
2396	+	pict_get_z2_gsn(p,igs) = 0;
2397	+
2398		pict_get_Eglare(p,igs) = 0.0;
2399		pict_get_Dglare(p,igs) = 0.0;
2400		pict_get_lum_min(p, igs) =
#	Line 1987 | Line 2408 | if (calcfast == 1 ) {
2408		if (i_split == 0) {
2409		igs = igs + 1;
2410		pict_new_gli(p);
2411	+	pict_get_z1_gsn(p,igs) = 0;
2412	+	pict_get_z2_gsn(p,igs) = 0;
2413	+
2414		pict_get_Eglare(p,igs) = 0.0;
2415		pict_get_Dglare(p,igs) = 0.0;
2416		pict_get_lum_min(p, igs) =
#	Line 2023 | Line 2447 | if (calcfast == 1 ) {
2447		if (before_igs > 0) {
2448		actual_igs =
2449		pict_get_gsn(p, x, y);
2450	<	icol =
2450	>	/*                                                                                     icol =
2451		setglcolor(p, x, y,
2452	<	actual_igs, uniform_gs, u_r, u_g , u_b);
2452	>	actual_igs, uniform_gs, u_r, u_g , u_b);*/
2453		}
2454
2455		}
#	Line 2040 | Line 2464 | if (calcfast == 1 ) {
2464		}
2465		}
2466
2467	<	/* calculation of direct vertical illuminance for CGI and for disability glare*/
2467	>	/* calculation of direct vertical illuminance for CGI and for disability glare, coloring glare sources*/
2468
2469	<
2046	<	if (calcfast == 0) {
2469	>	if (calcfast == 0 || calcfast == 2) {
2470		for (x = 0; x < pict_get_xsize(p); x++)
2471		for (y = 0; y < pict_get_ysize(p); y++) {
2472		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2473		if (pict_is_validpixel(p, x, y)) {
2474		if (pict_get_gsn(p, x, y) > 0) {
2475	<	pict_get_Eglare(p,pict_get_gsn(p, x, y)) +=
2476	<	DOT(p->view.vdir, pict_get_cached_dir(p, x, y))
2477	<	* pict_get_omega(p, x, y)
2478	<	* luminance(pict_get_color(p, x, y));
2479	<	E_v_dir +=
2057	<	DOT(p->view.vdir, pict_get_cached_dir(p, x, y))
2058	<	* pict_get_omega(p, x, y)
2059	<	* luminance(pict_get_color(p, x, y));
2475	>	actual_igs = pict_get_gsn(p, x, y);
2476	>	delta_E=DOT(p->view.vdir, pict_get_cached_dir(p, x, y))* pict_get_omega(p, x, y)* luminance(pict_get_color(p, x, y));
2477	>	pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
2478	>	E_v_dir = E_v_dir + delta_E;
2479	>	setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2480		}
2481		}
2482		}
2483		}
2484		lum_backg_cos = (E_v - E_v_dir) / 3.1415927;
2485	<	lum_backg = lum_backg_cos;
2485	>
2486		}
2487	<	/* calc of band luminance if applied */
2487	>	/* calc of band luminance distribution if applied */
2488		if (band_calc == 1) {
2489	<	band_avlum=get_band_lum( p, band_angle, band_color);
2490	<	}
2489	>	x_max = pict_get_xsize(p) - 1;
2490	>	y_max = pict_get_ysize(p) - 1;
2491	>	y_mid = (int)(y_max/2);
2492	>	for (x = 0; x <= x_max; x++)
2493	>	for (y = 0; y <= y_max; y++) {
2494	>	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2495	>	if (pict_is_validpixel(p, x, y)) {
2496
2497	+	r_actual = acos(DOT(pict_get_cached_dir(p, x, y_mid), pict_get_cached_dir(p, x, y))) ;
2498	+	act_lum = luminance(pict_get_color(p, x, y));
2499	+
2500	+	if ((r_actual <= band_angle) || (y == y_mid) ) {
2501	+	lum_band[0]=luminance(pict_get_color(p, x, y));
2502	+	muc_rvar_add_sample(s_band, lum_band);
2503	+	act_lum = luminance(pict_get_color(p, x, y));
2504	+	lum_band_av += pict_get_omega(p, x, y) * act_lum;
2505	+	omega_band += pict_get_omega(p, x, y);
2506	+	if (band_color == 1) {
2507	+	pict_get_color(p, x, y)[RED] = 0.0;
2508	+	pict_get_color(p, x, y)[GRN] = act_lum / WHTEFFICACY / CIE_gf;
2509	+	pict_get_color(p, x, y)[BLU] = 0.0;
2510	+	}
2511	+	}
2512	+	}}}
2513	+	lum_band_av=lum_band_av/omega_band;
2514	+	muc_rvar_get_vx(s_band,lum_band_std);
2515	+	muc_rvar_get_percentile(s_band,lum_band_median,0.75);
2516	+	per_75_band=lum_band_median[0];
2517	+	muc_rvar_get_percentile(s_band,lum_band_median,0.95);
2518	+	per_95_band=lum_band_median[0];
2519	+	muc_rvar_get_median(s_band,lum_band_median);
2520	+	muc_rvar_get_bounding_box(s_band,bbox_band);
2521	+
2522	+	printf ("band:band_omega,band_av_lum,band_median_lum,band_std_lum,band_perc_75,band_perc_95,band_lum_min,band_lum_max: %f %f %f %f %f %f %f %f\n",omega_band,lum_band_av,lum_band_median[0],sqrt(lum_band_std[0]),per_75_band,per_95_band,bbox_band[0],bbox_band[1] );
2523	+	/*      av_lum = av_lum / omega_sum; */
2524	+	/*    printf("average luminance of band %f \n",av_lum);*/
2525	+	/*      printf("solid angle of band %f \n",omega_sum);*/
2526	+	}
2527	+
2528		/*printf("total number of glare sources: %i\n",igs); */
2529		lum_sources = 0;
2530		omega_sources = 0;
2531	+	i=0;
2532		for (x = 0; x <= igs; x++) {
2533	+	if (pict_get_npix(p, x) > 0) {
2534		lum_sources += pict_get_av_lum(p, x) * pict_get_av_omega(p, x);
2535		omega_sources += pict_get_av_omega(p, x);
2536	+	i=i+1;
2537	+	}}
2538	+
2539	+	if (sang == omega_sources) {
2540	+	lum_backg =avlum;
2541	+	} else {
2542	+	lum_backg =(sang * avlum - lum_sources) / (sang - omega_sources);
2543		}
2544	<	if (non_cos_lb == 1) {
2545	<	lum_backg =
2546	<	(sang * avlum - lum_sources) / (sang - omega_sources);
2544	>
2545	>
2546	>	if (i == 0) {
2547	>	lum_sources =0.0;
2548	>	} else { lum_sources=lum_sources/omega_sources;
2549		}
2550	+
2551	+
2552	+
2553	+	if (non_cos_lb == 0) {
2554	+	lum_backg = lum_backg_cos;
2555	+	}
2556	+
2557	+	if (non_cos_lb == 2) {
2558	+	lum_backg = E_v / 3.1415927;
2559	+	}
2560	+
2561	+
2562	+	/* file writing NOT here
2563	+	if (checkfile == 1) {
2564	+	pict_write(p, file_out);
2565	+	}
2566	+	*/
2567	+
2568		/* print detailed output */
2569	+
2570	+
2571	+
2572	+	/* masking */
2573	+
2574	+	if ( masking == 1 ) {
2575	+
2576	+
2577	+	for (x = 0; x < pict_get_xsize(p); x++)
2578	+	for (y = 0; y < pict_get_ysize(p); y++) {
2579	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2580	+	if (pict_is_validpixel(p, x, y)) {
2581	+	if (luminance(pict_get_color(pm, x, y))>0.1) {
2582	+	/*                                         printf ("hallo %i %i %f \n",x,y,luminance(pict_get_color(pm, x, y)));*/
2583	+	i_mask=i_mask+1;
2584	+	lum_mask[0]=luminance(pict_get_color(p, x, y));
2585	+	/* printf ("%f \n",lum_mask[0]);*/
2586	+	muc_rvar_add_sample(s_mask, lum_mask);
2587	+	omega_mask += pict_get_omega(p, x, y);
2588	+	lum_mask_av += pict_get_omega(p, x, y)* luminance(pict_get_color(p, x, y));
2589	+	E_v_mask +=DOT(p->view.vdir, pict_get_cached_dir(p, x, y))*pict_get_omega(p, x, y)* luminance(pict_get_color(p, x, y));
2590	+
2591	+	pict_get_color(pm, x, y)[RED] = luminance(pict_get_color(p, x, y))/179.0;
2592	+	pict_get_color(pm, x, y)[GRN] = luminance(pict_get_color(p, x, y))/179.0;
2593	+	pict_get_color(pm, x, y)[BLU] = luminance(pict_get_color(p, x, y))/179.0;
2594	+
2595	+	} else {
2596	+	pict_get_color(p, x, y)[RED] = 0.0 ;
2597	+	pict_get_color(p, x, y)[GRN] = 0.0 ;
2598	+	pict_get_color(p, x, y)[BLU] = 0.0 ;
2599	+	}
2600	+	}
2601	+	}
2602	+	}
2603	+	/* Average luminance in masking area (weighted by solid angle) */
2604	+	lum_mask_av=lum_mask_av/omega_mask;
2605	+	muc_rvar_get_vx(s_mask,lum_mask_std);
2606	+	muc_rvar_get_percentile(s_mask,lum_mask_median,0.75);
2607	+	per_75_mask=lum_mask_median[0];
2608	+	muc_rvar_get_percentile(s_mask,lum_mask_median,0.95);
2609	+	per_95_mask=lum_mask_median[0];
2610	+	muc_rvar_get_median(s_mask,lum_mask_median);
2611	+	muc_rvar_get_bounding_box(s_mask,bbox);
2612	+	/* PSGV only why masking of window is applied! */
2613	+	pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av);
2614	+	pgsv_sat =get_pgsv_sat(E_v);
2615	+
2616		if (detail_out == 1) {
2617	+
2618	+	printf ("masking:no_pixels,omega,av_lum,median_lum,std_lum,perc_75,perc_95,lum_min,lum_max,pgsv,pgsv_sat: %i %f %f %f %f %f %f %f %f %f %f\n",i_mask,omega_mask,lum_mask_av,lum_mask_median[0],sqrt(lum_mask_std[0]),per_75_mask,per_95_mask,bbox[0],bbox[1],pgsv,pgsv_sat );
2619	+
2620	+	}
2621	+
2622	+	}
2623	+
2624	+	/* zones */
2625	+
2626	+	if ( zones > 0 ) {
2627	+
2628	+	for (x = 0; x < pict_get_xsize(p); x++)
2629	+	for (y = 0; y < pict_get_ysize(p); y++) {
2630	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2631	+	if (pict_is_validpixel(p, x, y)) {
2632	+
2633	+
2634	+	r_actual =acos(DOT(pict_get_cached_dir(p, x, y), pict_get_cached_dir(p, x_zone, y_zone))) * 2;
2635	+	lum_actual = luminance(pict_get_color(p, x, y));
2636	+	act_gsn=pict_get_gsn(p, x, y);
2637	+	/*     printf("1act_gsn,pict_get_z1_gsn,pict_get_z2_gsn %i %f %f \n",act_gsn,pict_get_z1_gsn(p,act_gsn),pict_get_z2_gsn(p,act_gsn));*/
2638	+
2639	+	/*zone1 */
2640	+	if (r_actual <= angle_z1) {
2641	+	i_z1=i_z1+1;
2642	+	lum_z1[0]=lum_actual;
2643	+	muc_rvar_add_sample(s_z1, lum_z1);
2644	+	omega_z1 += pict_get_omega(p, x, y);
2645	+	lum_z1_av += pict_get_omega(p, x, y)* lum_actual;
2646	+	setglcolor(p,x,y,1,1 , 0.66, 0.01 ,0.33);
2647	+	/*check if separation gsn already exist */
2648	+
2649	+	if (act_gsn > 0){
2650	+	if (pict_get_z1_gsn(p,act_gsn) == 0) {
2651	+	pict_new_gli(p);
2652	+	igs = igs + 1;
2653	+	pict_get_z1_gsn(p,act_gsn) = igs*1.000;
2654	+	pict_get_z1_gsn(p,igs) = -1.0;
2655	+	pict_get_z2_gsn(p,igs) = -1.0;
2656	+	splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2657	+	/*                                                                                        printf ("Glare source %i gets glare source %i in zone 1 : %i %f %f \n",act_gsn,igs,splitgs,pict_get_z1_gsn(p,act_gsn),pict_get_z1_gsn(p,igs)); */
2658	+	}
2659	+	splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2660	+	/*          printf("splitgs%i \n",splitgs);       */
2661	+	split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2662	+	}
2663	+	}
2664	+	/*zone2 */
2665	+
2666	+	if (r_actual > angle_z1 && r_actual<= angle_z2 ) {
2667	+
2668	+	i_z2=i_z2+1;
2669	+	lum_z2[0]=lum_actual;
2670	+	muc_rvar_add_sample(s_z2, lum_z2);
2671	+	omega_z2 +=   pict_get_omega(p, x, y);
2672	+	lum_z2_av += pict_get_omega(p, x, y)* lum_actual;
2673	+	setglcolor(p,x,y,1,1 , 0.65, 0.33 ,0.02);
2674	+	/*                                                printf("zone 2 x y act_gsn pict_get_z1_gsn(p,act_gsn) pict_get_z2_gsn(p,act_gsn): %i %i %f 1:%f 2:%f \n",x,y,act_gsn,pict_get_z1_gsn(p,act_gsn),pict_get_z2_gsn(p,act_gsn));
2675	+	*/                                                if (act_gsn > 0){
2676	+	if (pict_get_z2_gsn(p,act_gsn) == 0) {
2677	+	pict_new_gli(p);
2678	+	igs = igs + 1;
2679	+	pict_get_z2_gsn(p,act_gsn) = igs*1.000;
2680	+	pict_get_z1_gsn(p,igs) = -2.0;
2681	+	pict_get_z2_gsn(p,igs) = -2.0;
2682	+	/*                                                                                         printf ("Glare source %i gets glare source %i in zone 2 \n",act_gsn,igs ); */
2683	+	}
2684	+	splitgs=(int)(pict_get_z2_gsn(p,act_gsn));
2685	+	/*                                              printf("splitgs %i \n",splitgs);*/
2686	+	split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2687	+	}
2688	+	}
2689	+
2690	+	}
2691	+	} }
2692	+	/* Average luminance in zones (weighted by solid angle), calculate percentiles, median min and max in zones  */
2693	+	if (zones == 2 ) {
2694	+	lum_z2_av=lum_z2_av/omega_z2;
2695	+	muc_rvar_get_vx(s_z2,lum_z2_std);
2696	+	muc_rvar_get_percentile(s_z2,lum_z2_median,0.75);
2697	+	per_75_z2=lum_z2_median[0];
2698	+	muc_rvar_get_percentile(s_z2,lum_z2_median,0.95);
2699	+	per_95_z2=lum_z2_median[0];
2700	+	muc_rvar_get_median(s_z2,lum_z2_median);
2701	+	muc_rvar_get_bounding_box(s_z2,bbox_z2);
2702	+	}
2703	+	lum_z1_av=lum_z1_av/omega_z1;
2704	+	muc_rvar_get_vx(s_z1,lum_z1_std);
2705	+	muc_rvar_get_percentile(s_z1,lum_z1_median,0.75);
2706	+	per_75_z1=lum_z1_median[0];
2707	+	muc_rvar_get_percentile(s_z1,lum_z1_median,0.95);
2708	+	per_95_z1=lum_z1_median[0];
2709	+	muc_rvar_get_median(s_z1,lum_z1_median);
2710	+	muc_rvar_get_bounding_box(s_z1,bbox_z1);
2711	+	if (detail_out == 1) {
2712	+
2713	+	printf ("zoning:z1_omega,z1_av_lum,z1_median_lum,z1_std_lum,z1_perc_75,z1_perc_95,z1_lum_min,z1_lum_max: %f %f %f %f %f %f %f %f\n",omega_z1,lum_z1_av,lum_z1_median[0],sqrt(lum_z1_std[0]),per_75_z1,per_95_z1,bbox_z1[0],bbox_z1[1] );
2714	+
2715	+	if (zones == 2 ) {
2716	+
2717	+	printf ("zoning:z2_omega,z2_av_lum,z2_median_lum,z2_std_lum,z2_perc_75,z2_perc_95,z2_lum_min,z2_lum_max:  %f %f %f %f %f %f %f %f\n",omega_z2,lum_z2_av,lum_z2_median[0],sqrt(lum_z2_std[0]),per_75_z2,per_95_z2,bbox_z2[0],bbox_z2[1] );
2718	+	} }
2719	+
2720	+	}
2721	+
2722		i = 0;
2723		for (x = 0; x <= igs; x++) {
2724		/* resorting glare source numbers */
#	Line 2089 | Line 2726 | if (calcfast == 1 ) {
2726		i = i + 1;
2727		}
2728		}
2729	+	no_glaresources=i;
2730
2731	+	/* glare sources */
2732	+	if (detail_out == 1) {
2733
2094	–
2734		printf
2735	<	("%i No pixels x-pos y-pos L_s Omega_s Posindx L_b L_t E_vert Edir Max_Lum Sigma xdir ydir zdir Eglare_cie Lveil_cie \n",
2735	>	("%i No pixels x-pos y-pos L_s Omega_s Posindx L_b L_t E_vert Edir Max_Lum Sigma xdir ydir zdir Eglare_cie Lveil_cie teta glare_zone\n",
2736		i);
2737		if (i == 0) {
2738	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f\n", i, 0.0, 0.0,
2739	<	0.0, 0.0, 0.0, 0.0, lum_backg, lum_task, E_v, E_v_dir,
2101	<	abs_max);
2738	>	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n", i, 0.0, 0.0,
2739	>	0.0, 0.0, 0.0, 0.0, lum_backg, lum_task, E_v, E_v_dir,abs_max,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
2740
2741		} else {
2742		i = 0;
#	Line 2118 | Line 2756 | if (calcfast == 1 ) {
2756		Lveil_cie =0 ;
2757		}
2758		Lveil_cie_sum =  Lveil_cie_sum + Lveil_cie;
2759	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
2759	>	if (pict_get_z1_gsn(p,x)<0) {
2760	>	act_gsn=(int)(-pict_get_z1_gsn(p,x));
2761	>	}else{
2762	>	act_gsn=0;
2763	>	}
2764	>	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %i \n",
2765		i, pict_get_npix(p, x), pict_get_av_posx(p, x),
2766		pict_get_ysize(p) - pict_get_av_posy(p, x),
2767		pict_get_av_lum(p, x), pict_get_av_omega(p, x),
#	Line 2126 | Line 2769 | if (calcfast == 1 ) {
2769		pict_get_av_posy(p, x),
2770		posindex_2), lum_backg, lum_task,
2771		E_v, E_v_dir, abs_max, sigma * 180 / 3.1415927
2772	<	,pict_get_cached_dir(p, x2,y2)[0],pict_get_cached_dir(p, x2,y2)[1],pict_get_cached_dir(p, x2,y2)[2],pict_get_Eglare(p,x),Lveil_cie,teta
2130	<
2131	<	);
2772	>	,pict_get_cached_dir(p, x2,y2)[0],pict_get_cached_dir(p, x2,y2)[1],pict_get_cached_dir(p, x2,y2)[2],pict_get_Eglare(p,x),Lveil_cie,teta,act_gsn );
2773		}
2774		}
2775		}
#	Line 2168 | Line 2809 | if (calcfast == 1 ) {
2809		}
2810
2811		if (calcfast == 0) {
2812	+	lum_a= E_v2/3.1415927;
2813		dgi = get_dgi(p, lum_backg, igs, posindex_2);
2814		ugr = get_ugr(p, lum_backg, igs, posindex_2);
2815	+	ugp = get_ugp (p,lum_backg, igs, posindex_2);
2816	+	ugr_exp = get_ugr_exp (p,lum_backg_cos,lum_a, igs, posindex_2);
2817	+	dgi_mod = get_dgi_mod(p, lum_a, igs, posindex_2);
2818		cgi = get_cgi(p, E_v, E_v_dir, igs, posindex_2);
2819	<	vcp = get_vcp(p, avlum, igs, posindex_2);
2819	>	dgr = get_dgr(p, avlum, igs, posindex_2);
2820	>	vcp = get_vcp(dgr);
2821		Lveil = get_disability(p, avlum, igs);
2822	+	if (no_glaresources == 0) {
2823	+	dgi = 0.0;
2824	+	ugr = 0.0;
2825	+	ugp = 0.0;
2826	+	ugr_exp = 0.0;
2827	+	dgi_mod = 0.0;
2828	+	cgi = 0.0;
2829	+	dgr = 0.0;
2830	+	vcp = 100.0;
2831	+	}
2832		}
2833		/* check dgp range */
2834		if (dgp <= 0.2) {
#	Line 2198 | Line 2854 | if (calcfast == 0) {
2854		dgp =low_light_corr*dgp;
2855		dgp =age_corr_factor*dgp;
2856		}
2857	+	muc_rvar_get_median(s_noposweight,lum_nopos_median);
2858	+	muc_rvar_get_median(s_posweight,lum_pos_median);
2859	+	muc_rvar_get_median(s_posweight2,lum_pos2_median);
2860	+
2861
2862	+
2863	+
2864		printf
2865	<	("dgp,av_lum,E_v,lum_backg,E_v_dir,dgi,ugr,vcp,cgi,lum_sources,omega_sources,Lveil,Lveil_cie,band_avlum: %f %f %f %f %f %f %f %f %f %f %f %f %f %f \n",
2865	>	("dgp,av_lum,E_v,lum_backg,E_v_dir,dgi,ugr,vcp,cgi,lum_sources,omega_sources,Lveil,Lveil_cie,dgr,ugp,ugr_exp,dgi_mod,av_lum_pos,av_lum_pos2,med_lum,med_lum_pos,med_lum_pos2: %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
2866		dgp, avlum, E_v, lum_backg, E_v_dir, dgi, ugr, vcp, cgi,
2867	<	lum_sources / omega_sources, omega_sources, Lveil,Lveil_cie_sum,band_avlum);
2867	>	lum_sources, omega_sources, Lveil,Lveil_cie_sum,dgr,ugp,ugr_exp,dgi_mod,lum_pos_mean,lum_pos2_mean/sang,lum_nopos_median[0],lum_pos_median[0],lum_pos2_median[0]);
2868		} else {
2869		if (detail_out2 == 1) {
2870
#	Line 2233 | Line 2895 | if (calcfast == 0) {
2895		if (E_vl_ext < 1000) {
2896		low_light_corr=1.0*exp(0.024*E_vl_ext-4)/(1+exp(0.024*E_vl_ext-4)); } else {low_light_corr=1.0 ;}
2897		dgp =low_light_corr*dgp;
2898	<	dgp =age_corr_factor*dgp;
2899	<	printf("%f\n", dgp);
2898	>
2899	>	if (calcfast == 2) {
2900	>
2901	>	lum_backg_cos=(E_vl_ext-dir_ill)/3.1415927;
2902	>	ugr = get_ugr(p, lum_backg_cos, igs, posindex_2);
2903	>	printf("%f %f \n", dgp,ugr);
2904	>	}else{
2905	>	printf("%f\n", dgp);
2906	>	}
2907		}
2908
2909
#	Line 2265 | Line 2934 | has to be re-written from scratch....
2934
2935		/*output  */
2936		if (checkfile == 1) {
2937	+
2938	+
2939		pict_write(p, file_out);
2940		}
2941

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines