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.7 by greg, Sat Aug 12 15:11:09 2017 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.00
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/12  ad of -O option - disk replacement by providing luminance, not documented
322	+	remove some minor memory leakages, clean up initialization by C. Reetz
323	+	*/
324	+
325	+
326	+
327	+	#ifndef EVALGLARE
328	+	#define EVALGLARE
329	+	#endif
330		#define PROGNAME "evalglare"
331	<	#define VERSION "1.17 release 15.07.2015 by EPFL, J.Wienold"
331	>	#define VERSION "2.03 release 12.08.2017 by EPFL, J.Wienold"
332		#define RELEASENAME PROGNAME " " VERSION
333
334	<	#include "rtio.h"
285	<	#include "platform.h"
334	>
335		#include "pictool.h"
336	+	#include "rtio.h"
337		#include <math.h>
338		#include <string.h>
339	+	#include "platform.h"
340	+	#include "muc_randvar.h"
341	+
342		char *progname;
343
344		/* subroutine to add a pixel to a glare source */
#	Line 561 | Line 614 | double get_task_lum(pict * p, int x, int y, float r, i
614		return av_lum;
615		}
616
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;
617
618
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);
619
620
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	–
621		/* subroutine for coloring the glare sources
622		red is used only for explicit call of the subroutine with acol=0  , e.g. for disability glare
623		-1: set to grey*/
#	Line 623 | Line 629 | int setglcolor(pict * p, int x, int y, int acol, int u
629		l=u_r+u_g+u_b ;
630
631		pcol[RED][0] = 1.0 / CIE_rf;
632	<	pcol[GRN][0] = 0.;
633	<	pcol[BLU][0] = 0.;
632	>	pcol[GRN][0] = 0.0 / CIE_gf;
633	>	pcol[BLU][0] = 0.0 / CIE_bf;
634
635	<	pcol[RED][1] = 0.;
635	>	pcol[RED][1] = 0.0 / CIE_rf;
636		pcol[GRN][1] = 1.0 / CIE_gf;
637	<	pcol[BLU][1] = 0.;
637	>	pcol[BLU][1] = 0.0 / CIE_bf;
638
639	<	pcol[RED][2] = 0.;
640	<	pcol[GRN][2] = 0.;
641	<	pcol[BLU][2] = 1 / CIE_bf;
639	>	pcol[RED][2] = 0.15 / CIE_rf;
640	>	pcol[GRN][2] = 0.15 / CIE_gf;
641	>	pcol[BLU][2] = 0.7 / CIE_bf;
642
643	<	pcol[RED][3] = 1.0 / (1.0 - CIE_bf);
644	<	pcol[GRN][3] = 1.0 / (1.0 - CIE_bf);
645	<	pcol[BLU][3] = 0.;
643	>	pcol[RED][3] = .5 / CIE_rf;
644	>	pcol[GRN][3] = .5 / CIE_gf;
645	>	pcol[BLU][3] = 0.0 / CIE_bf;
646
647	<	pcol[RED][4] = 1.0 / (1.0 - CIE_gf);
648	<	pcol[GRN][4] = 0.;
649	<	pcol[BLU][4] = 1.0 / (1.0 - CIE_gf);
647	>	pcol[RED][4] = .5 / CIE_rf;
648	>	pcol[GRN][4] = .0 / CIE_gf;
649	>	pcol[BLU][4] = .5 / CIE_bf ;
650
651	<	pcol[RED][5] = 0.;
652	<	pcol[GRN][5] = 1.0 / (1.0 - CIE_rf);
653	<	pcol[BLU][5] = 1.0 / (1.0 - CIE_rf);
651	>	pcol[RED][5] = .0 / CIE_rf;
652	>	pcol[GRN][5] = .5 / CIE_gf;
653	>	pcol[BLU][5] = .5 / CIE_bf;
654
655	<	pcol[RED][6] = 0.;
656	<	pcol[GRN][6] = 1.0 / (1.0 - CIE_rf);
657	<	pcol[BLU][6] = 1.0 / (1.0 - CIE_rf);
655	>	pcol[RED][6] = 0.333 / CIE_rf;
656	>	pcol[GRN][6] = 0.333 / CIE_gf;
657	>	pcol[BLU][6] = 0.333 / CIE_bf;
658
659
660		pcol[RED][999] = 1.0 / WHTEFFICACY;
#	Line 659 | Line 665 | int setglcolor(pict * p, int x, int y, int acol, int u
665		pcol[RED][998] = u_r /(l* CIE_rf) ;
666		pcol[GRN][998] = u_g /(l* CIE_gf);
667		pcol[BLU][998] = u_b /(l* CIE_bf);
668	<	/*        printf("CIE_rf,CIE_gf,CIE_bf,l=%f %f %f %f\n",CIE_rf,CIE_gf,CIE_bf,l);*/
668	>	/*        printf("CIE_rf,CIE_gf,CIE_bf,l=%f %f %f %f %f\n",CIE_rf,CIE_gf,CIE_bf,l,WHTEFFICACY); */
669		icol = acol ;
670		if ( acol == -1) {icol=999;
671		}else{if (acol>0){icol = acol % 5 +1;
#	Line 672 | Line 678 | int setglcolor(pict * p, int x, int y, int acol, int u
678		pict_get_color(p, x, y)[RED] = pcol[RED][icol] * act_lum / WHTEFFICACY;
679		pict_get_color(p, x, y)[GRN] = pcol[GRN][icol] * act_lum / WHTEFFICACY;
680		pict_get_color(p, x, y)[BLU] = pcol[BLU][icol] * act_lum / WHTEFFICACY;
681	<
681	>	/*        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))); */
682		return icol;
683		}
684
#	Line 724 | Line 730 | void add_secondary_gs(pict * p, int x, int y, float r,
730
731		/* color pixel of gs */
732
733	<	icol = setglcolor(p, x, y, act_gs, uniform_gs, u_r, u_g , u_b);
733	>	/*              icol = setglcolor(p, x, y, act_gs, uniform_gs, u_r, u_g , u_b); */
734
735		}
736		}
#	Line 764 | Line 770 | void split_pixel_from_gs(pict * p, int x, int y, int n
770
771		/* color pixel of new gs */
772
773	<	icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b);
773	>	/*      icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b); */
774	>
775
769	–
776		}
777
778		/* subroutine for the calculation of the position index */
#	Line 797 | Line 803 | float get_posindex(pict * p, float x, float y, int pos
803		tau = tau * deg;
804		sigma = sigma * deg;
805
806	+	if (postype == 1) {
807	+	/* KIM  model */
808	+	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));
809	+	}else{
810	+	/* Guth model, equation from IES lighting handbook */
811		posindex =
812		exp((35.2 - 0.31889 * tau -
813		1.22 * exp(-2 * tau / 9)) / 1000 * sigma + (21 +
#	Line 818 | Line 829 | float get_posindex(pict * p, float x, float y, int pos
829
830		posindex = 1 + fact * r;
831		}
832	<	if (posindex > 16)
832	>	if (posindex > 16)
833		posindex = 16;
834	+	}
835
836		return posindex;
837
#	Line 1032 | Line 1044 | return;
1044
1045		}
1046
1047	<	/* subroutine for the calculation of the daylight glare index */
1047	>	/* subroutine for the calculation of the daylight glare index DGI*/
1048
1049
1050		float get_dgi(pict * p, float lum_backg, int igs, int posindex_2)
#	Line 1059 | Line 1071 | float get_dgi(pict * p, float lum_backg, int igs, int
1071		return dgi;
1072
1073		}
1074	+	/* subroutine for the calculation of the modified daylight glare index DGI_mod (Fisekis2003)
1075	+	several glare sources are taken into account and summed up, original equation has no summary
1076	+	*/
1077
1078	+
1079	+	float get_dgi_mod(pict * p, float lum_a, int igs, int posindex_2)
1080	+	{
1081	+	float dgi_mod, sum_glare, omega_s;
1082	+	int i;
1083	+
1084	+
1085	+	sum_glare = 0;
1086	+	omega_s = 0;
1087	+
1088	+	for (i = 0; i <= igs; i++) {
1089	+
1090	+	if (pict_get_npix(p, i) > 0) {
1091	+	omega_s =
1092	+	pict_get_av_omega(p, i) / get_posindex(p,pict_get_av_posx(p,i), pict_get_av_posy(p,i),posindex_2) /
1093	+	get_posindex(p, pict_get_av_posx(p, i), pict_get_av_posy(p, i), posindex_2);
1094	+	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));
1095	+	/*    printf("i,sum_glare %i %f\n",i,sum_glare); */
1096	+	}
1097	+	}
1098	+	dgi_mod = 10 * log10(sum_glare);
1099	+
1100	+	return dgi_mod;
1101	+
1102	+	}
1103	+
1104		/* subroutine for the calculation of the daylight glare probability */
1105		double
1106		get_dgp(pict * p, double E_v, int igs, double a1, double a2, double a3,
#	Line 1100 | Line 1141 | get_dgp(pict * p, double E_v, int igs, double a1, doub
1141		}
1142
1143		/* subroutine for the calculation of the visual comfort probability */
1144	<	float get_vcp(pict * p, double lum_a, int igs, int posindex_2)
1144	>	float get_dgr(pict * p, double lum_a, int igs, int posindex_2)
1145		{
1146	<	float vcp;
1147	<	double sum_glare, dgr;
1146	>	float dgr;
1147	>	double sum_glare;
1148		int i, i_glare;
1149
1150
#	Line 1129 | Line 1170 | float get_vcp(pict * p, double lum_a, int igs, int pos
1170		}
1171		dgr = pow(sum_glare, pow(i_glare, -0.0914));
1172
1173	+
1174	+
1175	+	return dgr;
1176	+
1177	+	}
1178	+
1179	+	float get_vcp(float dgr )
1180	+	{
1181	+	float vcp;
1182	+
1183		vcp = 50 * erf((6.347 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1184		if (dgr > 750) {
1185		vcp = 0;
#	Line 1136 | Line 1187 | float get_vcp(pict * p, double lum_a, int igs, int pos
1187		if (dgr < 20) {
1188		vcp = 100;
1189		}
1139	–
1140	–
1190		return vcp;
1191
1192		}
1193
1194	+
1195		/* subroutine for the calculation of the unified glare rating */
1196		float get_ugr(pict * p, double lum_backg, int igs, int posindex_2)
1197		{
#	Line 1165 | Line 1215 | float get_ugr(pict * p, double lum_backg, int igs, int
1215		}
1216		}
1217		ugr = 8 * log10(0.25 / lum_backg * sum_glare);
1218	<
1218	>	if (sum_glare==0) {
1219	>	ugr=0.0;
1220	>	}
1221	>	if (lum_backg<=0) {
1222	>	ugr=-99.0;
1223	>	}
1224	>
1225		return ugr;
1226
1227		}
1228	+	/* subroutine for the calculation of the experimental unified glare rating (Fisekis 2003)*/
1229	+	float get_ugr_exp(pict * p, double lum_backg, double lum_a, int igs, int posindex_2)
1230	+	{
1231	+	float ugr_exp;
1232	+	double sum_glare;
1233	+	int i, i_glare;
1234
1235
1236	+	sum_glare = 0;
1237	+	i_glare = 0;
1238	+	for (i = 0; i <= igs; i++) {
1239	+
1240	+	if (pict_get_npix(p, i) > 0) {
1241	+	i_glare = i_glare + 1;
1242	+	sum_glare +=
1243	+	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);
1244	+
1245	+	}
1246	+	}
1247	+	ugr_exp =8 * log10(lum_a) + 8 * log10(sum_glare/lum_backg);
1248	+
1249	+	return ugr_exp;
1250	+
1251	+	}
1252	+	/* subroutine for the calculation of the unified glare probability (Hirning 2014)*/
1253	+	float get_ugp(pict * p, double lum_backg, int igs, int posindex_2)
1254	+	{
1255	+	float ugp;
1256	+	double sum_glare;
1257	+	int i, i_glare;
1258	+
1259	+
1260	+	sum_glare = 0;
1261	+	i_glare = 0;
1262	+	for (i = 0; i <= igs; i++) {
1263	+
1264	+	if (pict_get_npix(p, i) > 0) {
1265	+	i_glare = i_glare + 1;
1266	+	sum_glare +=
1267	+	pow(pict_get_av_lum(p, i) /
1268	+	get_posindex(p, pict_get_av_posx(p, i),
1269	+	pict_get_av_posy(p, i), posindex_2),
1270	+	2) * pict_get_av_omega(p, i);
1271	+
1272	+	}
1273	+	}
1274	+	ugp = 0.26 * log10(0.25 / lum_backg * sum_glare);
1275	+
1276	+	return ugp;
1277	+
1278	+	}
1279	+
1280	+
1281		/* subroutine for the calculation of the disability glare according to Poynter */
1282		float get_disability(pict * p, double lum_backg, int igs)
1283		{
#	Line 1218 | Line 1325 | float get_disability(pict * p, double lum_backg, int i
1325
1326		/* subroutine for the calculation of the cie glare index */
1327
1328	<	float
1222	<	get_cgi(pict * p, double E_v, double E_v_dir, int igs, int posindex_2)
1328	>	float get_cgi(pict * p, double E_v, double E_v_dir, int igs, int posindex_2)
1329		{
1330		float cgi;
1331		double sum_glare;
#	Line 1243 | Line 1349 | get_cgi(pict * p, double E_v, double E_v_dir, int igs,
1349		cgi = 8 * log10((2 * (1 + E_v_dir / 500) / E_v) * sum_glare);
1350
1351		return cgi;
1352	+	}
1353
1354	+	/* 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! */
1355	+	float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av)
1356	+	{
1357	+	float pgsv;
1358	+	double Lb;
1359	+
1360	+	Lb = (E_v-E_mask)/1.414213562373;
1361	+
1362	+	pgsv =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1363	+
1364	+
1365	+	return pgsv;
1366		}
1367
1368	+	/* 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! */
1369	+	float get_pgsv_sat(double E_v)
1370	+	{
1371	+	float pgsv_sat;
1372
1373	+	pgsv_sat =3.3-(0.57+3.3)/pow((1+E_v/1.414213562373/1250),1.7);
1374	+
1375	+
1376	+	return pgsv_sat;
1377	+	}
1378	+
1379	+
1380	+
1381	+
1382		#ifdef  EVALGLARE
1383
1384
#	Line 1258 | Line 1390 | int main(int argc, char **argv)
1390		{
1391		#define CLINEMAX 4095 /* memory allocated for command line string */
1392		pict *p = pict_create();
1393	<	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, y1, fill, yfillmax, yfillmin,
1394	<	ext_vill, set_lum_max, set_lum_max2, task_color, i_splitstart,
1395	<	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,
1396	<	igs, actual_igs, icol, xt, yt, change, before_igs, sgs, splithigh,uniform_gs,
1397	<	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx, rmy,apply_disability,band_calc,band_color;
1398	<	double  lum_total_max,age_corr_factor,age,dgp_ext,dgp,low_light_corr,omega_cos_contr, setvalue, lum_ideal, E_v_contr, sigma,
1399	<	E_vl_ext, lum_max, new_lum_max, r_center,
1400	<	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,
1401	<	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang,
1402	<	l_max, lum_backg, lum_backg_cos, omega_sources, lum_sources,
1403	<	lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum;
1404	<	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit,
1393	>	pict *pm = pict_create();
1394	>	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1395	>	ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,
1396	>	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,x_zone,y_zone, i_z1, i_z2,
1397	>	igs, actual_igs, lastpixelwas_gs, icol, xt, yt, change,checkpixels, before_igs, sgs, splithigh,uniform_gs,x_max, y_max,y_mid,
1398	>	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx,rmy,apply_disability,band_calc,band_color,masking,i_mask,no_glaresources,force;
1399	>	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,
1400	>	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,
1401	>	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,dir_ill,
1402	>	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang, angle_z1, angle_z2,per_95_band,per_75_band,pos,
1403	>	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,
1404	>	lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum,
1405	>	lum_mask[1],lum_mask_av,lum_mask_std[1],lum_mask_median[1],omega_mask,bbox[2],
1406	>	lum_band[1],lum_band_av,lum_band_std[1],lum_band_median[1],omega_band,bbox_band[2],
1407	>	lum_z1[1],lum_z1_av,lum_z1_std[1],lum_z1_median[1],omega_z1,bbox_z1[2],
1408	>	lum_z2[1],lum_z2_av,lum_z2_std[1],lum_z2_median[1],omega_z2,bbox_z2[2],
1409	>	lum_pos[1],lum_nopos_median[1],lum_pos_median[1],lum_pos2_median[1],lum_pos_mean,lum_pos2_mean;
1410	>	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,
1411		abs_max, Lveil;
1412	<	char file_out[500], file_out2[500], version[500];
1413	<	char *cline;
1412	>	char maskfile[500],file_out[500], file_out2[500], version[500];
1413	>	char *cline = NULL;
1414		VIEW userview = STDVIEW;
1415		int gotuserview = 0;
1416	+	struct muc_rvar* s_mask = NULL;
1417	+	struct muc_rvar* s_band = NULL;
1418	+	struct muc_rvar* s_z1 = NULL;
1419	+	struct muc_rvar* s_z2 = NULL;
1420	+	struct muc_rvar* s_noposweight = NULL;
1421	+	struct muc_rvar* s_posweight = NULL;
1422	+	struct muc_rvar* s_posweight2 = NULL;
1423
1424	+	// initializing variables ....
1425	+	Lveil = lum_backg_cos = 0;
1426	+	dgi = ugr = ugp = ugr_exp = dgi_mod = cgi = dgr = vcp = 0.0;
1427	+	lum_task = lum_thres = limit = 0;
1428	+	s_mask = muc_rvar_create();
1429	+	muc_rvar_set_dim(s_mask, 1);
1430	+	muc_rvar_clear(s_mask);
1431	+	s_band = muc_rvar_create();
1432	+	muc_rvar_set_dim(s_band, 1);
1433	+	muc_rvar_clear(s_band);
1434	+	s_z1 = muc_rvar_create();
1435	+	muc_rvar_set_dim(s_z1, 1);
1436	+	muc_rvar_clear(s_z1);
1437	+
1438	+	s_z2 = muc_rvar_create();
1439	+	muc_rvar_set_dim(s_z2, 1);
1440	+	muc_rvar_clear(s_z2);
1441	+
1442	+	s_noposweight = muc_rvar_create();
1443	+	muc_rvar_set_dim(s_noposweight, 1);
1444	+	muc_rvar_clear(s_noposweight);
1445	+
1446	+	s_posweight = muc_rvar_create();
1447	+	muc_rvar_set_dim(s_posweight, 1);
1448	+	muc_rvar_clear(s_posweight);
1449	+
1450	+	s_posweight2 = muc_rvar_create();
1451	+	muc_rvar_set_dim(s_posweight2, 1);
1452	+	muc_rvar_clear(s_posweight2);
1453	+
1454		/*set required user view parameters to invalid values*/
1455	<	uniform_gs = 0;
1455	>	dir_ill=0.0;
1456	>	delta_E=0.0;
1457	>	no_glaresources=0;
1458	>	n_corner_px=0;
1459	>	zero_corner_px=0;
1460	>	force=0;
1461	>	dist=0.0;
1462	>	u_r=0.33333;
1463	>	u_g=0.33333;
1464	>	u_b=0.33333;
1465	>	band_angle=0;
1466	>	angle_z1=0;
1467	>	angle_z2=0;
1468	>	x_zone=0;
1469	>	y_zone=0;
1470	>	per_75_z2=0;
1471	>	per_95_z2=0;
1472	>	lum_pos_mean=0;
1473	>	lum_pos2_mean=0;
1474	>	lum_band_av = 0.0;
1475	>	omega_band = 0.0;
1476	>	pgsv = 0.0 ;
1477	>	pgsv_sat = 0.0 ;
1478	>	E_v_mask = 0.0;
1479	>	lum_z1_av = 0.0;
1480	>	omega_z1 = 0.0;
1481	>	lum_z2_av = 0.0;
1482	>	omega_z2 = 0.0 ;
1483	>	i_z1 = 0;
1484	>	i_z2 = 0;
1485	>	zones = 0;
1486	>	lum_z2_av = 0.0;
1487	>	uniform_gs = 0;
1488		apply_disability = 0;
1489		disability_thresh = 0;
1490		Lveil_cie_sum=0.0;
#	Line 1297 | Line 1504 | int main(int argc, char **argv)
1504		omegat = 0.0;
1505		yt = 0;
1506		xt = 0;
1507	+	x_disk=0;
1508	+	y_disk=0;
1509	+	angle_disk=0;
1510		yfillmin = 0;
1511		yfillmax = 0;
1512		cut_view = 0;
#	Line 1329 | Line 1539 | int main(int argc, char **argv)
1539		limit = 50000.0;
1540		set_lum_max = 0;
1541		set_lum_max2 = 0;
1542	+	img_corr=0;
1543		abs_max = 0;
1544		progname = argv[0];
1545		E_v_contr = 0.0;
1546	<	strcpy(version, "1.15 release 05.02.2015 by J.Wienold");
1546	>	strcpy(version, "1.19 release 09.12.2015 by J.Wienold");
1547		low_light_corr=1.0;
1548		output = 0;
1549		calc_vill = 0;
1550		band_avlum = -99;
1551		band_calc = 0;
1552	+	masking = 0;
1553	+	lum_mask[0]=0.0;
1554	+	lum_mask_av=0.0;
1555	+	omega_mask=0.0;
1556	+	i_mask=0;
1557	+	actual_igs=0;
1558	+	LUM_replace=0;
1559		/* command line for output picture*/
1560
1561		cline = (char *) malloc(CLINEMAX+1);
#	Line 1379 | Line 1597 | int main(int argc, char **argv)
1597		printf("age factor not supported any more \n");
1598		exit(1);
1599		break;
1600	+	case 'A':
1601	+	masking = 1;
1602	+	detail_out = 1;
1603	+	strcpy(maskfile, argv[++i]);
1604	+	pict_read(pm,maskfile );
1605	+
1606	+	break;
1607		case 'b':
1608		lum_thres = atof(argv[++i]);
1609		break;
#	Line 1398 | Line 1623 | int main(int argc, char **argv)
1623		case 's':
1624		sgs = 1;
1625		break;
1626	+	case 'f':
1627	+	force = 1;
1628	+	break;
1629		case 'k':
1630		apply_disability = 1;
1631		disability_thresh = atof(argv[++i]);
#	Line 1406 | Line 1634 | int main(int argc, char **argv)
1634		case 'p':
1635		posindex_picture = 1;
1636		break;
1637	+	case 'P':
1638	+	posindex_2 = atoi(argv[++i]);
1639	+	break;
1640	+
1641
1642		case 'y':
1643		splithigh = 1;
#	Line 1436 | Line 1668 | int main(int argc, char **argv)
1668		detail_out2 = 1;
1669		break;
1670		case 'm':
1671	+	img_corr = 1;
1672		set_lum_max = 1;
1673		lum_max = atof(argv[++i]);
1674		new_lum_max = atof(argv[++i]);
#	Line 1444 | Line 1677 | int main(int argc, char **argv)
1677		break;
1678
1679		case 'M':
1680	+	img_corr = 1;
1681		set_lum_max2 = 1;
1682		lum_max = atof(argv[++i]);
1683		E_vl_ext = atof(argv[++i]);
1684		strcpy(file_out2, argv[++i]);
1685		/*                      printf("max lum set to %f\n",new_lum_max);*/
1686		break;
1687	+	case 'N':
1688	+	img_corr = 1;
1689	+	set_lum_max2 = 2;
1690	+	x_disk = atoi(argv[++i]);
1691	+	y_disk = atoi(argv[++i]);
1692	+	angle_disk = atof(argv[++i]);
1693	+	E_vl_ext = atof(argv[++i]);
1694	+	strcpy(file_out2, argv[++i]);
1695	+	/*                      printf("max lum set to %f\n",new_lum_max);*/
1696	+	break;
1697	+	case 'O':
1698	+	img_corr = 1;
1699	+	set_lum_max2 = 3;
1700	+	x_disk = atoi(argv[++i]);
1701	+	y_disk = atoi(argv[++i]);
1702	+	angle_disk = atof(argv[++i]);
1703	+	LUM_replace = atof(argv[++i]);
1704	+	strcpy(file_out2, argv[++i]);
1705	+	/*                      printf("max lum set to %f\n",new_lum_max);*/
1706	+	break;
1707	+
1708	+
1709		case 'n':
1710		non_cos_lb = 0;
1711		break;
#	Line 1469 | Line 1725 | int main(int argc, char **argv)
1725		omegat = atof(argv[++i]);
1726		task_color = 1;
1727		break;
1728	+	case 'l':
1729	+	zones = 1;
1730	+	x_zone = atoi(argv[++i]);
1731	+	y_zone = atoi(argv[++i]);
1732	+	angle_z1 = atof(argv[++i]);
1733	+	angle_z2 = -1;
1734	+	break;
1735	+	case 'L':
1736	+	zones = 2;
1737	+	x_zone = atoi(argv[++i]);
1738	+	y_zone = atoi(argv[++i]);
1739	+	angle_z1 = atof(argv[++i]);
1740	+	angle_z2 = atof(argv[++i]);
1741	+	break;
1742	+
1743	+
1744		case 'B':
1745		band_calc = 1;
1746		band_angle = atof(argv[++i]);
#	Line 1505 | Line 1777 | int main(int argc, char **argv)
1777		case '1':
1778		output = 1;
1779		break;
1780	+	case '2':
1781	+	output = 2;
1782	+	dir_ill = atof(argv[++i]);
1783	+	break;
1784
1785		case 'v':
1786		if (argv[i][2] == '\0') {
#	Line 1536 | Line 1812 | int main(int argc, char **argv)
1812
1813		/*fast calculation, if gendgp_profile is used: No Vertical illuminance calculation, only dgp is calculated*/
1814
1815	<	if (output == 1 && ext_vill == 1) {
1815	>	if (output == 1 && ext_vill == 1 ) {
1816		calcfast=1;
1817		}
1818	+
1819	+	if (output == 2 && ext_vill == 1 ) {
1820	+	calcfast=2;
1821	+	}
1822	+
1823	+	/*masking and zoning cannot be applied at the same time*/
1824
1825	+	if (masking ==1 && zones >0) {
1826	+	fprintf(stderr,  " masking and zoning cannot be activated at the same time!\n");
1827	+	exit(1);
1828	+	}
1829	+
1830		/* read picture file */
1831		if (i == argc) {
1832		SET_FILE_BINARY(stdin);
#	Line 1573 | Line 1860 | if (output == 1 && ext_vill == 1) {
1860		return EXIT_FAILURE;
1861		}
1862
1863	+
1864	+
1865		/*                fprintf(stderr,"Picture read!");*/
1866
1867		/* command line for output picture*/
1868
1869		pict_set_comment(p, cline);
1870
1871	+	/* several checks */
1872		if (p->view.type == VT_PAR) {
1873	<	fprintf(stderr, "wrong view type! must not be parallel ! \n");
1873	>	fprintf(stderr, "error: wrong view type! must not be parallel ! \n");
1874		exit(1);
1875		}
1876
1877	+	if (p->view.type == VT_PER) {
1878	+	fprintf(stderr, "warning: image has perspective view type specified in header ! \n");
1879	+	}
1880
1881	+	if (masking == 1) {
1882	+
1883	+	if (!pict_get_xsize(p)==pict_get_xsize(pm) || !pict_get_ysize(p)==pict_get_ysize(pm)) {
1884	+	fprintf(stderr, "error: masking image has other resolution than main image ! \n");
1885	+	fprintf(stderr, "size must be identical \n");
1886	+	printf("resolution main image : %dx%d\n",pict_get_xsize(p),pict_get_ysize(p));
1887	+	printf("resolution masking image : %dx%d\n",pict_get_xsize(pm),pict_get_ysize(pm));
1888	+	exit(1);
1889	+
1890	+	}
1891	+
1892	+	}
1893	+	/*      printf("resolution: %dx%d\n",pict_get_xsize(p),pict_get_ysize(p)); */
1894	+
1895		/* Check size of search radius */
1896		rmx = (pict_get_xsize(p) / 2);
1897		rmy = (pict_get_ysize(p) / 2);
#	Line 1629 | Line 1936 | if (output == 1 && ext_vill == 1) {
1936		avlum = 0.0;
1937		pict_new_gli(p);
1938		igs = 0;
1939	+	pict_get_z1_gsn(p,igs) = 0;
1940	+	pict_get_z2_gsn(p,igs) = 0;
1941
1942	+
1943		/* cut out GUTH field of view and exit without glare evaluation */
1944		if (cut_view==2) {
1945		if (cut_view_type==1) {
#	Line 1696 | Line 2006 | if (cut_view==2) {
2006		if (calcfast == 0) {
2007		for (x = 0; x < pict_get_xsize(p); x++)
2008		for (y = 0; y < pict_get_ysize(p); y++) {
2009	+	lum = luminance(pict_get_color(p, x, y));
2010	+	dist=sqrt((x-rmx)*(x-rmx)+(y-rmy)*(y-rmy));
2011	+	if (dist>((rmx+rmy)/2)) {
2012	+	n_corner_px=n_corner_px+1;
2013	+	if (lum<7.0) {
2014	+	zero_corner_px=zero_corner_px+1;
2015	+	}
2016	+	}
2017	+
2018	+
2019		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2020		if (pict_is_validpixel(p, x, y)) {
1701	–	lum = luminance(pict_get_color(p, x, y));
2021		if (fill == 1 && y >= yfillmax) {
2022		y1 = y - 1;
2023		lum = luminance(pict_get_color(p, x, y1));
#	Line 1711 | Line 2030 | if (cut_view==2) {
2030		abs_max = lum;
2031		}
2032		/* set luminance restriction, if -m is set */
2033	<	if (set_lum_max == 1 && lum >= lum_max) {
2034	<	pict_get_color(p, x, y)[RED] = new_lum_max / 179.0;
2035	<	pict_get_color(p, x, y)[GRN] = new_lum_max / 179.0;
2036	<	pict_get_color(p, x, y)[BLU] = new_lum_max / 179.0;
2037	<	/*                                    printf("old lum, new lum %f %f \n",lum,luminance(pict_get_color(p,x,y))); */
2038	<	lum = luminance(pict_get_color(p, x, y));
2033	>	if (img_corr == 1 ) {
2034	>	if (set_lum_max == 1 && lum >= lum_max) {
2035	>	pict_get_color(p, x, y)[RED] = new_lum_max / 179.0;
2036	>	pict_get_color(p, x, y)[GRN] = new_lum_max / 179.0;
2037	>	pict_get_color(p, x, y)[BLU] = new_lum_max / 179.0;
2038	>	/*                                                      printf("old lum, new lum %f %f \n",lum,luminance(pict_get_color(p,x,y))); */
2039	>	lum = luminance(pict_get_color(p, x, y));
2040	>	}
2041	>	if (set_lum_max2 == 1 && lum >= lum_max) {
2042
2043	<	}
2044	<	if (set_lum_max2 == 1 && lum >= lum_max) {
2043	>	E_v_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* lum;
2044	>	omega_cos_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* 1;
2045	>	}
2046	>	if (set_lum_max2 == 2 ) {
2047	>	r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2048	>	if (x_disk == x && y_disk==y ) r_actual=0.0;
2049
2050	<	E_v_contr +=
2051	<	DOT(p->view.vdir,
2052	<	pict_get_cached_dir(p, x,
2053	<	y)) * pict_get_omega(p,
2054	<	x,
2055	<	y)
2056	<	* lum;
2057	<	omega_cos_contr +=
2058	<	DOT(p->view.vdir,
2059	<	pict_get_cached_dir(p, x,
1734	<	y)) * pict_get_omega(p,
1735	<	x,
1736	<	y)
1737	<	* 1;
2050	>	act_lum = luminance(pict_get_color(p, x, y));
2051	>
2052	>	if (r_actual <= angle_disk) {
2053	>	E_v_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* lum;
2054	>	omega_cos_contr += DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* 1;
2055	>	}
2056	>
2057	>
2058	>
2059	>	}
2060		}
2061	+	om = pict_get_omega(p, x, y);
2062	+	sang += om;
2063	+	E_v += DOT(p->view.vdir, pict_get_cached_dir(p, x,y)) * om *lum;
2064	+	avlum += om * lum;
2065	+	pos=get_posindex(p, x, y,posindex_2);
2066
2067	+	lum_pos[0]=lum;
2068	+	muc_rvar_add_sample(s_noposweight,lum_pos);
2069	+	lum_pos[0]=lum/pos;
2070	+	lum_pos_mean+=lum_pos[0]*om;
2071	+	muc_rvar_add_sample(s_posweight, lum_pos);
2072	+	lum_pos[0]=lum_pos[0]/pos;
2073	+	lum_pos2_mean+=lum_pos[0]*om;
2074	+	muc_rvar_add_sample(s_posweight2,lum_pos);
2075
2076	<	sang += pict_get_omega(p, x, y);
2077	<	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));
2076	>
2077	>
2078		} else {
2079		pict_get_color(p, x, y)[RED] = 0.0;
2080		pict_get_color(p, x, y)[GRN] = 0.0;
2081		pict_get_color(p, x, y)[BLU] = 0.0;
2082
2083		}
2084	<	}
2084	>	}else {
2085	>	pict_get_color(p, x, y)[RED] = 0.0;
2086	>	pict_get_color(p, x, y)[GRN] = 0.0;
2087	>	pict_get_color(p, x, y)[BLU] = 0.0;
2088	>
2089	>	}
2090		}
2091
2092	<	if (set_lum_max2 == 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) {
2092	>	/* check if image has black corners AND a perspective view */
2093
2094	+	if (zero_corner_px/n_corner_px > 0.70 && (p->view.type == VT_PER) ) {
2095	+	printf (" corner pixels are to  %f %% black! \n",zero_corner_px/n_corner_px*100);
2096	+	printf("error! The image has black corners AND header contains a perspective view type definition !!!\n") ;
2097	+
2098	+	if (force==0) {
2099	+	printf("stopping...!!!!\n") ;
2100	+
2101	+	exit(1);
2102	+	}
2103	+	}
2104	+
2105	+
2106	+
2107	+
2108	+	lum_pos_mean= lum_pos_mean/sang;
2109	+	lum_pos2_mean= lum_pos2_mean/sang;
2110	+
2111	+	// XXX: sure this works? I'd suggest parenthesis.
2112	+	if ((set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) || set_lum_max2==3) {
2113	+
2114	+	if (set_lum_max2<3){
2115		lum_ideal = (E_vl_ext - E_v + E_v_contr) / omega_cos_contr;
2116	+	if (set_lum_max2 == 2 && lum_ideal >= 2e9) {
2117	+	printf("warning! luminance of replacement pixels would be larger than 2e9 cd/m2. Value set to 2e9cd/m2!\n") ;
2118	+	}
2119	+
2120		if (lum_ideal > 0 && lum_ideal < setvalue) {
2121		setvalue = lum_ideal;
2122		}
2123	<	printf
1768	<	("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2123	>	printf("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2124		lum_ideal, setvalue, E_vl_ext, E_v, E_v_contr);
2125	+	}else{setvalue=LUM_replace;
2126	+	}
2127
2128	<
2128	>
2129		for (x = 0; x < pict_get_xsize(p); x++)
2130		for (y = 0; y < pict_get_ysize(p); y++) {
2131		if (pict_get_hangle
2132		(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2133		if (pict_is_validpixel(p, x, y)) {
2134		lum = luminance(pict_get_color(p, x, y));
2135	+
2136	+
2137		if (set_lum_max2 == 1 && lum >= lum_max) {
2138
2139		pict_get_color(p, x, y)[RED] =
#	Line 1784 | Line 2143 | if (cut_view==2) {
2143		pict_get_color(p, x, y)[BLU] =
2144		setvalue / 179.0;
2145
2146	+	}else{ if(set_lum_max2 >1 ) {
2147	+	r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2148	+	if (x_disk == x && y_disk==y ) r_actual=0.0;
2149	+
2150	+	if (r_actual <= angle_disk) {
2151	+
2152	+	pict_get_color(p, x, y)[RED] =
2153	+	setvalue / 179.0;
2154	+	pict_get_color(p, x, y)[GRN] =
2155	+	setvalue / 179.0;
2156	+	pict_get_color(p, x, y)[BLU] =
2157	+	setvalue / 179.0;
2158	+
2159	+	}
2160		}
2161	+	}
2162		}
2163		}
2164		}
2165	+
2166
2167		pict_write(p, file_out2);
2168	<
2168	>	exit(1);
2169		}
2170		if (set_lum_max == 1) {
2171		pict_write(p, file_out2);
#	Line 1850 | Line 2225 | if (cut_view==1) {
2225		lum_source = lum_thres;
2226		}
2227
2228	<	/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2228	>	/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2229
2230		/* first glare source scan: find primary glare sources */
2231	<	for (x = 0; x < pict_get_xsize(p); x++)
2231	>	for (x = 0; x < pict_get_xsize(p); x++) {
2232	>	/*                lastpixelwas_gs=0; */
2233		for (y = 0; y < pict_get_ysize(p); y++) {
2234		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2235		if (pict_is_validpixel(p, x, y)) {
#	Line 1862 | Line 2238 | if (cut_view==1) {
2238		if (act_lum >lum_total_max) {
2239		lum_total_max=act_lum;
2240		}
2241	<
2242	<	actual_igs =
2243	<	find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2241	>	/* speed improvement first scan: when last pixel was glare source, then use this glare source number instead of searching.
2242	>	has been deactivated with v1.25
2243	>
2244	>	if (lastpixelwas_gs==0 || search_pix <= 1.0 ) { */
2245	>	actual_igs = find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2246	>	/*  }*/
2247		if (actual_igs == 0) {
2248		igs = igs + 1;
2249		pict_new_gli(p);
2250		pict_get_lum_min(p, igs) = HUGE_VAL;
2251		pict_get_Eglare(p,igs) = 0.0;
2252		pict_get_Dglare(p,igs) = 0.0;
2253	+	pict_get_z1_gsn(p,igs) = 0;
2254	+	pict_get_z2_gsn(p,igs) = 0;
2255		actual_igs = igs;
2256	+
2257		}
2258	<	icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2258	>	/* no coloring any more here            icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2259		pict_get_gsn(p, x, y) = actual_igs;
2260		pict_get_pgs(p, x, y) = 1;
2261		add_pixel_to_gs(p, x, y, actual_igs);
2262	+	/*                                                lastpixelwas_gs=actual_igs; */
2263
2264		} else {
2265		pict_get_pgs(p, x, y) = 0;
2266	+	/*                                               lastpixelwas_gs=0;*/
2267		}
2268		}
2269		}
2270	<	}
2270	>	}
2271	>	}
2272		/*      pict_write(p,"firstscan.pic");   */
2273
2274	<	if (calcfast == 1 ) {
2274	>
2275	>
2276	>
2277	>	if (calcfast ==1 || search_pix <= 1.0 || calcfast == 2 ) {
2278		skip_second_scan=1;
2279		}
2280	+
2281
2282		/* second glare source scan: combine glare sources facing each other */
2283		change = 1;
2284	+	i = 0;
2285		while (change == 1 && skip_second_scan==0) {
2286		change = 0;
2287	<	for (x = 0; x < pict_get_xsize(p); x++)
2287	>	i = i+1;
2288	>	for (x = 0; x < pict_get_xsize(p); x++) {
2289		for (y = 0; y < pict_get_ysize(p); y++) {
1899	–	before_igs = pict_get_gsn(p, x, y);
2290		if (pict_get_hangle
2291		(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2292	<	if (pict_is_validpixel(p, x, y) && before_igs > 0) {
2292	>	checkpixels=1;
2293	>	before_igs = pict_get_gsn(p, x, y);
2294	>
2295	>	/* speed improvement: search for other nearby glare sources only, when at least one adjacend pixel has another glare source number  */
2296	>	if (x >1 && x<pict_get_xsize(p)-2 && y >1 && y<pict_get_ysize(p)-2 )   {
2297	>	x1=x-1;
2298	>	x2=x+1;
2299	>	y1=y-1;
2300	>	y2=y+1;
2301	>	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) ) {
2302	>	checkpixels = 0;
2303	>	actual_igs = before_igs;
2304	>	}  }
2305	>
2306	>
2307	>	if (pict_is_validpixel(p, x, y) && before_igs > 0 && checkpixels==1) {
2308		actual_igs =
2309		find_near_pgs(p, x, y, max_angle, before_igs,
2310		igs, 1);
#	Line 1908 | Line 2313 | if (calcfast == 1 ) {
2313		}
2314		if (before_igs > 0) {
2315		actual_igs = pict_get_gsn(p, x, y);
2316	<	icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2316	>	/*      icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2317		}
2318
2319		}
2320		}
2321		}
2322		/*      pict_write(p,"secondscan.pic");*/
2323	+	}}
2324
1919	–	}
1920	–
2325		/*smoothing: add secondary glare sources */
2326		i_max = igs;
2327		if (sgs == 1) {
#	Line 1974 | Line 2378 | if (calcfast == 1 ) {
2378		if (i_splitstart == (igs + 1)) {
2379		igs = igs + 1;
2380		pict_new_gli(p);
2381	+	pict_get_z1_gsn(p,igs) = 0;
2382	+	pict_get_z2_gsn(p,igs) = 0;
2383	+
2384		pict_get_Eglare(p,igs) = 0.0;
2385		pict_get_Dglare(p,igs) = 0.0;
2386		pict_get_lum_min(p, igs) =
#	Line 1987 | Line 2394 | if (calcfast == 1 ) {
2394		if (i_split == 0) {
2395		igs = igs + 1;
2396		pict_new_gli(p);
2397	+	pict_get_z1_gsn(p,igs) = 0;
2398	+	pict_get_z2_gsn(p,igs) = 0;
2399	+
2400		pict_get_Eglare(p,igs) = 0.0;
2401		pict_get_Dglare(p,igs) = 0.0;
2402		pict_get_lum_min(p, igs) =
#	Line 2023 | Line 2433 | if (calcfast == 1 ) {
2433		if (before_igs > 0) {
2434		actual_igs =
2435		pict_get_gsn(p, x, y);
2436	<	icol =
2436	>	/*                                                                                     icol =
2437		setglcolor(p, x, y,
2438	<	actual_igs, uniform_gs, u_r, u_g , u_b);
2438	>	actual_igs, uniform_gs, u_r, u_g , u_b);*/
2439		}
2440
2441		}
#	Line 2040 | Line 2450 | if (calcfast == 1 ) {
2450		}
2451		}
2452
2453	<	/* calculation of direct vertical illuminance for CGI and for disability glare*/
2453	>	/* calculation of direct vertical illuminance for CGI and for disability glare, coloring glare sources*/
2454
2455	<
2046	<	if (calcfast == 0) {
2455	>	if (calcfast == 0 || calcfast == 2) {
2456		for (x = 0; x < pict_get_xsize(p); x++)
2457		for (y = 0; y < pict_get_ysize(p); y++) {
2458		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2459		if (pict_is_validpixel(p, x, y)) {
2460		if (pict_get_gsn(p, x, y) > 0) {
2461	<	pict_get_Eglare(p,pict_get_gsn(p, x, y)) +=
2462	<	DOT(p->view.vdir, pict_get_cached_dir(p, x, y))
2463	<	* pict_get_omega(p, x, y)
2464	<	* luminance(pict_get_color(p, x, y));
2465	<	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));
2461	>	actual_igs = pict_get_gsn(p, x, y);
2462	>	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));
2463	>	pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
2464	>	E_v_dir = E_v_dir + delta_E;
2465	>	setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2466		}
2467		}
2468		}
2469		}
2470		lum_backg_cos = (E_v - E_v_dir) / 3.1415927;
2471	<	lum_backg = lum_backg_cos;
2471	>
2472		}
2473	<	/* calc of band luminance if applied */
2473	>	/* calc of band luminance distribution if applied */
2474		if (band_calc == 1) {
2475	<	band_avlum=get_band_lum( p, band_angle, band_color);
2476	<	}
2475	>	x_max = pict_get_xsize(p) - 1;
2476	>	y_max = pict_get_ysize(p) - 1;
2477	>	y_mid = (int)(y_max/2);
2478	>	for (x = 0; x <= x_max; x++)
2479	>	for (y = 0; y <= y_max; y++) {
2480	>	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2481	>	if (pict_is_validpixel(p, x, y)) {
2482
2483	+	r_actual = acos(DOT(pict_get_cached_dir(p, x, y_mid), pict_get_cached_dir(p, x, y))) ;
2484	+	act_lum = luminance(pict_get_color(p, x, y));
2485	+
2486	+	if ((r_actual <= band_angle) || (y == y_mid) ) {
2487	+	lum_band[0]=luminance(pict_get_color(p, x, y));
2488	+	muc_rvar_add_sample(s_band, lum_band);
2489	+	act_lum = luminance(pict_get_color(p, x, y));
2490	+	lum_band_av += pict_get_omega(p, x, y) * act_lum;
2491	+	omega_band += pict_get_omega(p, x, y);
2492	+	if (band_color == 1) {
2493	+	pict_get_color(p, x, y)[RED] = 0.0;
2494	+	pict_get_color(p, x, y)[GRN] = act_lum / WHTEFFICACY / CIE_gf;
2495	+	pict_get_color(p, x, y)[BLU] = 0.0;
2496	+	}
2497	+	}
2498	+	}}}
2499	+	lum_band_av=lum_band_av/omega_band;
2500	+	muc_rvar_get_vx(s_band,lum_band_std);
2501	+	muc_rvar_get_percentile(s_band,lum_band_median,0.75);
2502	+	per_75_band=lum_band_median[0];
2503	+	muc_rvar_get_percentile(s_band,lum_band_median,0.95);
2504	+	per_95_band=lum_band_median[0];
2505	+	muc_rvar_get_median(s_band,lum_band_median);
2506	+	muc_rvar_get_bounding_box(s_band,bbox_band);
2507	+
2508	+	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] );
2509	+	/*      av_lum = av_lum / omega_sum; */
2510	+	/*    printf("average luminance of band %f \n",av_lum);*/
2511	+	/*      printf("solid angle of band %f \n",omega_sum);*/
2512	+	}
2513	+
2514		/*printf("total number of glare sources: %i\n",igs); */
2515		lum_sources = 0;
2516		omega_sources = 0;
2517	+	i=0;
2518		for (x = 0; x <= igs; x++) {
2519	+	if (pict_get_npix(p, x) > 0) {
2520		lum_sources += pict_get_av_lum(p, x) * pict_get_av_omega(p, x);
2521		omega_sources += pict_get_av_omega(p, x);
2522	+	i=i+1;
2523	+	}}
2524	+
2525	+	if (sang == omega_sources) {
2526	+	lum_backg =avlum;
2527	+	} else {
2528	+	lum_backg =(sang * avlum - lum_sources) / (sang - omega_sources);
2529		}
2530	<	if (non_cos_lb == 1) {
2531	<	lum_backg =
2532	<	(sang * avlum - lum_sources) / (sang - omega_sources);
2530	>
2531	>
2532	>	if (i == 0) {
2533	>	lum_sources =0.0;
2534	>	} else { lum_sources=lum_sources/omega_sources;
2535		}
2536	+
2537	+
2538	+
2539	+	if (non_cos_lb == 0) {
2540	+	lum_backg = lum_backg_cos;
2541	+	}
2542	+
2543	+	/* file writing NOT here
2544	+	if (checkfile == 1) {
2545	+	pict_write(p, file_out);
2546	+	}
2547	+	*/
2548	+
2549		/* print detailed output */
2550	+
2551	+
2552	+
2553	+	/* masking */
2554	+
2555	+	if ( masking == 1 ) {
2556	+
2557	+
2558	+	for (x = 0; x < pict_get_xsize(p); x++)
2559	+	for (y = 0; y < pict_get_ysize(p); y++) {
2560	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2561	+	if (pict_is_validpixel(p, x, y)) {
2562	+	if (luminance(pict_get_color(pm, x, y))>0.1) {
2563	+	/*                                         printf ("hallo %i %i %f \n",x,y,luminance(pict_get_color(pm, x, y)));*/
2564	+	i_mask=i_mask+1;
2565	+	lum_mask[0]=luminance(pict_get_color(p, x, y));
2566	+	/* printf ("%f \n",lum_mask[0]);*/
2567	+	muc_rvar_add_sample(s_mask, lum_mask);
2568	+	omega_mask += pict_get_omega(p, x, y);
2569	+	lum_mask_av += pict_get_omega(p, x, y)* luminance(pict_get_color(p, x, y));
2570	+	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));
2571	+
2572	+	pict_get_color(pm, x, y)[RED] = luminance(pict_get_color(p, x, y))/179.0;
2573	+	pict_get_color(pm, x, y)[GRN] = luminance(pict_get_color(p, x, y))/179.0;
2574	+	pict_get_color(pm, x, y)[BLU] = luminance(pict_get_color(p, x, y))/179.0;
2575	+
2576	+	} else {
2577	+	pict_get_color(p, x, y)[RED] = 0.0 ;
2578	+	pict_get_color(p, x, y)[GRN] = 0.0 ;
2579	+	pict_get_color(p, x, y)[BLU] = 0.0 ;
2580	+	}
2581	+	}
2582	+	}
2583	+	}
2584	+	/* Average luminance in masking area (weighted by solid angle) */
2585	+	lum_mask_av=lum_mask_av/omega_mask;
2586	+	muc_rvar_get_vx(s_mask,lum_mask_std);
2587	+	muc_rvar_get_percentile(s_mask,lum_mask_median,0.75);
2588	+	per_75_mask=lum_mask_median[0];
2589	+	muc_rvar_get_percentile(s_mask,lum_mask_median,0.95);
2590	+	per_95_mask=lum_mask_median[0];
2591	+	muc_rvar_get_median(s_mask,lum_mask_median);
2592	+	muc_rvar_get_bounding_box(s_mask,bbox);
2593	+	/* PSGV only why masking of window is applied! */
2594	+	pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av);
2595	+	pgsv_sat =get_pgsv_sat(E_v);
2596	+
2597		if (detail_out == 1) {
2598	+
2599	+	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 );
2600	+
2601	+	}
2602	+
2603	+	}
2604	+
2605	+	/* zones */
2606	+
2607	+	if ( zones > 0 ) {
2608	+
2609	+	for (x = 0; x < pict_get_xsize(p); x++)
2610	+	for (y = 0; y < pict_get_ysize(p); y++) {
2611	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2612	+	if (pict_is_validpixel(p, x, y)) {
2613	+
2614	+
2615	+	r_actual =acos(DOT(pict_get_cached_dir(p, x, y), pict_get_cached_dir(p, x_zone, y_zone))) * 2;
2616	+	lum_actual = luminance(pict_get_color(p, x, y));
2617	+	act_gsn=pict_get_gsn(p, x, y);
2618	+	/*     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));*/
2619	+
2620	+	/*zone1 */
2621	+	if (r_actual <= angle_z1) {
2622	+	i_z1=i_z1+1;
2623	+	lum_z1[0]=lum_actual;
2624	+	muc_rvar_add_sample(s_z1, lum_z1);
2625	+	omega_z1 += pict_get_omega(p, x, y);
2626	+	lum_z1_av += pict_get_omega(p, x, y)* lum_actual;
2627	+	setglcolor(p,x,y,1,1 , 0.66, 0.01 ,0.33);
2628	+	/*check if separation gsn already exist */
2629	+
2630	+	if (act_gsn > 0){
2631	+	if (pict_get_z1_gsn(p,act_gsn) == 0) {
2632	+	pict_new_gli(p);
2633	+	igs = igs + 1;
2634	+	pict_get_z1_gsn(p,act_gsn) = igs*1.000;
2635	+	pict_get_z1_gsn(p,igs) = -1.0;
2636	+	pict_get_z2_gsn(p,igs) = -1.0;
2637	+	splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2638	+	/*                                                                                        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)); */
2639	+	}
2640	+	splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2641	+	/*          printf("splitgs%i \n",splitgs);       */
2642	+	split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2643	+	}
2644	+	}
2645	+	/*zone2 */
2646	+
2647	+	if (r_actual > angle_z1 && r_actual<= angle_z2 ) {
2648	+
2649	+	i_z2=i_z2+1;
2650	+	lum_z2[0]=lum_actual;
2651	+	muc_rvar_add_sample(s_z2, lum_z2);
2652	+	omega_z2 +=   pict_get_omega(p, x, y);
2653	+	lum_z2_av += pict_get_omega(p, x, y)* lum_actual;
2654	+	setglcolor(p,x,y,1,1 , 0.65, 0.33 ,0.02);
2655	+	/*                                                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));
2656	+	*/                                                if (act_gsn > 0){
2657	+	if (pict_get_z2_gsn(p,act_gsn) == 0) {
2658	+	pict_new_gli(p);
2659	+	igs = igs + 1;
2660	+	pict_get_z2_gsn(p,act_gsn) = igs*1.000;
2661	+	pict_get_z1_gsn(p,igs) = -2.0;
2662	+	pict_get_z2_gsn(p,igs) = -2.0;
2663	+	/*                                                                                         printf ("Glare source %i gets glare source %i in zone 2 \n",act_gsn,igs ); */
2664	+	}
2665	+	splitgs=(int)(pict_get_z2_gsn(p,act_gsn));
2666	+	/*                                              printf("splitgs %i \n",splitgs);*/
2667	+	split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2668	+	}
2669	+	}
2670	+
2671	+	}
2672	+	} }
2673	+	/* Average luminance in zones (weighted by solid angle), calculate percentiles, median min and max in zones  */
2674	+	if (zones == 2 ) {
2675	+	lum_z2_av=lum_z2_av/omega_z2;
2676	+	muc_rvar_get_vx(s_z2,lum_z2_std);
2677	+	muc_rvar_get_percentile(s_z2,lum_z2_median,0.75);
2678	+	per_75_z2=lum_z2_median[0];
2679	+	muc_rvar_get_percentile(s_z2,lum_z2_median,0.95);
2680	+	per_95_z2=lum_z2_median[0];
2681	+	muc_rvar_get_median(s_z2,lum_z2_median);
2682	+	muc_rvar_get_bounding_box(s_z2,bbox_z2);
2683	+	}
2684	+	lum_z1_av=lum_z1_av/omega_z1;
2685	+	muc_rvar_get_vx(s_z1,lum_z1_std);
2686	+	muc_rvar_get_percentile(s_z1,lum_z1_median,0.75);
2687	+	per_75_z1=lum_z1_median[0];
2688	+	muc_rvar_get_percentile(s_z1,lum_z1_median,0.95);
2689	+	per_95_z1=lum_z1_median[0];
2690	+	muc_rvar_get_median(s_z1,lum_z1_median);
2691	+	muc_rvar_get_bounding_box(s_z1,bbox_z1);
2692	+	if (detail_out == 1) {
2693	+
2694	+	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] );
2695	+
2696	+	if (zones == 2 ) {
2697	+
2698	+	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] );
2699	+	} }
2700	+
2701	+	}
2702	+
2703		i = 0;
2704		for (x = 0; x <= igs; x++) {
2705		/* resorting glare source numbers */
#	Line 2089 | Line 2707 | if (calcfast == 1 ) {
2707		i = i + 1;
2708		}
2709		}
2710	+	no_glaresources=i;
2711
2712	+	/* glare sources */
2713	+	if (detail_out == 1) {
2714
2094	–
2715		printf
2716	<	("%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",
2716	>	("%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",
2717		i);
2718		if (i == 0) {
2719	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f\n", i, 0.0, 0.0,
2720	<	0.0, 0.0, 0.0, 0.0, lum_backg, lum_task, E_v, E_v_dir,
2101	<	abs_max);
2719	>	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,
2720	>	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);
2721
2722		} else {
2723		i = 0;
#	Line 2118 | Line 2737 | if (calcfast == 1 ) {
2737		Lveil_cie =0 ;
2738		}
2739		Lveil_cie_sum =  Lveil_cie_sum + Lveil_cie;
2740	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
2740	>	if (pict_get_z1_gsn(p,x)<0) {
2741	>	act_gsn=(int)(-pict_get_z1_gsn(p,x));
2742	>	}else{
2743	>	act_gsn=0;
2744	>	}
2745	>	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %i \n",
2746		i, pict_get_npix(p, x), pict_get_av_posx(p, x),
2747		pict_get_ysize(p) - pict_get_av_posy(p, x),
2748		pict_get_av_lum(p, x), pict_get_av_omega(p, x),
#	Line 2126 | Line 2750 | if (calcfast == 1 ) {
2750		pict_get_av_posy(p, x),
2751		posindex_2), lum_backg, lum_task,
2752		E_v, E_v_dir, abs_max, sigma * 180 / 3.1415927
2753	<	,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	<	);
2753	>	,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 );
2754		}
2755		}
2756		}
#	Line 2168 | Line 2790 | if (calcfast == 1 ) {
2790		}
2791
2792		if (calcfast == 0) {
2793	+	lum_a= E_v2/3.1415927;
2794		dgi = get_dgi(p, lum_backg, igs, posindex_2);
2795		ugr = get_ugr(p, lum_backg, igs, posindex_2);
2796	+	ugp = get_ugp (p,lum_backg, igs, posindex_2);
2797	+	ugr_exp = get_ugr_exp (p,lum_backg_cos,lum_a, igs, posindex_2);
2798	+	dgi_mod = get_dgi_mod(p, lum_a, igs, posindex_2);
2799		cgi = get_cgi(p, E_v, E_v_dir, igs, posindex_2);
2800	<	vcp = get_vcp(p, avlum, igs, posindex_2);
2800	>	dgr = get_dgr(p, avlum, igs, posindex_2);
2801	>	vcp = get_vcp(dgr);
2802		Lveil = get_disability(p, avlum, igs);
2803	+	if (no_glaresources == 0) {
2804	+	dgi = 0.0;
2805	+	ugr = 0.0;
2806	+	ugp = 0.0;
2807	+	ugr_exp = 0.0;
2808	+	dgi_mod = 0.0;
2809	+	cgi = 0.0;
2810	+	dgr = 0.0;
2811	+	vcp = 100.0;
2812	+	}
2813		}
2814		/* check dgp range */
2815		if (dgp <= 0.2) {
#	Line 2198 | Line 2835 | if (calcfast == 0) {
2835		dgp =low_light_corr*dgp;
2836		dgp =age_corr_factor*dgp;
2837		}
2838	+	muc_rvar_get_median(s_noposweight,lum_nopos_median);
2839	+	muc_rvar_get_median(s_posweight,lum_pos_median);
2840	+	muc_rvar_get_median(s_posweight2,lum_pos2_median);
2841	+
2842
2843	+
2844	+
2845		printf
2846	<	("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",
2846	>	("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",
2847		dgp, avlum, E_v, lum_backg, E_v_dir, dgi, ugr, vcp, cgi,
2848	<	lum_sources / omega_sources, omega_sources, Lveil,Lveil_cie_sum,band_avlum);
2848	>	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]);
2849		} else {
2850		if (detail_out2 == 1) {
2851
#	Line 2233 | Line 2876 | if (calcfast == 0) {
2876		if (E_vl_ext < 1000) {
2877		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 ;}
2878		dgp =low_light_corr*dgp;
2879	<	dgp =age_corr_factor*dgp;
2880	<	printf("%f\n", dgp);
2879	>
2880	>	if (calcfast == 2) {
2881	>
2882	>	lum_backg_cos=(E_vl_ext-dir_ill)/3.1415927;
2883	>	ugr = get_ugr(p, lum_backg_cos, igs, posindex_2);
2884	>	printf("%f %f \n", dgp,ugr);
2885	>	}else{
2886	>	printf("%f\n", dgp);
2887	>	}
2888		}
2889
2890
#	Line 2265 | Line 2915 | has to be re-written from scratch....
2915
2916		/*output  */
2917		if (checkfile == 1) {
2918	+
2919	+
2920		pict_write(p, file_out);
2921		}
2922
2923
2924	<
2924	>	pict_free(p);
2925	>	pict_free(pm);
2926	>	muc_rvar_free(s_mask);
2927	>	muc_rvar_free(s_band);
2928	>	muc_rvar_free(s_z1);
2929	>	muc_rvar_free(s_z2);
2930	>	muc_rvar_free(s_noposweight);
2931	>	muc_rvar_free(s_posweight);
2932	>	muc_rvar_free(s_posweight2);
2933	>	free(cline);
2934		return EXIT_SUCCESS;
2274	–	exit(0);
2935
2936		userr:
2937		fprintf(stderr,
2938		"Usage: %s [-s][-d][-c picture][-t xpos ypos angle] [-T xpos ypos angle] [-b fact] [-r angle] [-y] [-Y lum] [-i Ev] [-I Ev ymax ymin] [-v] picfile\n",
2939		progname);
2940	<	exit(1);
2940	>	pict_free(p);
2941	>	pict_free(pm);
2942	>	muc_rvar_free(s_mask);
2943	>	muc_rvar_free(s_band);
2944	>	muc_rvar_free(s_z1);
2945	>	muc_rvar_free(s_z2);
2946	>	muc_rvar_free(s_noposweight);
2947	>	muc_rvar_free(s_posweight);
2948	>	muc_rvar_free(s_posweight2);
2949	>	free(cline);
2950	>	return 1;
2951		}
2952
2953

Diff Legend

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