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.2 by greg, Tue Aug 18 15:02:53 2015 UTC vs.
Revision 2.3 by greg, Thu Jul 14 17:32:12 2016 UTC

#	Line 1 | Line 1
1		#ifndef lint
2		static const char RCSid[] = "$Id$";
3		#endif
4	<	/* EVALGLARE V1.17
5	<	* Evalglare Software License, Version 1.0
4	>	/* EVALGLARE V1.29
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 23 | Line 23 | static const char RCSid[] = "$Id$";
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 31 | Line 31 | static const char RCSid[] = "$Id$";
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 48 | Line 48 | static const char RCSid[] = "$Id$";
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 278 | Line 278 | static const char RCSid[] = "$Id$";
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	+	#define EVALGLARE
312		#define PROGNAME "evalglare"
313	<	#define VERSION "1.17 release 15.07.2015 by EPFL, J.Wienold"
313	>	#define VERSION "1.29 release 12.07.2016 by EPFL, J.Wienold"
314		#define RELEASENAME PROGNAME " " VERSION
315
316	<	#include "rtio.h"
288	<	#include "platform.h"
316	>
317		#include "pictool.h"
318	+	#include "rtio.h"
319		#include <math.h>
320		#include <string.h>
321	+	#include "platform.h"
322	+	#include "muc_randvar.h"
323	+
324		char *progname;
325
326		/* subroutine to add a pixel to a glare source */
#	Line 564 | Line 596 | double get_task_lum(pict * p, int x, int y, float r, i
596		return av_lum;
597		}
598
567	–	/* subroutine for calculation of band luminance */
568	–	double get_band_lum(pict * p, float r, int task_color)
569	–	{
570	–	int x_min, x_max, y_min, y_max, ix, iy, y_mid;
571	–	double r_actual, av_lum, omega_sum, act_lum;
599
600
574	–	x_max = pict_get_xsize(p) - 1;
575	–	y_max = pict_get_ysize(p) - 1;
576	–	x_min = 0;
577	–	y_min = 0;
578	–	y_mid = rint(y_max/2);
601
602
581	–
582	–	av_lum = 0.0;
583	–	omega_sum = 0.0;
584	–
585	–	for (iy = y_min; iy <= y_max; iy++) {
586	–	for (ix = x_min; ix <= x_max; ix++) {
587	–
588	–	/*                      if (DOT(pict_get_cached_dir(p,ix,iy),p->view.vdir) < 0.0)
589	–	continue;*/
590	–	r_actual =
591	–	acos(DOT(pict_get_cached_dir(p, ix, y_mid),
592	–	pict_get_cached_dir(p, ix, iy))) ;
593	–	act_lum = luminance(pict_get_color(p, ix, iy));
594	–
595	–	if ((r_actual <= r) || (iy == y_mid) ) {
596	–	act_lum = luminance(pict_get_color(p, ix, iy));
597	–	av_lum += pict_get_omega(p, ix, iy) * act_lum;
598	–	omega_sum += pict_get_omega(p, ix, iy);
599	–	if (task_color == 1) {
600	–	pict_get_color(p, ix, iy)[RED] = 0.0;
601	–	pict_get_color(p, ix, iy)[GRN] = act_lum / WHTEFFICACY / CIE_gf;
602	–	pict_get_color(p, ix, iy)[BLU] = 0.0;
603	–	}
604	–	}
605	–	}
606	–	}
607	–
608	–	av_lum = av_lum / omega_sum;
609	–	/*    printf("average luminance of band %f \n",av_lum);*/
610	–	/*      printf("solid angle of band %f \n",omega_sum);*/
611	–	return av_lum;
612	–	}
613	–
614	–
615	–
616	–
617	–
603		/* subroutine for coloring the glare sources
604		red is used only for explicit call of the subroutine with acol=0  , e.g. for disability glare
605		-1: set to grey*/
#	Line 626 | Line 611 | int setglcolor(pict * p, int x, int y, int acol, int u
611		l=u_r+u_g+u_b ;
612
613		pcol[RED][0] = 1.0 / CIE_rf;
614	<	pcol[GRN][0] = 0.;
615	<	pcol[BLU][0] = 0.;
614	>	pcol[GRN][0] = 0.0 / CIE_gf;
615	>	pcol[BLU][0] = 0.0 / CIE_bf;
616
617	<	pcol[RED][1] = 0.;
617	>	pcol[RED][1] = 0.0 / CIE_rf;
618		pcol[GRN][1] = 1.0 / CIE_gf;
619	<	pcol[BLU][1] = 0.;
619	>	pcol[BLU][1] = 0.0 / CIE_bf;
620
621	<	pcol[RED][2] = 0.;
622	<	pcol[GRN][2] = 0.;
623	<	pcol[BLU][2] = 1 / CIE_bf;
621	>	pcol[RED][2] = 0.15 / CIE_rf;
622	>	pcol[GRN][2] = 0.15 / CIE_gf;
623	>	pcol[BLU][2] = 0.7 / CIE_bf;
624
625	<	pcol[RED][3] = 1.0 / (1.0 - CIE_bf);
626	<	pcol[GRN][3] = 1.0 / (1.0 - CIE_bf);
627	<	pcol[BLU][3] = 0.;
625	>	pcol[RED][3] = .5 / CIE_rf;
626	>	pcol[GRN][3] = .5 / CIE_gf;
627	>	pcol[BLU][3] = 0.0 / CIE_bf;
628
629	<	pcol[RED][4] = 1.0 / (1.0 - CIE_gf);
630	<	pcol[GRN][4] = 0.;
631	<	pcol[BLU][4] = 1.0 / (1.0 - CIE_gf);
629	>	pcol[RED][4] = .5 / CIE_rf;
630	>	pcol[GRN][4] = .0 / CIE_gf;
631	>	pcol[BLU][4] = .5 / CIE_bf ;
632
633	<	pcol[RED][5] = 0.;
634	<	pcol[GRN][5] = 1.0 / (1.0 - CIE_rf);
635	<	pcol[BLU][5] = 1.0 / (1.0 - CIE_rf);
633	>	pcol[RED][5] = .0 / CIE_rf;
634	>	pcol[GRN][5] = .5 / CIE_gf;
635	>	pcol[BLU][5] = .5 / CIE_bf;
636
637	<	pcol[RED][6] = 0.;
638	<	pcol[GRN][6] = 1.0 / (1.0 - CIE_rf);
639	<	pcol[BLU][6] = 1.0 / (1.0 - CIE_rf);
637	>	pcol[RED][6] = 0.333 / CIE_rf;
638	>	pcol[GRN][6] = 0.333 / CIE_gf;
639	>	pcol[BLU][6] = 0.333 / CIE_bf;
640
641
642		pcol[RED][999] = 1.0 / WHTEFFICACY;
#	Line 662 | Line 647 | int setglcolor(pict * p, int x, int y, int acol, int u
647		pcol[RED][998] = u_r /(l* CIE_rf) ;
648		pcol[GRN][998] = u_g /(l* CIE_gf);
649		pcol[BLU][998] = u_b /(l* CIE_bf);
650	<	/*        printf("CIE_rf,CIE_gf,CIE_bf,l=%f %f %f %f\n",CIE_rf,CIE_gf,CIE_bf,l);*/
650	>	/*        printf("CIE_rf,CIE_gf,CIE_bf,l=%f %f %f %f %f\n",CIE_rf,CIE_gf,CIE_bf,l,WHTEFFICACY); */
651		icol = acol ;
652		if ( acol == -1) {icol=999;
653		}else{if (acol>0){icol = acol % 5 +1;
#	Line 675 | Line 660 | int setglcolor(pict * p, int x, int y, int acol, int u
660		pict_get_color(p, x, y)[RED] = pcol[RED][icol] * act_lum / WHTEFFICACY;
661		pict_get_color(p, x, y)[GRN] = pcol[GRN][icol] * act_lum / WHTEFFICACY;
662		pict_get_color(p, x, y)[BLU] = pcol[BLU][icol] * act_lum / WHTEFFICACY;
663	<
663	>	/*        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))); */
664		return icol;
665		}
666
#	Line 727 | Line 712 | void add_secondary_gs(pict * p, int x, int y, float r,
712
713		/* color pixel of gs */
714
715	<	icol = setglcolor(p, x, y, act_gs, uniform_gs, u_r, u_g , u_b);
715	>	/*              icol = setglcolor(p, x, y, act_gs, uniform_gs, u_r, u_g , u_b); */
716
717		}
718		}
#	Line 767 | Line 752 | void split_pixel_from_gs(pict * p, int x, int y, int n
752
753		/* color pixel of new gs */
754
755	<	icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b);
755	>	/*      icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b); */
756	>
757
772	–
758		}
759
760		/* subroutine for the calculation of the position index */
#	Line 800 | Line 785 | float get_posindex(pict * p, float x, float y, int pos
785		tau = tau * deg;
786		sigma = sigma * deg;
787
788	+	if (postype == 1) {
789	+	/* KIM  model */
790	+	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));
791	+	}else{
792	+	/* Guth model, equation from IES lighting handbook */
793		posindex =
794		exp((35.2 - 0.31889 * tau -
795		1.22 * exp(-2 * tau / 9)) / 1000 * sigma + (21 +
#	Line 821 | Line 811 | float get_posindex(pict * p, float x, float y, int pos
811
812		posindex = 1 + fact * r;
813		}
814	<	if (posindex > 16)
814	>	if (posindex > 16)
815		posindex = 16;
816	+	}
817
818		return posindex;
819
#	Line 1035 | Line 1026 | return;
1026
1027		}
1028
1029	<	/* subroutine for the calculation of the daylight glare index */
1029	>	/* subroutine for the calculation of the daylight glare index DGI*/
1030
1031
1032		float get_dgi(pict * p, float lum_backg, int igs, int posindex_2)
#	Line 1062 | Line 1053 | float get_dgi(pict * p, float lum_backg, int igs, int
1053		return dgi;
1054
1055		}
1056	+	/* subroutine for the calculation of the modified daylight glare index DGI_mod (Fisekis2003)
1057	+	several glare sources are taken into account and summed up, original equation has no summary
1058	+	*/
1059
1060	+
1061	+	float get_dgi_mod(pict * p, float lum_a, int igs, int posindex_2)
1062	+	{
1063	+	float dgi_mod, sum_glare, omega_s;
1064	+	int i;
1065	+
1066	+
1067	+	sum_glare = 0;
1068	+	omega_s = 0;
1069	+
1070	+	for (i = 0; i <= igs; i++) {
1071	+
1072	+	if (pict_get_npix(p, i) > 0) {
1073	+	omega_s =
1074	+	pict_get_av_omega(p, i) / get_posindex(p,pict_get_av_posx(p,i), pict_get_av_posy(p,i),posindex_2) /
1075	+	get_posindex(p, pict_get_av_posx(p, i), pict_get_av_posy(p, i), posindex_2);
1076	+	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));
1077	+	/*    printf("i,sum_glare %i %f\n",i,sum_glare); */
1078	+	}
1079	+	}
1080	+	dgi_mod = 10 * log10(sum_glare);
1081	+
1082	+	return dgi_mod;
1083	+
1084	+	}
1085	+
1086		/* subroutine for the calculation of the daylight glare probability */
1087		double
1088		get_dgp(pict * p, double E_v, int igs, double a1, double a2, double a3,
#	Line 1103 | Line 1123 | get_dgp(pict * p, double E_v, int igs, double a1, doub
1123		}
1124
1125		/* subroutine for the calculation of the visual comfort probability */
1126	<	float get_vcp(pict * p, double lum_a, int igs, int posindex_2)
1126	>	float get_dgr(pict * p, double lum_a, int igs, int posindex_2)
1127		{
1128	<	float vcp;
1129	<	double sum_glare, dgr;
1128	>	float dgr;
1129	>	double sum_glare;
1130		int i, i_glare;
1131
1132
#	Line 1132 | Line 1152 | float get_vcp(pict * p, double lum_a, int igs, int pos
1152		}
1153		dgr = pow(sum_glare, pow(i_glare, -0.0914));
1154
1155	+
1156	+
1157	+	return dgr;
1158	+
1159	+	}
1160	+
1161	+	float get_vcp(float dgr )
1162	+	{
1163	+	float vcp;
1164	+
1165		vcp = 50 * erf((6.347 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1166		if (dgr > 750) {
1167		vcp = 0;
#	Line 1139 | Line 1169 | float get_vcp(pict * p, double lum_a, int igs, int pos
1169		if (dgr < 20) {
1170		vcp = 100;
1171		}
1142	–
1143	–
1172		return vcp;
1173
1174		}
1175
1176	+
1177		/* subroutine for the calculation of the unified glare rating */
1178		float get_ugr(pict * p, double lum_backg, int igs, int posindex_2)
1179		{
#	Line 1172 | Line 1201 | float get_ugr(pict * p, double lum_backg, int igs, int
1201		return ugr;
1202
1203		}
1204	+	/* subroutine for the calculation of the experimental unified glare rating (Fisekis 2003)*/
1205	+	float get_ugr_exp(pict * p, double lum_backg, double lum_a, int igs, int posindex_2)
1206	+	{
1207	+	float ugr_exp;
1208	+	double sum_glare;
1209	+	int i, i_glare;
1210
1211
1212	+	sum_glare = 0;
1213	+	i_glare = 0;
1214	+	for (i = 0; i <= igs; i++) {
1215	+
1216	+	if (pict_get_npix(p, i) > 0) {
1217	+	i_glare = i_glare + 1;
1218	+	sum_glare +=
1219	+	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);
1220	+
1221	+	}
1222	+	}
1223	+	ugr_exp =8 * log10(lum_a) + 8 * log10(sum_glare/lum_backg);
1224	+
1225	+	return ugr_exp;
1226	+
1227	+	}
1228	+	/* subroutine for the calculation of the unified glare probability (Hirning 2014)*/
1229	+	float get_ugp(pict * p, double lum_backg, int igs, int posindex_2)
1230	+	{
1231	+	float ugp;
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(pict_get_av_lum(p, i) /
1244	+	get_posindex(p, pict_get_av_posx(p, i),
1245	+	pict_get_av_posy(p, i), posindex_2),
1246	+	2) * pict_get_av_omega(p, i);
1247	+
1248	+	}
1249	+	}
1250	+	ugp = 0.26 * log10(0.25 / lum_backg * sum_glare);
1251	+
1252	+	return ugp;
1253	+
1254	+	}
1255	+
1256	+
1257		/* subroutine for the calculation of the disability glare according to Poynter */
1258		float get_disability(pict * p, double lum_backg, int igs)
1259		{
#	Line 1221 | Line 1301 | float get_disability(pict * p, double lum_backg, int i
1301
1302		/* subroutine for the calculation of the cie glare index */
1303
1304	<	float
1225	<	get_cgi(pict * p, double E_v, double E_v_dir, int igs, int posindex_2)
1304	>	float get_cgi(pict * p, double E_v, double E_v_dir, int igs, int posindex_2)
1305		{
1306		float cgi;
1307		double sum_glare;
#	Line 1246 | Line 1325 | get_cgi(pict * p, double E_v, double E_v_dir, int igs,
1325		cgi = 8 * log10((2 * (1 + E_v_dir / 500) / E_v) * sum_glare);
1326
1327		return cgi;
1328	+	}
1329
1330	+	/* 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! */
1331	+	float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av)
1332	+	{
1333	+	float pgsv;
1334	+	double Lb;
1335	+
1336	+	Lb = (E_v-E_mask)/1.414213562373;
1337	+
1338	+	pgsv =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1339	+
1340	+
1341	+	return pgsv;
1342		}
1343
1344	+	/* 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! */
1345	+	float get_pgsv_sat(double E_v)
1346	+	{
1347	+	float pgsv_sat;
1348
1349	+	pgsv_sat =3.3-(0.57+3.3)/pow((1+E_v/1.414213562373/1250),1.7);
1350	+
1351	+
1352	+	return pgsv_sat;
1353	+	}
1354	+
1355	+
1356	+
1357	+
1358		#ifdef  EVALGLARE
1359
1360
#	Line 1261 | Line 1366 | int main(int argc, char **argv)
1366		{
1367		#define CLINEMAX 4095 /* memory allocated for command line string */
1368		pict *p = pict_create();
1369	<	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, y1, fill, yfillmax, yfillmin,
1370	<	ext_vill, set_lum_max, set_lum_max2, task_color, i_splitstart,
1371	<	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,
1372	<	igs, actual_igs, icol, xt, yt, change, before_igs, sgs, splithigh,uniform_gs,
1373	<	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx, rmy,apply_disability,band_calc,band_color;
1374	<	double  lum_total_max,age_corr_factor,age,dgp_ext,dgp,low_light_corr,omega_cos_contr, setvalue, lum_ideal, E_v_contr, sigma,
1375	<	E_vl_ext, lum_max, new_lum_max, r_center,
1376	<	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,
1377	<	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang,
1378	<	l_max, lum_backg, lum_backg_cos, omega_sources, lum_sources,
1379	<	lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum;
1380	<	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit,
1369	>	pict *pm = pict_create();
1370	>	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1371	>	ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,
1372	>	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,x_zone,y_zone, i_z1, i_z2,
1373	>	igs, actual_igs, lastpixelwas_gs, icol, xt, yt, change,checkpixels, before_igs, sgs, splithigh,uniform_gs,x_max, y_max,y_mid,
1374	>	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx,rmy,apply_disability,band_calc,band_color,masking,i_mask,no_glaresources,force;
1375	>	double  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,
1376	>	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,
1377	>	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,
1378	>	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang, angle_z1, angle_z2,per_95_band,per_75_band,pos,
1379	>	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,
1380	>	lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum,
1381	>	lum_mask[1],lum_mask_av,lum_mask_std[1],lum_mask_median[1],omega_mask,bbox[2],
1382	>	lum_band[1],lum_band_av,lum_band_std[1],lum_band_median[1],omega_band,bbox_band[2],
1383	>	lum_z1[1],lum_z1_av,lum_z1_std[1],lum_z1_median[1],omega_z1,bbox_z1[2],
1384	>	lum_z2[1],lum_z2_av,lum_z2_std[1],lum_z2_median[1],omega_z2,bbox_z2[2],
1385	>	lum_pos[1],lum_nopos_median[1],lum_pos_median[1],lum_pos2_median[1],lum_pos_mean,lum_pos2_mean;
1386	>	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,
1387		abs_max, Lveil;
1388	<	char file_out[500], file_out2[500], version[500];
1388	>	char maskfile[500],file_out[500], file_out2[500], version[500];
1389		char *cline;
1390		VIEW userview = STDVIEW;
1391		int gotuserview = 0;
1392	+	struct muc_rvar* s_mask;
1393	+	s_mask = muc_rvar_create();
1394	+	muc_rvar_set_dim(s_mask, 1);
1395	+	muc_rvar_clear(s_mask);
1396	+	struct muc_rvar* s_band;
1397	+	s_band = muc_rvar_create();
1398	+	muc_rvar_set_dim(s_band, 1);
1399	+	muc_rvar_clear(s_band);
1400	+	struct muc_rvar* s_z1;
1401	+	s_z1 = muc_rvar_create();
1402	+	muc_rvar_set_dim(s_z1, 1);
1403	+	muc_rvar_clear(s_z1);
1404
1405	+	struct muc_rvar* s_z2;
1406	+	s_z2 = muc_rvar_create();
1407	+	muc_rvar_set_dim(s_z2, 1);
1408	+	muc_rvar_clear(s_z2);
1409	+
1410	+	struct muc_rvar* s_noposweight;
1411	+	s_noposweight = muc_rvar_create();
1412	+	muc_rvar_set_dim(s_noposweight, 1);
1413	+	muc_rvar_clear(s_noposweight);
1414	+
1415	+	struct muc_rvar* s_posweight;
1416	+	s_posweight = muc_rvar_create();
1417	+	muc_rvar_set_dim(s_posweight, 1);
1418	+	muc_rvar_clear(s_posweight);
1419	+
1420	+	struct muc_rvar* s_posweight2;
1421	+	s_posweight2 = muc_rvar_create();
1422	+	muc_rvar_set_dim(s_posweight2, 1);
1423	+	muc_rvar_clear(s_posweight2);
1424	+
1425		/*set required user view parameters to invalid values*/
1426	<	uniform_gs = 0;
1426	>	delta_E=0.0;
1427	>	no_glaresources=0;
1428	>	n_corner_px=0;
1429	>	zero_corner_px=0;
1430	>	force=0;
1431	>	dist=0.0;
1432	>	u_r=0.33333;
1433	>	u_g=0.33333;
1434	>	u_b=0.33333;
1435	>	band_angle=0;
1436	>	angle_z1=0;
1437	>	angle_z2=0;
1438	>	x_zone=0;
1439	>	y_zone=0;
1440	>	per_75_z2=0;
1441	>	per_95_z2=0;
1442	>	lum_pos_mean=0;
1443	>	lum_pos2_mean=0;
1444	>	lum_band_av = 0.0;
1445	>	omega_band = 0.0;
1446	>	pgsv = 0.0 ;
1447	>	pgsv_sat = 0.0 ;
1448	>	E_v_mask = 0.0;
1449	>	lum_z1_av = 0.0;
1450	>	omega_z1 = 0.0;
1451	>	lum_z2_av = 0.0;
1452	>	omega_z2 = 0.0 ;
1453	>	i_z1 = 0;
1454	>	i_z2 = 0;
1455	>	zones = 0;
1456	>	lum_z2_av = 0.0;
1457	>	uniform_gs = 0;
1458		apply_disability = 0;
1459		disability_thresh = 0;
1460		Lveil_cie_sum=0.0;
#	Line 1300 | Line 1474 | int main(int argc, char **argv)
1474		omegat = 0.0;
1475		yt = 0;
1476		xt = 0;
1477	+	x_disk=0;
1478	+	y_disk=0;
1479	+	angle_disk=0;
1480		yfillmin = 0;
1481		yfillmax = 0;
1482		cut_view = 0;
#	Line 1332 | Line 1509 | int main(int argc, char **argv)
1509		limit = 50000.0;
1510		set_lum_max = 0;
1511		set_lum_max2 = 0;
1512	+	img_corr=0;
1513		abs_max = 0;
1514		progname = argv[0];
1515		E_v_contr = 0.0;
1516	<	strcpy(version, "1.15 release 05.02.2015 by J.Wienold");
1516	>	strcpy(version, "1.19 release 09.12.2015 by J.Wienold");
1517		low_light_corr=1.0;
1518		output = 0;
1519		calc_vill = 0;
1520		band_avlum = -99;
1521		band_calc = 0;
1522	+	masking = 0;
1523	+	lum_mask[0]=0.0;
1524	+	lum_mask_av=0.0;
1525	+	omega_mask=0.0;
1526	+	i_mask=0;
1527	+	actual_igs=0;
1528		/* command line for output picture*/
1529
1530		cline = (char *) malloc(CLINEMAX+1);
#	Line 1382 | Line 1566 | int main(int argc, char **argv)
1566		printf("age factor not supported any more \n");
1567		exit(1);
1568		break;
1569	+	case 'A':
1570	+	masking = 1;
1571	+	detail_out = 1;
1572	+	strcpy(maskfile, argv[++i]);
1573	+	pict_read(pm,maskfile );
1574	+
1575	+	break;
1576		case 'b':
1577		lum_thres = atof(argv[++i]);
1578		break;
#	Line 1401 | Line 1592 | int main(int argc, char **argv)
1592		case 's':
1593		sgs = 1;
1594		break;
1595	+	case 'f':
1596	+	force = 1;
1597	+	break;
1598		case 'k':
1599		apply_disability = 1;
1600		disability_thresh = atof(argv[++i]);
#	Line 1409 | Line 1603 | int main(int argc, char **argv)
1603		case 'p':
1604		posindex_picture = 1;
1605		break;
1606	+	case 'P':
1607	+	posindex_2 = atoi(argv[++i]);
1608	+	break;
1609	+
1610
1611		case 'y':
1612		splithigh = 1;
#	Line 1439 | Line 1637 | int main(int argc, char **argv)
1637		detail_out2 = 1;
1638		break;
1639		case 'm':
1640	+	img_corr = 1;
1641		set_lum_max = 1;
1642		lum_max = atof(argv[++i]);
1643		new_lum_max = atof(argv[++i]);
#	Line 1447 | Line 1646 | int main(int argc, char **argv)
1646		break;
1647
1648		case 'M':
1649	+	img_corr = 1;
1650		set_lum_max2 = 1;
1651		lum_max = atof(argv[++i]);
1652		E_vl_ext = atof(argv[++i]);
1653		strcpy(file_out2, argv[++i]);
1654		/*                      printf("max lum set to %f\n",new_lum_max);*/
1655		break;
1656	+	case 'N':
1657	+	img_corr = 1;
1658	+	set_lum_max2 = 2;
1659	+	x_disk = atoi(argv[++i]);
1660	+	y_disk = atoi(argv[++i]);
1661	+	angle_disk = atof(argv[++i]);
1662	+	E_vl_ext = atof(argv[++i]);
1663	+	strcpy(file_out2, argv[++i]);
1664	+	/*                      printf("max lum set to %f\n",new_lum_max);*/
1665	+	break;
1666	+
1667		case 'n':
1668		non_cos_lb = 0;
1669		break;
#	Line 1472 | Line 1683 | int main(int argc, char **argv)
1683		omegat = atof(argv[++i]);
1684		task_color = 1;
1685		break;
1686	+	case 'l':
1687	+	zones = 1;
1688	+	x_zone = atoi(argv[++i]);
1689	+	y_zone = atoi(argv[++i]);
1690	+	angle_z1 = atof(argv[++i]);
1691	+	angle_z2 = -1;
1692	+	break;
1693	+	case 'L':
1694	+	zones = 2;
1695	+	x_zone = atoi(argv[++i]);
1696	+	y_zone = atoi(argv[++i]);
1697	+	angle_z1 = atof(argv[++i]);
1698	+	angle_z2 = atof(argv[++i]);
1699	+	break;
1700	+
1701	+
1702		case 'B':
1703		band_calc = 1;
1704		band_angle = atof(argv[++i]);
#	Line 1542 | Line 1769 | int main(int argc, char **argv)
1769		if (output == 1 && ext_vill == 1) {
1770		calcfast=1;
1771		}
1772	+	/*masking and zoning cannot be applied at the same time*/
1773
1774	+	if (masking ==1 && zones >0) {
1775	+	fprintf(stderr,  " masking and zoning cannot be activated at the same time!\n");
1776	+	exit(1);
1777	+	}
1778	+
1779		/* read picture file */
1780		if (i == argc) {
1781		SET_FILE_BINARY(stdin);
#	Line 1576 | Line 1809 | if (output == 1 && ext_vill == 1) {
1809		return EXIT_FAILURE;
1810		}
1811
1812	+
1813	+
1814		/*                fprintf(stderr,"Picture read!");*/
1815
1816		/* command line for output picture*/
1817
1818		pict_set_comment(p, cline);
1819
1820	+	/* several checks */
1821		if (p->view.type == VT_PAR) {
1822	<	fprintf(stderr, "wrong view type! must not be parallel ! \n");
1822	>	fprintf(stderr, "error: wrong view type! must not be parallel ! \n");
1823		exit(1);
1824		}
1825
1826	+	if (p->view.type == VT_PER) {
1827	+	fprintf(stderr, "warning: image has perspective view type specified in header ! \n");
1828	+	}
1829
1830	+	if (masking == 1) {
1831	+
1832	+	if (!pict_get_xsize(p)==pict_get_xsize(pm) || !pict_get_ysize(p)==pict_get_ysize(pm)) {
1833	+	fprintf(stderr, "error: masking image has other resolution than main image ! \n");
1834	+	fprintf(stderr, "size must be identical \n");
1835	+	printf("resolution main image : %dx%d\n",pict_get_xsize(p),pict_get_ysize(p));
1836	+	printf("resolution masking image : %dx%d\n",pict_get_xsize(pm),pict_get_ysize(pm));
1837	+	exit(1);
1838	+
1839	+	}
1840	+
1841	+	}
1842	+	/*      printf("resolution: %dx%d\n",pict_get_xsize(p),pict_get_ysize(p)); */
1843	+
1844		/* Check size of search radius */
1845		rmx = (pict_get_xsize(p) / 2);
1846		rmy = (pict_get_ysize(p) / 2);
#	Line 1632 | Line 1885 | if (output == 1 && ext_vill == 1) {
1885		avlum = 0.0;
1886		pict_new_gli(p);
1887		igs = 0;
1888	+	pict_get_z1_gsn(p,igs) = 0;
1889	+	pict_get_z2_gsn(p,igs) = 0;
1890
1891	+
1892		/* cut out GUTH field of view and exit without glare evaluation */
1893		if (cut_view==2) {
1894		if (cut_view_type==1) {
#	Line 1699 | Line 1955 | if (cut_view==2) {
1955		if (calcfast == 0) {
1956		for (x = 0; x < pict_get_xsize(p); x++)
1957		for (y = 0; y < pict_get_ysize(p); y++) {
1958	+	lum = luminance(pict_get_color(p, x, y));
1959	+	dist=sqrt((x-rmx)*(x-rmx)+(y-rmy)*(y-rmy));
1960	+	if (dist>((rmx+rmy)/2)) {
1961	+	n_corner_px=n_corner_px+1;
1962	+	if (lum<7.0) {
1963	+	zero_corner_px=zero_corner_px+1;
1964	+	}
1965	+	}
1966	+
1967	+
1968		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
1969		if (pict_is_validpixel(p, x, y)) {
1704	–	lum = luminance(pict_get_color(p, x, y));
1970		if (fill == 1 && y >= yfillmax) {
1971		y1 = y - 1;
1972		lum = luminance(pict_get_color(p, x, y1));
#	Line 1714 | Line 1979 | if (cut_view==2) {
1979		abs_max = lum;
1980		}
1981		/* set luminance restriction, if -m is set */
1982	<	if (set_lum_max == 1 && lum >= lum_max) {
1983	<	pict_get_color(p, x, y)[RED] = new_lum_max / 179.0;
1984	<	pict_get_color(p, x, y)[GRN] = new_lum_max / 179.0;
1985	<	pict_get_color(p, x, y)[BLU] = new_lum_max / 179.0;
1986	<	/*                                    printf("old lum, new lum %f %f \n",lum,luminance(pict_get_color(p,x,y))); */
1987	<	lum = luminance(pict_get_color(p, x, y));
1982	>	if (img_corr == 1 ) {
1983	>	if (set_lum_max == 1 && lum >= lum_max) {
1984	>	pict_get_color(p, x, y)[RED] = new_lum_max / 179.0;
1985	>	pict_get_color(p, x, y)[GRN] = new_lum_max / 179.0;
1986	>	pict_get_color(p, x, y)[BLU] = new_lum_max / 179.0;
1987	>	/*                                                      printf("old lum, new lum %f %f \n",lum,luminance(pict_get_color(p,x,y))); */
1988	>	lum = luminance(pict_get_color(p, x, y));
1989	>	}
1990	>	if (set_lum_max2 == 1 && lum >= lum_max) {
1991
1992	<	}
1993	<	if (set_lum_max2 == 1 && lum >= lum_max) {
1992	>	E_v_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* lum;
1993	>	omega_cos_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* 1;
1994	>	}
1995	>	if (set_lum_max2 == 2 ) {
1996	>	r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
1997	>	if (x_disk == x && y_disk==y ) r_actual=0.0;
1998
1999	<	E_v_contr +=
2000	<	DOT(p->view.vdir,
2001	<	pict_get_cached_dir(p, x,
2002	<	y)) * pict_get_omega(p,
2003	<	x,
2004	<	y)
2005	<	* lum;
2006	<	omega_cos_contr +=
2007	<	DOT(p->view.vdir,
2008	<	pict_get_cached_dir(p, x,
1737	<	y)) * pict_get_omega(p,
1738	<	x,
1739	<	y)
1740	<	* 1;
1999	>	act_lum = luminance(pict_get_color(p, x, y));
2000	>
2001	>	if (r_actual <= angle_disk) {
2002	>	E_v_contr +=DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* lum;
2003	>	omega_cos_contr += DOT(p->view.vdir,pict_get_cached_dir(p, x,y)) * pict_get_omega(p,x,y)* 1;
2004	>	}
2005	>
2006	>
2007	>
2008	>	}
2009		}
2010	+	om = pict_get_omega(p, x, y);
2011	+	sang += om;
2012	+	E_v += DOT(p->view.vdir, pict_get_cached_dir(p, x,y)) * om *lum;
2013	+	avlum += om * lum;
2014	+	pos=get_posindex(p, x, y,posindex_2);
2015
2016	+	lum_pos[0]=lum;
2017	+	muc_rvar_add_sample(s_noposweight,lum_pos);
2018	+	lum_pos[0]=lum/pos;
2019	+	lum_pos_mean+=lum_pos[0]*om;
2020	+	muc_rvar_add_sample(s_posweight, lum_pos);
2021	+	lum_pos[0]=lum_pos[0]/pos;
2022	+	lum_pos2_mean+=lum_pos[0]*om;
2023	+	muc_rvar_add_sample(s_posweight2,lum_pos);
2024
2025	<	sang += pict_get_omega(p, x, y);
2026	<	E_v +=
1746	<	DOT(p->view.vdir,
1747	<	pict_get_cached_dir(p, x,
1748	<	y)) * pict_get_omega(p, x,
1749	<	y) *
1750	<	lum;
1751	<	avlum +=
1752	<	pict_get_omega(p, x,
1753	<	y) * luminance(pict_get_color(p, x,
1754	<	y));
2025	>
2026	>
2027		} else {
2028		pict_get_color(p, x, y)[RED] = 0.0;
2029		pict_get_color(p, x, y)[GRN] = 0.0;
2030		pict_get_color(p, x, y)[BLU] = 0.0;
2031
2032		}
2033	<	}
2033	>	}else {
2034	>	pict_get_color(p, x, y)[RED] = 0.0;
2035	>	pict_get_color(p, x, y)[GRN] = 0.0;
2036	>	pict_get_color(p, x, y)[BLU] = 0.0;
2037	>
2038	>	}
2039		}
2040
2041	<	if (set_lum_max2 == 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) {
2041	>	/* check if image has black corners AND a perspective view */
2042
2043	+	if (zero_corner_px/n_corner_px > 0.70 && (p->view.type == VT_PER) ) {
2044	+	printf (" corner pixels are to  %f %% black! \n",zero_corner_px/n_corner_px*100);
2045	+	printf("error! The image has black corners AND header contains a perspective view type definition !!!\n") ;
2046	+
2047	+	if (force==0) {
2048	+	printf("stopping...!!!!\n") ;
2049	+
2050	+	exit(1);
2051	+	}
2052	+	}
2053	+
2054	+
2055	+
2056	+
2057	+	lum_pos_mean= lum_pos_mean/sang;
2058	+	lum_pos2_mean= lum_pos2_mean/sang;
2059	+
2060	+	if (set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) {
2061	+
2062		lum_ideal = (E_vl_ext - E_v + E_v_contr) / omega_cos_contr;
2063	+	if (set_lum_max2 == 2 && lum_ideal >= 2e9) {
2064	+	printf("warning! luminance of replacement pixels would be larger than 2e9 cd/m2. Value set to 2e9cd/m2!\n") ;
2065	+	}
2066	+
2067		if (lum_ideal > 0 && lum_ideal < setvalue) {
2068		setvalue = lum_ideal;
2069		}
2070	<	printf
1771	<	("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2070	>	printf("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2071		lum_ideal, setvalue, E_vl_ext, E_v, E_v_contr);
2072
2073	<
2073	>
2074		for (x = 0; x < pict_get_xsize(p); x++)
2075		for (y = 0; y < pict_get_ysize(p); y++) {
2076		if (pict_get_hangle
2077		(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2078		if (pict_is_validpixel(p, x, y)) {
2079		lum = luminance(pict_get_color(p, x, y));
2080	+
2081	+
2082		if (set_lum_max2 == 1 && lum >= lum_max) {
2083
2084		pict_get_color(p, x, y)[RED] =
#	Line 1787 | Line 2088 | if (cut_view==2) {
2088		pict_get_color(p, x, y)[BLU] =
2089		setvalue / 179.0;
2090
2091	+	}else{ if(set_lum_max2 ==2 ) {
2092	+	r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2093	+	if (x_disk == x && y_disk==y ) r_actual=0.0;
2094	+
2095	+	if (r_actual <= angle_disk) {
2096	+
2097	+	pict_get_color(p, x, y)[RED] =
2098	+	setvalue / 179.0;
2099	+	pict_get_color(p, x, y)[GRN] =
2100	+	setvalue / 179.0;
2101	+	pict_get_color(p, x, y)[BLU] =
2102	+	setvalue / 179.0;
2103	+
2104	+	}
2105	+
2106	+
2107		}
2108	+	}
2109		}
2110		}
2111		}
2112	+
2113
2114		pict_write(p, file_out2);
2115	<
2115	>	exit(1);
2116		}
2117		if (set_lum_max == 1) {
2118		pict_write(p, file_out2);
#	Line 1853 | Line 2172 | if (cut_view==1) {
2172		lum_source = lum_thres;
2173		}
2174
2175	<	/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2175	>	/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2176
2177		/* first glare source scan: find primary glare sources */
2178	<	for (x = 0; x < pict_get_xsize(p); x++)
2178	>	for (x = 0; x < pict_get_xsize(p); x++) {
2179	>	/*                lastpixelwas_gs=0; */
2180		for (y = 0; y < pict_get_ysize(p); y++) {
2181		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2182		if (pict_is_validpixel(p, x, y)) {
#	Line 1865 | Line 2185 | if (cut_view==1) {
2185		if (act_lum >lum_total_max) {
2186		lum_total_max=act_lum;
2187		}
2188	<
2189	<	actual_igs =
2190	<	find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2188	>	/* speed improvement first scan: when last pixel was glare source, then use this glare source number instead of searching.
2189	>	has been deactivated with v1.25
2190	>
2191	>	if (lastpixelwas_gs==0 || search_pix <= 1.0 ) { */
2192	>	actual_igs = find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2193	>	/*  }*/
2194		if (actual_igs == 0) {
2195		igs = igs + 1;
2196		pict_new_gli(p);
2197		pict_get_lum_min(p, igs) = HUGE_VAL;
2198		pict_get_Eglare(p,igs) = 0.0;
2199		pict_get_Dglare(p,igs) = 0.0;
2200	+	pict_get_z1_gsn(p,igs) = 0;
2201	+	pict_get_z2_gsn(p,igs) = 0;
2202		actual_igs = igs;
2203	+
2204		}
2205	<	icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2205	>	/* no coloring any more here            icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2206		pict_get_gsn(p, x, y) = actual_igs;
2207		pict_get_pgs(p, x, y) = 1;
2208		add_pixel_to_gs(p, x, y, actual_igs);
2209	+	/*                                                lastpixelwas_gs=actual_igs; */
2210
2211		} else {
2212		pict_get_pgs(p, x, y) = 0;
2213	+	/*                                               lastpixelwas_gs=0;*/
2214		}
2215		}
2216		}
2217	<	}
2217	>	}
2218	>	}
2219		/*      pict_write(p,"firstscan.pic");   */
2220
2221	<	if (calcfast == 1 ) {
2221	>
2222	>	if (calcfast == 1 || search_pix <= 1.0) {
2223		skip_second_scan=1;
2224		}
2225
2226		/* second glare source scan: combine glare sources facing each other */
2227		change = 1;
2228	+	i = 0;
2229		while (change == 1 && skip_second_scan==0) {
2230		change = 0;
2231	<	for (x = 0; x < pict_get_xsize(p); x++)
2231	>	i = i+1;
2232	>	for (x = 0; x < pict_get_xsize(p); x++) {
2233		for (y = 0; y < pict_get_ysize(p); y++) {
1902	–	before_igs = pict_get_gsn(p, x, y);
2234		if (pict_get_hangle
2235		(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2236	<	if (pict_is_validpixel(p, x, y) && before_igs > 0) {
2236	>	checkpixels=1;
2237	>	before_igs = pict_get_gsn(p, x, y);
2238	>
2239	>	/* speed improvement: search for other nearby glare sources only, when at least one adjacend pixel has another glare source number  */
2240	>	if (x >1 && x<pict_get_xsize(p)-2 && y >1 && y<pict_get_ysize(p)-2 )   {
2241	>	x1=x-1;
2242	>	x2=x+1;
2243	>	y1=y-1;
2244	>	y2=y+1;
2245	>	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) ) {
2246	>	checkpixels = 0;
2247	>	actual_igs = before_igs;
2248	>	}  }
2249	>
2250	>
2251	>	if (pict_is_validpixel(p, x, y) && before_igs > 0 && checkpixels==1) {
2252		actual_igs =
2253		find_near_pgs(p, x, y, max_angle, before_igs,
2254		igs, 1);
#	Line 1911 | Line 2257 | if (calcfast == 1 ) {
2257		}
2258		if (before_igs > 0) {
2259		actual_igs = pict_get_gsn(p, x, y);
2260	<	icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2260	>	/*      icol = setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2261		}
2262
2263		}
2264		}
2265		}
2266		/*      pict_write(p,"secondscan.pic");*/
2267	+	}}
2268
1922	–	}
1923	–
2269		/*smoothing: add secondary glare sources */
2270		i_max = igs;
2271		if (sgs == 1) {
#	Line 1977 | Line 2322 | if (calcfast == 1 ) {
2322		if (i_splitstart == (igs + 1)) {
2323		igs = igs + 1;
2324		pict_new_gli(p);
2325	+	pict_get_z1_gsn(p,igs) = 0;
2326	+	pict_get_z2_gsn(p,igs) = 0;
2327	+
2328		pict_get_Eglare(p,igs) = 0.0;
2329		pict_get_Dglare(p,igs) = 0.0;
2330		pict_get_lum_min(p, igs) =
#	Line 1990 | Line 2338 | if (calcfast == 1 ) {
2338		if (i_split == 0) {
2339		igs = igs + 1;
2340		pict_new_gli(p);
2341	+	pict_get_z1_gsn(p,igs) = 0;
2342	+	pict_get_z2_gsn(p,igs) = 0;
2343	+
2344		pict_get_Eglare(p,igs) = 0.0;
2345		pict_get_Dglare(p,igs) = 0.0;
2346		pict_get_lum_min(p, igs) =
#	Line 2026 | Line 2377 | if (calcfast == 1 ) {
2377		if (before_igs > 0) {
2378		actual_igs =
2379		pict_get_gsn(p, x, y);
2380	<	icol =
2380	>	/*                                                                                     icol =
2381		setglcolor(p, x, y,
2382	<	actual_igs, uniform_gs, u_r, u_g , u_b);
2382	>	actual_igs, uniform_gs, u_r, u_g , u_b);*/
2383		}
2384
2385		}
#	Line 2043 | Line 2394 | if (calcfast == 1 ) {
2394		}
2395		}
2396
2397	<	/* calculation of direct vertical illuminance for CGI and for disability glare*/
2397	>	/* calculation of direct vertical illuminance for CGI and for disability glare, coloring glare sources*/
2398
2048	–
2399		if (calcfast == 0) {
2400		for (x = 0; x < pict_get_xsize(p); x++)
2401		for (y = 0; y < pict_get_ysize(p); y++) {
2402		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2403		if (pict_is_validpixel(p, x, y)) {
2404		if (pict_get_gsn(p, x, y) > 0) {
2405	<	pict_get_Eglare(p,pict_get_gsn(p, x, y)) +=
2406	<	DOT(p->view.vdir, pict_get_cached_dir(p, x, y))
2407	<	* pict_get_omega(p, x, y)
2408	<	* luminance(pict_get_color(p, x, y));
2409	<	E_v_dir +=
2060	<	DOT(p->view.vdir, pict_get_cached_dir(p, x, y))
2061	<	* pict_get_omega(p, x, y)
2062	<	* luminance(pict_get_color(p, x, y));
2405	>	actual_igs = pict_get_gsn(p, x, y);
2406	>	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));
2407	>	pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
2408	>	E_v_dir = E_v_dir + delta_E;
2409	>	setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b);
2410		}
2411		}
2412		}
2413		}
2414		lum_backg_cos = (E_v - E_v_dir) / 3.1415927;
2415	<	lum_backg = lum_backg_cos;
2415	>
2416		}
2417	<	/* calc of band luminance if applied */
2417	>	/* calc of band luminance distribution if applied */
2418		if (band_calc == 1) {
2419	<	band_avlum=get_band_lum( p, band_angle, band_color);
2420	<	}
2419	>	x_max = pict_get_xsize(p) - 1;
2420	>	y_max = pict_get_ysize(p) - 1;
2421	>	y_mid = (int)(y_max/2);
2422	>	for (x = 0; x <= x_max; x++)
2423	>	for (y = 0; y <= y_max; y++) {
2424	>	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2425	>	if (pict_is_validpixel(p, x, y)) {
2426
2427	+	r_actual = acos(DOT(pict_get_cached_dir(p, x, y_mid), pict_get_cached_dir(p, x, y))) ;
2428	+	act_lum = luminance(pict_get_color(p, x, y));
2429	+
2430	+	if ((r_actual <= band_angle) || (y == y_mid) ) {
2431	+	lum_band[0]=luminance(pict_get_color(p, x, y));
2432	+	muc_rvar_add_sample(s_band, lum_band);
2433	+	act_lum = luminance(pict_get_color(p, x, y));
2434	+	lum_band_av += pict_get_omega(p, x, y) * act_lum;
2435	+	omega_band += pict_get_omega(p, x, y);
2436	+	if (band_color == 1) {
2437	+	pict_get_color(p, x, y)[RED] = 0.0;
2438	+	pict_get_color(p, x, y)[GRN] = act_lum / WHTEFFICACY / CIE_gf;
2439	+	pict_get_color(p, x, y)[BLU] = 0.0;
2440	+	}
2441	+	}
2442	+	}}}
2443	+	lum_band_av=lum_band_av/omega_band;
2444	+	muc_rvar_get_vx(s_band,lum_band_std);
2445	+	muc_rvar_get_percentile(s_band,lum_band_median,0.75);
2446	+	per_75_band=lum_band_median[0];
2447	+	muc_rvar_get_percentile(s_band,lum_band_median,0.95);
2448	+	per_95_band=lum_band_median[0];
2449	+	muc_rvar_get_median(s_band,lum_band_median);
2450	+	muc_rvar_get_bounding_box(s_band,bbox_band);
2451	+
2452	+	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] );
2453	+	/*      av_lum = av_lum / omega_sum; */
2454	+	/*    printf("average luminance of band %f \n",av_lum);*/
2455	+	/*      printf("solid angle of band %f \n",omega_sum);*/
2456	+	}
2457	+
2458		/*printf("total number of glare sources: %i\n",igs); */
2459		lum_sources = 0;
2460		omega_sources = 0;
2461	+	i=0;
2462		for (x = 0; x <= igs; x++) {
2463	+	if (pict_get_npix(p, x) > 0) {
2464		lum_sources += pict_get_av_lum(p, x) * pict_get_av_omega(p, x);
2465		omega_sources += pict_get_av_omega(p, x);
2466	+	i=i+1;
2467	+	}}
2468	+
2469	+	if (sang == omega_sources) {
2470	+	lum_backg =avlum;
2471	+	} else {
2472	+	lum_backg =(sang * avlum - lum_sources) / (sang - omega_sources);
2473		}
2474	<	if (non_cos_lb == 1) {
2475	<	lum_backg =
2476	<	(sang * avlum - lum_sources) / (sang - omega_sources);
2474	>
2475	>
2476	>	if (i == 0) {
2477	>	lum_sources =0.0;
2478	>	} else { lum_sources=lum_sources/omega_sources;
2479		}
2480	+
2481	+
2482	+
2483	+	if (non_cos_lb == 0) {
2484	+	lum_backg = lum_backg_cos;
2485	+	}
2486	+
2487	+	/* file writing NOT here
2488	+	if (checkfile == 1) {
2489	+	pict_write(p, file_out);
2490	+	}
2491	+	*/
2492	+
2493		/* print detailed output */
2494	+
2495	+
2496		if (detail_out == 1) {
2497	+
2498	+	/* masking */
2499	+
2500	+	if ( masking == 1 ) {
2501	+
2502	+
2503	+	for (x = 0; x < pict_get_xsize(p); x++)
2504	+	for (y = 0; y < pict_get_ysize(p); y++) {
2505	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2506	+	if (pict_is_validpixel(p, x, y)) {
2507	+	if (luminance(pict_get_color(pm, x, y))>0.1) {
2508	+	/*                                         printf ("hallo %i %i %f \n",x,y,luminance(pict_get_color(pm, x, y)));*/
2509	+	i_mask=i_mask+1;
2510	+	lum_mask[0]=luminance(pict_get_color(p, x, y));
2511	+	/* printf ("%f \n",lum_mask[0]);*/
2512	+	muc_rvar_add_sample(s_mask, lum_mask);
2513	+	omega_mask += pict_get_omega(p, x, y);
2514	+	lum_mask_av += pict_get_omega(p, x, y)* luminance(pict_get_color(p, x, y));
2515	+	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));
2516	+
2517	+	pict_get_color(pm, x, y)[RED] = luminance(pict_get_color(p, x, y))/179.0;
2518	+	pict_get_color(pm, x, y)[GRN] = luminance(pict_get_color(p, x, y))/179.0;
2519	+	pict_get_color(pm, x, y)[BLU] = luminance(pict_get_color(p, x, y))/179.0;
2520	+
2521	+	} else {
2522	+	pict_get_color(p, x, y)[RED] = 0.0 ;
2523	+	pict_get_color(p, x, y)[GRN] = 0.0 ;
2524	+	pict_get_color(p, x, y)[BLU] = 0.0 ;
2525	+	}
2526	+	}
2527	+	}
2528	+	}
2529	+	/* Average luminance in masking area (weighted by solid angle) */
2530	+	lum_mask_av=lum_mask_av/omega_mask;
2531	+	muc_rvar_get_vx(s_mask,lum_mask_std);
2532	+	muc_rvar_get_percentile(s_mask,lum_mask_median,0.75);
2533	+	per_75_mask=lum_mask_median[0];
2534	+	muc_rvar_get_percentile(s_mask,lum_mask_median,0.95);
2535	+	per_95_mask=lum_mask_median[0];
2536	+	muc_rvar_get_median(s_mask,lum_mask_median);
2537	+	muc_rvar_get_bounding_box(s_mask,bbox);
2538	+	/* PSGV only why masking of window is applied! */
2539	+	pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av);
2540	+	pgsv_sat =get_pgsv_sat(E_v);
2541	+	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 );
2542	+
2543	+
2544	+
2545	+	}
2546	+
2547	+	/* zones */
2548	+
2549	+	if ( zones > 0 ) {
2550	+
2551	+	for (x = 0; x < pict_get_xsize(p); x++)
2552	+	for (y = 0; y < pict_get_ysize(p); y++) {
2553	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2554	+	if (pict_is_validpixel(p, x, y)) {
2555	+
2556	+
2557	+	r_actual =acos(DOT(pict_get_cached_dir(p, x, y), pict_get_cached_dir(p, x_zone, y_zone))) * 2;
2558	+	lum_actual = luminance(pict_get_color(p, x, y));
2559	+	act_gsn=pict_get_gsn(p, x, y);
2560	+	/*     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));*/
2561	+
2562	+	/*zone1 */
2563	+	if (r_actual <= angle_z1) {
2564	+	i_z1=i_z1+1;
2565	+	lum_z1[0]=lum_actual;
2566	+	muc_rvar_add_sample(s_z1, lum_z1);
2567	+	omega_z1 += pict_get_omega(p, x, y);
2568	+	lum_z1_av += pict_get_omega(p, x, y)* lum_actual;
2569	+	setglcolor(p,x,y,1,1 , 0.66, 0.01 ,0.33);
2570	+	/*check if separation gsn already exist */
2571	+
2572	+	if (act_gsn > 0){
2573	+	if (pict_get_z1_gsn(p,act_gsn) == 0) {
2574	+	pict_new_gli(p);
2575	+	igs = igs + 1;
2576	+	pict_get_z1_gsn(p,act_gsn) = igs*1.000;
2577	+	pict_get_z1_gsn(p,igs) = -1.0;
2578	+	pict_get_z2_gsn(p,igs) = -1.0;
2579	+	splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2580	+	/*                                                                                        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)); */
2581	+	}
2582	+	splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2583	+	/*          printf("splitgs%i \n",splitgs);       */
2584	+	split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2585	+	}
2586	+	}
2587	+	/*zone2 */
2588	+
2589	+	if (r_actual > angle_z1 && r_actual<= angle_z2 ) {
2590	+
2591	+	i_z2=i_z2+1;
2592	+	lum_z2[0]=lum_actual;
2593	+	muc_rvar_add_sample(s_z2, lum_z2);
2594	+	omega_z2 +=   pict_get_omega(p, x, y);
2595	+	lum_z2_av += pict_get_omega(p, x, y)* lum_actual;
2596	+	setglcolor(p,x,y,1,1 , 0.65, 0.33 ,0.02);
2597	+	/*                                                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));
2598	+	*/                                                if (act_gsn > 0){
2599	+	if (pict_get_z2_gsn(p,act_gsn) == 0) {
2600	+	pict_new_gli(p);
2601	+	igs = igs + 1;
2602	+	pict_get_z2_gsn(p,act_gsn) = igs*1.000;
2603	+	pict_get_z1_gsn(p,igs) = -2.0;
2604	+	pict_get_z2_gsn(p,igs) = -2.0;
2605	+	/*                                                                                         printf ("Glare source %i gets glare source %i in zone 2 \n",act_gsn,igs ); */
2606	+	}
2607	+	splitgs=(int)(pict_get_z2_gsn(p,act_gsn));
2608	+	/*                                              printf("splitgs %i \n",splitgs);*/
2609	+	split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2610	+	}
2611	+	}
2612	+
2613	+	}
2614	+	} }
2615	+	/* Average luminance in zones (weighted by solid angle), calculate percentiles, median min and max in zones  */
2616	+	if (zones == 2 ) {
2617	+	lum_z2_av=lum_z2_av/omega_z2;
2618	+	muc_rvar_get_vx(s_z2,lum_z2_std);
2619	+	muc_rvar_get_percentile(s_z2,lum_z2_median,0.75);
2620	+	per_75_z2=lum_z2_median[0];
2621	+	muc_rvar_get_percentile(s_z2,lum_z2_median,0.95);
2622	+	per_95_z2=lum_z2_median[0];
2623	+	muc_rvar_get_median(s_z2,lum_z2_median);
2624	+	muc_rvar_get_bounding_box(s_z2,bbox_z2);
2625	+	}
2626	+	lum_z1_av=lum_z1_av/omega_z1;
2627	+	muc_rvar_get_vx(s_z1,lum_z1_std);
2628	+	muc_rvar_get_percentile(s_z1,lum_z1_median,0.75);
2629	+	per_75_z1=lum_z1_median[0];
2630	+	muc_rvar_get_percentile(s_z1,lum_z1_median,0.95);
2631	+	per_95_z1=lum_z1_median[0];
2632	+	muc_rvar_get_median(s_z1,lum_z1_median);
2633	+	muc_rvar_get_bounding_box(s_z1,bbox_z1);
2634	+
2635	+	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] );
2636	+
2637	+
2638	+	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] );
2639	+
2640	+
2641	+	}
2642	+
2643		i = 0;
2644		for (x = 0; x <= igs; x++) {
2645		/* resorting glare source numbers */
#	Line 2092 | Line 2647 | if (calcfast == 1 ) {
2647		i = i + 1;
2648		}
2649		}
2650	+	no_glaresources=i;
2651
2652	<
2097	<
2652	>	/* glare sources */
2653		printf
2654	<	("%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",
2654	>	("%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",
2655		i);
2656		if (i == 0) {
2657	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f\n", i, 0.0, 0.0,
2658	<	0.0, 0.0, 0.0, 0.0, lum_backg, lum_task, E_v, E_v_dir,
2104	<	abs_max);
2657	>	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,
2658	>	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);
2659
2660		} else {
2661		i = 0;
#	Line 2121 | Line 2675 | if (calcfast == 1 ) {
2675		Lveil_cie =0 ;
2676		}
2677		Lveil_cie_sum =  Lveil_cie_sum + Lveil_cie;
2678	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
2678	>	if (pict_get_z1_gsn(p,x)<0) {
2679	>	act_gsn=(int)(-pict_get_z1_gsn(p,x));
2680	>	}else{
2681	>	act_gsn=0;
2682	>	}
2683	>	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %i \n",
2684		i, pict_get_npix(p, x), pict_get_av_posx(p, x),
2685		pict_get_ysize(p) - pict_get_av_posy(p, x),
2686		pict_get_av_lum(p, x), pict_get_av_omega(p, x),
#	Line 2129 | Line 2688 | if (calcfast == 1 ) {
2688		pict_get_av_posy(p, x),
2689		posindex_2), lum_backg, lum_task,
2690		E_v, E_v_dir, abs_max, sigma * 180 / 3.1415927
2691	<	,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
2133	<
2134	<	);
2691	>	,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 );
2692		}
2693		}
2694		}
#	Line 2171 | Line 2728 | if (calcfast == 1 ) {
2728		}
2729
2730		if (calcfast == 0) {
2731	+	lum_a= E_v2/3.1415927;
2732		dgi = get_dgi(p, lum_backg, igs, posindex_2);
2733		ugr = get_ugr(p, lum_backg, igs, posindex_2);
2734	+	ugp = get_ugp (p,lum_backg, igs, posindex_2);
2735	+	ugr_exp = get_ugr_exp (p,lum_backg_cos,lum_a, igs, posindex_2);
2736	+	dgi_mod = get_dgi_mod(p, lum_a, igs, posindex_2);
2737		cgi = get_cgi(p, E_v, E_v_dir, igs, posindex_2);
2738	<	vcp = get_vcp(p, avlum, igs, posindex_2);
2738	>	dgr = get_dgr(p, avlum, igs, posindex_2);
2739	>	vcp = get_vcp(dgr);
2740		Lveil = get_disability(p, avlum, igs);
2741	+	if (no_glaresources == 0) {
2742	+	dgi = 0.0;
2743	+	ugr = 0.0;
2744	+	ugp = 0.0;
2745	+	ugr_exp = 0.0;
2746	+	dgi_mod = 0.0;
2747	+	cgi = 0.0;
2748	+	dgr = 0.0;
2749	+	vcp = 100.0;
2750	+	}
2751		}
2752		/* check dgp range */
2753		if (dgp <= 0.2) {
#	Line 2201 | Line 2773 | if (calcfast == 0) {
2773		dgp =low_light_corr*dgp;
2774		dgp =age_corr_factor*dgp;
2775		}
2776	+	muc_rvar_get_median(s_noposweight,lum_nopos_median);
2777	+	muc_rvar_get_median(s_posweight,lum_pos_median);
2778	+	muc_rvar_get_median(s_posweight2,lum_pos2_median);
2779	+
2780
2781	+
2782	+
2783		printf
2784	<	("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",
2784	>	("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",
2785		dgp, avlum, E_v, lum_backg, E_v_dir, dgi, ugr, vcp, cgi,
2786	<	lum_sources / omega_sources, omega_sources, Lveil,Lveil_cie_sum,band_avlum);
2786	>	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]);
2787		} else {
2788		if (detail_out2 == 1) {
2789
#	Line 2268 | Line 2846 | has to be re-written from scratch....
2846
2847		/*output  */
2848		if (checkfile == 1) {
2849	+
2850	+
2851		pict_write(p, file_out);
2852		}
2853

Diff Legend

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