ViewVC Help

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

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

Comparing ray/src/util/evalglare.c (file contents):
Revision 2.4 by greg, Thu Jul 28 16:46:10 2016 UTC vs.
Revision 3.07 by greg, Tue Sep 16 15:43:14 2025 UTC

#	Line 1 | Line 1
1		#ifndef lint
2	<	static const char RCSid[] = "$Id$";
2	>	static const char RCSid[] = "$Id$";
3		#endif
4	<	/* EVALGLARE V1.29
5	<	* Evalglare Software License, Version 2.0
4	>	/* EVALGLARE V3.05
5	>	* Evalglare Software License, Version 3.0x
6		*
7	<	* Copyright (c) 1995 - 2016 Fraunhofer ISE, EPFL.
7	>	* Copyright (c) 1995 - 2022 Fraunhofer ISE, EPFL.
8		* All rights reserved.
9		*
10		*
#	Line 310 | Line 310 | changed masking threshold to 0.05 cd/m2
310		*/
311		/* evalglare.c, v1.30 2016/07/28 change zonal output: If just one zone is specified, only one zone shows up in the output (bug removal).
312		*/
313	+	/* evalglare.c, v1.31 2016/08/02  bug removal: default output did not calculate the amout of glare sources before and therefore no_glaresources was set to zero causing dgi,ugr being set to zero as well. Now renumbering of the glare sources and calculation of the amount of glare sources is done for all output versions.
314	+	*/
315	+	/* evalglare.c, v2.00 2016/11/15  add of a second fast calculation mode for annual calculations, activted by -2. Output: dgp,ugr
316	+	*/
317	+	/* evalglare.c, v2.01 2016/11/16  change of -2 option (now -2 dir_illum). External provision of the direct illuminance necessary, since the sun interpolation of daysim is causing problems in calculation of the background luminance.
318	+	*/
319	+	/* evalglare.c, v2.02 2017/02/28  change of warning message, when invalid exposure setting is found. Reason: tab removal is not in all cases the right measure - it depends which tool caused the invalid exposure entry   */
320	+
321	+	/* evalglare.c, v2.03 2017/08/04  ad of -O option - disk replacement by providing luminance, not documented
322	+	*/
323	+
324	+	/* evalglare.c, v2.04 2017/08/04  adding -q option: use of Ev/pi as background luminance. not documented. no combination with -n option!!!
325	+	*/
326	+
327	+	/* evalglare.c, v2.05 2018/08/28  change of the -q option for the choice of the background luminance calculation mode: 0: CIE method (Ev-Edir)/pi, 1: mathematical correct average background luminance, 2: Ev/pi.
328	+	change of default options:
329	+	- cosinus weighted calculation of the background luminance (according to CIE) is now default.
330	+	- absolute threshold for the glare source detection is now default (2000cd/m2), based on study of C. Pierson
331	+	*/
332	+
333	+	/* evalglare.c, v2.06 2018/08/29
334	+	change of default value of multiplier b to 5.0, if task options (-t or -T ) are activated AND -b NOT used. To be downward compatible when using the task method.
335	+	*/
336	+
337	+	/* evalglare.c, v2.07 2018/11/17
338	+	bugfix: correction of error in the equations of PGSV_con and PGSV_sat
339	+	all three PGSV equations are calculated now
340	+	illuminance from the masking area (E_v_mask) is also printed
341	+	bugfix: in VCPs error fuction equation, value of 6.347 replaced by 6.374
342	+	*/
343	+
344	+	/* evalglare.c, v2.08 2018/11/27
345	+	bugfix: checkroutine for same image size for the masking corrected
346	+	*/
347	+
348	+	/* evalglare.c, v2.09 2019/01/18
349	+	calculate "illuminance-contribution of zones"
350	+	-switch to turn off low-light correction: 4
351	+	*/
352	+
353	+	/* evalglare.c, v2.10 2019/07/30, 2020/06/25
354	+	-add multiimage-mode for annual glare evaluation -Q
355	+	-extra output for multiimage mode
356	+	2020/06/22 - added Ev contribution from each glare source as output to the multiimage mode
357	+	-switch for correction modes (-C), value of 0 switches off all corrections
358	+	*/
359	+
360	+
361	+	/* evalglare.c, v2.11  2020/07/06
362	+	-add extra output for DGP-contribution in -d mode
363	+	-fix (remove) 1 pixel offset of the mulltiimage-mode
364	+	*/
365	+
366	+	/* evalglare.c, v2.12  2021/07/19
367	+	-bugfix: center of glare source calculation now based on l*omega weighting, before it was just on omega.
368	+	*/
369	+
370	+	/* evalglare.c, v2.13  2021/07/21
371	+	- center of glare source calculation now based on l*l*omega weighting.
372	+	- bugfix: Position-index below line of sight is now corrected and based on the modified equation from Iwata and Osterhaus 2010
373	+	*/
374	+
375	+	/* evalglare.c, v2.14  2021/10/20
376	+	- center of glare source calculation now based on l*omega weighting.
377	+	- adding UGP2 equation to the output
378	+	- new default setting: low-light correction off !
379	+	*/
380	+
381	+	/* evalglare.c, v3.0  2021/12/24
382	+	- adding patch-mode (-z patchangle combineflag ) as glare source grouping method
383	+	*/
384	+
385	+	/* evalglare.c, v3.01  2022/01/05
386	+	- change of multi-image-mode. Adding extra scans with scaled image
387	+	syntax now: -Q n_images n_extrascans_per_image n_images*( imagename x y  n_extrascans*(scale) )
388	+	*/
389	+	/* evalglare.c, v3.02  2022/02/11
390	+	- correction of position index below line of sight after Takuro Kikuchi's comments in radiance-discourse from Dec 2021.
391	+	*/
392	+
393	+	/* evalglare.c, v3.03  2022/03/18, 2024/06/25
394	+	- add no pixels output for zonal analysis.
395	+
396	+	/* evalglare.c, v3.04  2023/09/01
397	+	- test version to include peripherical dependency, changes not (yet) used for following versions
398	+
399	+	/* evalglare.c, v3.05  2024/06/25
400	+	- fix bug of still having lowlight correction even if turned off
401	+	- changing abs_max,Lveil from float to double
402	+	*/
403	+
404	+
405		#define EVALGLARE
406		#define PROGNAME "evalglare"
407	<	#define VERSION "1.30 release 29.07.2016 by EPFL, J.Wienold"
407	>	#define VERSION "3.05 release 25.06.2024 by J.Wienold, EPFL"
408		#define RELEASENAME PROGNAME " " VERSION
409
410
#	Line 323 | Line 415 | changed masking threshold to 0.05 cd/m2
415		#include "platform.h"
416		#include "muc_randvar.h"
417
326	–	char *progname;
327	–
418		/* subroutine to add a pixel to a glare source */
419		void add_pixel_to_gs(pict * p, int x, int y, int gsn)
420		{
421		double old_av_posx, old_av_posy, old_av_lum, old_omega, act_omega,
422	<	new_omega, act_lum;
422	>	new_omega, act_lum,temp_av_posx,temp_av_posy,av_lum;
423
424
425		pict_get_npix(p, gsn) = pict_get_npix(p, gsn) + 1;
#	Line 341 | Line 431 | void add_pixel_to_gs(pict * p, int x, int y, int gsn)
431		act_omega = pict_get_omega(p, x, y);
432		act_lum = luminance(pict_get_color(p, x, y));
433		new_omega = old_omega + act_omega;
434	<	pict_get_av_posx(p, gsn) =
435	<	(old_av_posx * old_omega + x * act_omega) / new_omega;
436	<	pict_get_av_posy(p, gsn) =
437	<	(old_av_posy * old_omega + y * act_omega) / new_omega;
434	>	pict_get_av_lum(p, gsn) =
435	>	(old_av_lum * old_omega + act_lum * act_omega) / new_omega;
436	>
437	>	av_lum=pict_get_av_lum(p, gsn);
438	>	temp_av_posx =
439	>	(old_av_posx *  old_omega* old_av_lum + x * act_omega*act_lum) / (old_av_lum*old_omega + act_lum* act_omega );
440	>	pict_get_av_posx(p, gsn) = temp_av_posx;
441	>	temp_av_posy =
442	>	(old_av_posy *  old_omega* old_av_lum + y * act_omega*act_lum) / (old_av_lum*old_omega + act_lum* act_omega );
443	>
444	>	pict_get_av_posy(p, gsn) = temp_av_posy;
445		if (isnan((pict_get_av_posx(p, gsn))))
446		fprintf(stderr,"error in add_pixel_to_gs %d %d %f %f %f %f\n", x, y, old_av_posy, old_omega, act_omega, new_omega);
447
351	–	pict_get_av_lum(p, gsn) =
352	–	(old_av_lum * old_omega + act_lum * act_omega) / new_omega;
448		pict_get_av_omega(p, gsn) = new_omega;
449		pict_get_gsn(p, x, y) = gsn;
450		if (act_lum < pict_get_lum_min(p, gsn)) {
#	Line 723 | Line 818 | void add_secondary_gs(pict * p, int x, int y, float r,
818		void split_pixel_from_gs(pict * p, int x, int y, int new_gsn, int uniform_gs, double u_r, double u_g , double u_b)
819		{
820		int old_gsn, icol;
821	<	double old_av_posx, old_av_posy, old_av_lum, old_omega, act_omega,
822	<	new_omega, act_lum;
821	>	double old_av_posx, old_av_posy, old_av_lum, old_omega, act_omega, delta_E,
822	>	new_omega, act_lum,temp_av_posx,temp_av_posy,av_lum;
823
824
825		/* change existing gs */
#	Line 735 | Line 830 | void split_pixel_from_gs(pict * p, int x, int y, int n
830		old_av_posx = pict_get_av_posx(p, old_gsn);
831		old_av_posy = pict_get_av_posy(p, old_gsn);
832		old_omega = pict_get_av_omega(p, old_gsn);
833	+
834	+
835	+
836
837		new_omega = old_omega - act_omega;
838		pict_get_av_omega(p, old_gsn) = new_omega;
741	–	pict_get_av_posx(p, old_gsn) =
742	–	(old_av_posx * old_omega - x * act_omega) / new_omega;
743	–	pict_get_av_posy(p, old_gsn) =
744	–	(old_av_posy * old_omega - y * act_omega) / new_omega;
839
746	–
840		act_lum = luminance(pict_get_color(p, x, y));
841		old_av_lum = pict_get_av_lum(p, old_gsn);
842		pict_get_av_lum(p, old_gsn) =
843		(old_av_lum * old_omega - act_lum * act_omega) / new_omega;
844	+
845	+	av_lum = pict_get_av_lum(p, old_gsn);
846	+	temp_av_posx =
847	+	(old_av_posx *old_av_lum* old_omega  - x *act_lum* act_omega ) / (old_av_lum*old_omega  - act_lum* act_omega);
848	+
849	+	pict_get_av_posx(p, old_gsn) = temp_av_posx;
850	+	temp_av_posy =
851	+	(old_av_posy *old_av_lum* old_omega - y *act_lum* act_omega ) / (old_av_lum*old_omega  - act_lum* act_omega);
852	+	pict_get_av_posy(p, old_gsn) = temp_av_posy;
853	+
854		/* add pixel to new  gs */
855
856		add_pixel_to_gs(p, x, y, new_gsn);
857
858	+
859	+
860	+
861		/* color pixel of new gs */
862
863		/*      icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b); */
#	Line 763 | Line 869 | void split_pixel_from_gs(pict * p, int x, int y, int n
869		float get_posindex(pict * p, float x, float y, int postype)
870		{
871		float posindex;
872	<	double teta, phi, sigma, tau, deg, d, s, r, fact;
872	>	double teta, beta, phi, sigma, tau, deg, d, s, r, fact;
873
874
875		pict_get_vangle(p, x, y, p->view.vdir, p->view.vup, &phi);
#	Line 791 | Line 897 | float get_posindex(pict * p, float x, float y, int pos
897		/* KIM  model */
898		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));
899		}else{
900	+
901		/* Guth model, equation from IES lighting handbook */
902		posindex =
903		exp((35.2 - 0.31889 * tau -
#	Line 799 | Line 906 | float get_posindex(pict * p, float x, float y, int pos
906		0.002963 * tau *
907		tau) / 100000 *
908		sigma * sigma);
802	–	/* below line of sight, using Iwata model */
803	–	if (phi < 0) {
804	–	d = 1 / tan(phi);
805	–	s = tan(teta) / tan(phi);
806	–	r = sqrt(1 / d * 1 / d + s * s / d / d);
807	–	if (r > 0.6)
808	–	fact = 1.2;
809	–	if (r > 3) {
810	–	fact = 1.2;
811	–	r = 3;
812	–	}
909
910	<	posindex = 1 + fact * r;
910	>	/* below line of sight, using Iwata model, CIE2010, converted coordinate system according to Takuro Kikuchi */
911	>
912	>	if (phi < 0) {
913	>	beta = atan(tan(sigma/deg)* sqrt(1 + 0.3225 * pow(cos(tau/deg),2))) * deg;
914	>	posindex = exp(6.49 / 1000 * beta + 21.0 / 100000 * beta * beta);
915	>
916		}
917	+
918		if (posindex > 16)
919		posindex = 16;
920		}
#	Line 1106 | Line 1208 | get_dgp(pict * p, double E_v, int igs, double a1, doub
1208		pict_get_av_posy(p, i),
1209		posindex_2),
1210		a4) * pow(pict_get_av_omega(p, i), a2);
1211	<	/*                      printf("i,sum_glare %i %f\n",i,sum_glare);*/
1211	>	/*printf("i,sum_glare %i %f\n",i,sum_glare);    */
1212		}
1213		}
1214		dgp =
#	Line 1164 | Line 1266 | float get_vcp(float dgr )
1266		{
1267		float vcp;
1268
1269	<	vcp = 50 * erf((6.347 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1269	>	vcp = 50 * erf((6.374 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1270		if (dgr > 750) {
1271		vcp = 0;
1272		}
#	Line 1199 | Line 1301 | float get_ugr(pict * p, double lum_backg, int igs, int
1301		}
1302		}
1303		ugr = 8 * log10(0.25 / lum_backg * sum_glare);
1304	<
1304	>	if (sum_glare==0) {
1305	>	ugr=0.0;
1306	>	}
1307	>	if (lum_backg<=0) {
1308	>	ugr=-99.0;
1309	>	}
1310	>
1311		return ugr;
1312
1313		}
#	Line 1254 | Line 1362 | float get_ugp(pict * p, double lum_backg, int igs, int
1362		return ugp;
1363
1364		}
1365	+	/* subroutine for the calculation of the updated unified glare probability (Hirning 2016)*/
1366	+	float get_ugp2(pict * p, double lum_backg, int igs, int posindex_2)
1367	+	{
1368	+	float ugp;
1369	+	double sum_glare,ugp2;
1370	+	int i, i_glare;
1371
1372
1373	+	sum_glare = 0;
1374	+	i_glare = 0;
1375	+	for (i = 0; i <= igs; i++) {
1376	+
1377	+	if (pict_get_npix(p, i) > 0) {
1378	+	i_glare = i_glare + 1;
1379	+	sum_glare +=
1380	+	pow(pict_get_av_lum(p, i) /
1381	+	get_posindex(p, pict_get_av_posx(p, i),
1382	+	pict_get_av_posy(p, i), posindex_2),
1383	+	2) * pict_get_av_omega(p, i);
1384	+
1385	+	}
1386	+	}
1387	+	ugp2 = 1/pow(1.0+2.0/7.0*pow(sum_glare/lum_backg,-0.2),10.0);
1388	+
1389	+	return ugp2;
1390	+
1391	+	}
1392	+
1393	+
1394		/* subroutine for the calculation of the disability glare according to Poynter */
1395		float get_disability(pict * p, double lum_backg, int igs)
1396		{
#	Line 1329 | Line 1464 | float get_cgi(pict * p, double E_v, double E_v_dir, in
1464		return cgi;
1465		}
1466
1467	<	/* 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! */
1468	<	float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av)
1467	>
1468	>
1469	>	/* subroutine for the calculation of the PGSV_con; is only applied, when masking is done, since it refers only to the window. Important: masking area must be the window! */
1470	>	float get_pgsv_con(double E_v, double E_mask,double omega_mask,double lum_mask_av, double Lavg)
1471		{
1472	<	float pgsv;
1472	>	float pgsv_con;
1473		double Lb;
1474
1475	<	Lb = (E_v-E_mask)/1.414213562373;
1475	>	/*        Lb = (E_v-E_mask)/3.14159265359;  */
1476	>	/*        Lb = (2*E_v-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask); */
1477	>	Lb = (2*3.14159265359*Lavg-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask);
1478
1340	–	pgsv =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1479
1480	+	pgsv_con =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1481
1482	<	return pgsv;
1482	>
1483	>	return pgsv_con;
1484		}
1485
1486		/* 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! */
#	Line 1348 | Line 1488 | float get_pgsv_sat(double E_v)
1488		{
1489		float pgsv_sat;
1490
1491	<	pgsv_sat =3.3-(0.57+3.3)/pow((1+E_v/1.414213562373/1250),1.7);
1491	>	pgsv_sat =3.3-(0.57+3.3)/(1+pow(E_v/3.14159265359/1250,1.7));
1492
1493
1494		return pgsv_sat;
1495		}
1496
1497	+	/* 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! */
1498
1499	+	float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av,double Ltask, double Lavg)
1500	+	{
1501	+	float pgsv;
1502	+	double Lb;
1503
1504	+	/*        Lb = (E_v-E_mask)/3.14159265359;  */
1505	+	/*        Lb = (2*E_v-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask); */
1506	+	Lb = (2*3.14159265359*Lavg-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask);
1507	+
1508	+	if (Lb==0.0 ) {
1509	+	fprintf(stderr,  " warning: Background luminance is 0 or masking area = full image! pgsv cannot be calculated (set to -99)!!\n");
1510	+	pgsv=-99;
1511	+	}else{
1512	+	if ( (lum_mask_av/Lb) > (E_v/(3.14159265359*Ltask))) {
1513	+	pgsv=get_pgsv_con(E_v,E_mask,omega_mask,lum_mask_av, Lavg);
1514	+	}else{
1515	+	pgsv=get_pgsv_sat(E_v)  ;
1516	+	}}
1517	+	return pgsv;
1518
1519	+	}
1520	+
1521	+
1522	+
1523		#ifdef  EVALGLARE
1524
1525
#	Line 1366 | Line 1529 | float get_pgsv_sat(double E_v)
1529
1530		int main(int argc, char **argv)
1531		{
1532	<	#define CLINEMAX 4095 /* memory allocated for command line string */
1532	>	#define CLINEMAX 999999999 /* memory allocated for command line string */
1533		pict *p = pict_create();
1534		pict *pm = pict_create();
1535	<	int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1536	<	ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,
1537	<	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,x_zone,y_zone, i_z1, i_z2,
1535	>	pict *pcoeff = pict_create();
1536	>	int     add,i1,i2,y_lines,ix_offset,x_offset,y_offset, patchmode,ix, iy, patch_pixdistance_x, patch_pixdistance_y,nx_patch,ny_patch, lowlight,skip_second_scan,
1537	>	calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1538	>	ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,j,jj,multi_image_mode,
1539	>	i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,x_zone,y_zone, i_z1, i_z2, thres_activate,num_images,xmap,ymap,
1540		igs, actual_igs, lastpixelwas_gs, icol, xt, yt, change,checkpixels, before_igs, sgs, splithigh,uniform_gs,x_max, y_max,y_mid,
1541	<	detail_out, posindex_picture, non_cos_lb, rx, ry, rmx,rmy,apply_disability,band_calc,band_color,masking,i_mask,no_glaresources,force;
1542	<	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,
1543	<	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,
1544	<	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,
1545	<	omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang, angle_z1, angle_z2,per_95_band,per_75_band,pos,
1541	>	detail_out, posindex_picture, non_cos_lb, rx, ry,lastpixelwas_peak, rmx,rmy,apply_disability,band_calc,band_color,masking,i_mask,no_glaresources,force,num_scans;
1542	>	double  abs_max,Lveil,xxx,angle_v,angle_h,patch_angle, r_contrast,r_dgp,r_glare,sum_glare, LUM_replace,lum_total_max,age_corr_factor,age,dgp_ext,dgp,low_light_corr,omega_cos_contr, setvalue,
1543	>	lum_ideal, E_v_contr, sigma,om,delta_E,
1544	>	E_vl_ext, lum_max, new_lum_max, r_center, ugp,ugp2, ugr_exp, dgi_mod,lum_a, E_v_mask,angle_disk,dist,n_corner_px,zero_corner_px,
1545	>	search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,dir_ill,
1546	>	omegat, sang,Ez1,Ez2, E_v, E_v2, E_v_dir, avlum, act_lum, ang, angle_z1, angle_z2,per_95_band,per_75_band,pos,
1547		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,
1548		lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum,
1549		lum_mask[1],lum_mask_av,lum_mask_std[1],lum_mask_median[1],omega_mask,bbox[2],
#	Line 1385 | Line 1551 | int main(int argc, char **argv)
1551		lum_z1[1],lum_z1_av,lum_z1_std[1],lum_z1_median[1],omega_z1,bbox_z1[2],
1552		lum_z2[1],lum_z2_av,lum_z2_std[1],lum_z2_median[1],omega_z2,bbox_z2[2],
1553		lum_pos[1],lum_nopos_median[1],lum_pos_median[1],lum_pos2_median[1],lum_pos_mean,lum_pos2_mean;
1554	<	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,
1555	<	abs_max, Lveil;
1390	<	char maskfile[500],file_out[500], file_out2[500], version[500];
1554	>	float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,pgsv ,pgsv_sat,pgsv_con;
1555	>	char maskfile[500],file_out[500], file_out2[500], version[500],correction_type[500];
1556		char *cline;
1557	+	char** temp_image_name;
1558	+	int *x_temp_img, *y_temp_img;
1559	+	double *scale_image_scans;
1560	+	int *new_gs_number = NULL;
1561		VIEW userview = STDVIEW;
1562		int gotuserview = 0;
1563	+
1564		struct muc_rvar* s_mask;
1565		s_mask = muc_rvar_create();
1566		muc_rvar_set_dim(s_mask, 1);
#	Line 1425 | Line 1595 | int main(int argc, char **argv)
1595		muc_rvar_clear(s_posweight2);
1596
1597		/*set required user view parameters to invalid values*/
1598	+	patchmode=0;
1599	+	patch_angle=25.0;
1600	+	patch_pixdistance_x=0;
1601	+	patch_pixdistance_y=0;
1602	+	lowlight=0;
1603	+	multi_image_mode=0;
1604	+	lastpixelwas_peak=0;
1605	+	num_images=0;
1606	+	dir_ill=0.0;
1607		delta_E=0.0;
1608		no_glaresources=0;
1609		n_corner_px=0;
#	Line 1446 | Line 1625 | int main(int argc, char **argv)
1625		lum_band_av = 0.0;
1626		omega_band = 0.0;
1627		pgsv = 0.0 ;
1628	+	pgsv_con = 0.0 ;
1629		pgsv_sat = 0.0 ;
1630		E_v_mask = 0.0;
1631	+	Ez1 = 0.0;
1632	+	Ez2 = 0.0;
1633		lum_z1_av = 0.0;
1634		omega_z1 = 0.0;
1635		lum_z2_av = 0.0;
#	Line 1487 | Line 1669 | int main(int argc, char **argv)
1669		omega_cos_contr = 0.0;
1670		lum_ideal = 0.0;
1671		max_angle = 0.2;
1672	<	lum_thres = 5.0;
1672	>	lum_thres = 2000.0;
1673	>	lum_task = 0.0;
1674		task_lum = 0;
1675		sgs = 0;
1676		splithigh = 1;
#	Line 1505 | Line 1688 | int main(int argc, char **argv)
1688		c1 = 5.87e-05;
1689		c2 = 0.092;
1690		c3 = 0.159;
1691	<	non_cos_lb = 1;
1691	>	non_cos_lb = 0;
1692		posindex_2 = 0;
1693		task_color = 0;
1694		limit = 50000.0;
#	Line 1513 | Line 1696 | int main(int argc, char **argv)
1696		set_lum_max2 = 0;
1697		img_corr=0;
1698		abs_max = 0;
1699	<	progname = argv[0];
1699	>	fixargv0(argv[0]);
1700		E_v_contr = 0.0;
1701	<	strcpy(version, "1.19 release 09.12.2015 by J.Wienold");
1701	>	strcpy(version, "3.05 release 25.06.2024 by J.Wienold");
1702		low_light_corr=1.0;
1703		output = 0;
1704		calc_vill = 0;
#	Line 1527 | Line 1710 | int main(int argc, char **argv)
1710		omega_mask=0.0;
1711		i_mask=0;
1712		actual_igs=0;
1713	+	LUM_replace=0;
1714	+	thres_activate=0;
1715		/* command line for output picture*/
1716
1717	<	cline = (char *) malloc(CLINEMAX+1);
1717	>	cline = (char *) malloc(CLINEMAX+100);
1718		cline[0] = '\0';
1719		for (i = 0; i < argc; i++) {
1720		/*       fprintf(stderr, "%d %d \n",i,strlen(argv[i]));*/
#	Line 1577 | Line 1762 | int main(int argc, char **argv)
1762		break;
1763		case 'b':
1764		lum_thres = atof(argv[++i]);
1765	+	lum_source =lum_thres;
1766	+	thres_activate = 1;
1767		break;
1768		case 'c':
1769		checkfile = 1;
#	Line 1591 | Line 1778 | int main(int argc, char **argv)
1778		case 'r':
1779		max_angle = atof(argv[++i]);
1780		break;
1781	+	case 'z':
1782	+	patch_angle = atof(argv[++i]);
1783	+	patchmode= atoi(argv[++i]);
1784	+	if ( patchmode == 3) { output=4;}
1785	+
1786	+	/* patchmode = 0 : deactivated; patchmode =1: patch without combining, normal output; patchmode =3: patch without combining, coefficient output; patchmode =2 patch with combining (not yet implemented...) */
1787	+	break;
1788	+
1789		case 's':
1790		sgs = 1;
1791		break;
#	Line 1665 | Line 1860 | int main(int argc, char **argv)
1860		strcpy(file_out2, argv[++i]);
1861		/*                      printf("max lum set to %f\n",new_lum_max);*/
1862		break;
1863	+	case 'O':
1864	+	img_corr = 1;
1865	+	set_lum_max2 = 3;
1866	+	x_disk = atoi(argv[++i]);
1867	+	y_disk = atoi(argv[++i]);
1868	+	angle_disk = atof(argv[++i]);
1869	+	LUM_replace = atof(argv[++i]);
1870	+	strcpy(file_out2, argv[++i]);
1871	+	/*                      printf("max lum set to %f\n",new_lum_max);*/
1872	+	break;
1873
1874	<	case 'n':
1874	>
1875	>	/* deactivated          case 'n':
1876		non_cos_lb = 0;
1877		break;
1878	+	*/
1879	+	case 'q':
1880	+	non_cos_lb = atoi(argv[++i]);
1881	+	break;
1882
1883		case 't':
1884		task_lum = 1;
#	Line 1733 | Line 1943 | int main(int argc, char **argv)
1943		/*case 'v':
1944		printf("evalglare  %s \n",version);
1945		exit(1); */
1946	+	case 'C':
1947	+	strcpy(correction_type,argv[++i]);
1948	+
1949	+	if (!strcmp(correction_type,"l-")  ){
1950	+	/*      printf("low light off!\n"); */
1951	+	lowlight = 0; }
1952	+	if (!strcmp(correction_type,"l+")  ){
1953	+	/*      printf("low light on!\n"); */
1954	+	lowlight = 1; }
1955	+	if (!strcmp(correction_type,"0")  ){
1956	+	/*      printf("all corrections off!\n"); */
1957	+	lowlight = 0; }
1958	+
1959	+	break;
1960
1961	+	/*case 'v':
1962	+	printf("evalglare  %s \n",version);
1963	+	exit(1); */
1964	+
1965		case '1':
1966		output = 1;
1967		break;
1968	<
1968	>	case '2':
1969	>	output = 2;
1970	>	dir_ill = atof(argv[++i]);
1971	>	break;
1972	>	case '3':
1973	>	output = 3;
1974	>	break;
1975	>	case '4':
1976	>	lowlight = 0;
1977	>	break;
1978	>	case 'Q':
1979	>	multi_image_mode=1;
1980	>	output= 3;
1981	>	calcfast=1;
1982	>	num_images =atoi(argv[++i]);
1983	>	num_scans =atoi(argv[++i]);
1984	>	temp_image_name = malloc(sizeof(char*)*num_images);
1985	>
1986	>	x_temp_img=(int *) malloc(sizeof(int) * num_images);
1987	>	y_temp_img=(int *) malloc(sizeof(int) * num_images);
1988	>	scale_image_scans=(double *) malloc(sizeof(double) * (num_scans+1)*num_images);
1989	>	/* iterate through all images and allocate 256 characters to each: */
1990	>	for (j = 0; j < num_images; j++) {
1991	>	scale_image_scans[j*(num_scans+1)]=1.0;
1992	>	temp_image_name[j] = malloc(256*sizeof(char));
1993	>	strcpy(temp_image_name[j], argv[++i]);
1994	>	x_temp_img[j] = atoi(argv[++i]);
1995	>	y_temp_img[j] = atoi(argv[++i]);
1996	>	for (jj=1;jj<=num_scans;jj++){
1997	>	scale_image_scans[j*(num_scans+1)+jj]=atof(argv[++i]);}
1998	>	}
1999	>
2000	>
2001	>	break;
2002		case 'v':
2003		if (argv[i][2] == '\0') {
2004		printf("%s \n",RELEASENAME);
#	Line 1766 | Line 2027 | int main(int argc, char **argv)
2027		}
2028		}
2029
2030	+	/* set multiplier for task method to 5, if not specified */
2031	+
2032	+
2033	+
2034	+	if ( task_lum == 1 && thres_activate == 0){
2035	+	lum_thres = 5.0;
2036	+	}
2037		/*fast calculation, if gendgp_profile is used: No Vertical illuminance calculation, only dgp is calculated*/
2038
2039	<	if (output == 1 && ext_vill == 1) {
2039	>	if (output == 1 && ext_vill == 1 ) {
2040		calcfast=1;
2041		}
2042	+
2043	+	if (output == 2 && ext_vill == 1 ) {
2044	+	calcfast=2;
2045	+	}
2046	+
2047		/*masking and zoning cannot be applied at the same time*/
2048
2049		if (masking ==1 && zones >0) {
#	Line 1825 | Line 2098 | if (masking ==1 && zones >0) {
2098		exit(1);
2099		}
2100
2101	+	if ( patchmode > 0 && p->view.type != VT_ANG) {
2102	+
2103	+	fprintf(stderr, "error: Patchmode only possible with view type vta  !  Stopping... \n");
2104	+	exit(1);
2105	+
2106	+	}
2107	+
2108	+
2109		if (p->view.type == VT_PER) {
2110		fprintf(stderr, "warning: image has perspective view type specified in header ! \n");
2111		}
2112
2113		if (masking == 1) {
2114
2115	<	if (!pict_get_xsize(p)==pict_get_xsize(pm) || !pict_get_ysize(p)==pict_get_ysize(pm)) {
2115	>	if (pict_get_xsize(p)!=pict_get_xsize(pm) || pict_get_ysize(p)!=pict_get_ysize(pm)) {
2116		fprintf(stderr, "error: masking image has other resolution than main image ! \n");
2117		fprintf(stderr, "size must be identical \n");
2118		printf("resolution main image : %dx%d\n",pict_get_xsize(p),pict_get_ysize(p));
#	Line 1866 | Line 2147 | if (masking ==1 && zones >0) {
2147
2148		}
2149		}
2150	<
2150	>
2151	>
2152		/* Check task position  */
2153
2154		if (task_lum == 1) {
#	Line 1890 | Line 2172 | if (masking ==1 && zones >0) {
2172		pict_get_z1_gsn(p,igs) = 0;
2173		pict_get_z2_gsn(p,igs) = 0;
2174
2175	+	if (multi_image_mode<1) {
2176
2177	+
2178		/* cut out GUTH field of view and exit without glare evaluation */
2179		if (cut_view==2) {
2180		if (cut_view_type==1) {
#	Line 2059 | Line 2343 | if (cut_view==2) {
2343		lum_pos_mean= lum_pos_mean/sang;
2344		lum_pos2_mean= lum_pos2_mean/sang;
2345
2346	<	if (set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) {
2346	>	if ((set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0 ) || set_lum_max2==3) {
2347
2348	+	if (set_lum_max2<3){
2349		lum_ideal = (E_vl_ext - E_v + E_v_contr) / omega_cos_contr;
2350		if (set_lum_max2 == 2 && lum_ideal >= 2e9) {
2351		printf("warning! luminance of replacement pixels would be larger than 2e9 cd/m2. Value set to 2e9cd/m2!\n") ;
#	Line 2071 | Line 2356 | if (cut_view==2) {
2356		}
2357		printf("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2358		lum_ideal, setvalue, E_vl_ext, E_v, E_v_contr);
2359	+	}else{setvalue=LUM_replace;
2360	+	}
2361
2362
2363		for (x = 0; x < pict_get_xsize(p); x++)
#	Line 2090 | Line 2377 | if (cut_view==2) {
2377		pict_get_color(p, x, y)[BLU] =
2378		setvalue / 179.0;
2379
2380	<	}else{ if(set_lum_max2 ==2 ) {
2380	>	}else{ if(set_lum_max2 >1 ) {
2381		r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2382		if (x_disk == x && y_disk==y ) r_actual=0.0;
2383
#	Line 2103 | Line 2390 | if (cut_view==2) {
2390		pict_get_color(p, x, y)[BLU] =
2391		setvalue / 179.0;
2392
2393	<	}
2107	<
2108	<
2393	>	}
2394		}
2395		}
2396		}
#	Line 2177 | Line 2462 | if (cut_view==1) {
2462		/*     printf("Ev, avlum, Omega_tot%f %f %f \n",E_v, avlum, sang); */
2463
2464		/* first glare source scan: find primary glare sources */
2465	+
2466	+	if (patchmode==0) {
2467		for (x = 0; x < pict_get_xsize(p); x++) {
2468	<	/*                lastpixelwas_gs=0; */
2468	>	lastpixelwas_gs=0;
2469	>	/*              lastpixelwas_peak=0; */
2470		for (y = 0; y < pict_get_ysize(p); y++) {
2471		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2472		if (pict_is_validpixel(p, x, y)) {
#	Line 2188 | Line 2476 | if (cut_view==1) {
2476		lum_total_max=act_lum;
2477		}
2478		/* speed improvement first scan: when last pixel was glare source, then use this glare source number instead of searching.
2479	<	has been deactivated with v1.25
2479	>	has been deactivated with v1.25, reactivated with v2.10 */
2480
2481	<	if (lastpixelwas_gs==0 || search_pix <= 1.0 ) { */
2481	>	if (lastpixelwas_gs==0 || search_pix <= 1.0 ) {
2482		actual_igs = find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2483	<	/*  }*/
2483	>	}
2484		if (actual_igs == 0) {
2485		igs = igs + 1;
2486		pict_new_gli(p);
#	Line 2208 | Line 2496 | if (cut_view==1) {
2496		pict_get_gsn(p, x, y) = actual_igs;
2497		pict_get_pgs(p, x, y) = 1;
2498		add_pixel_to_gs(p, x, y, actual_igs);
2499	<	/*                                                lastpixelwas_gs=actual_igs; */
2499	>	lastpixelwas_gs=actual_igs;
2500
2501		} else {
2502		pict_get_pgs(p, x, y) = 0;
2503	<	/*                                               lastpixelwas_gs=0;*/
2503	>	lastpixelwas_gs=0;
2504		}
2505		}
2506		}
2507		}
2508		}
2509	<	/*      pict_write(p,"firstscan.pic");   */
2509	>	} else {
2510	>	/* patchmode on!
2511	>	calculation only for angular projection!
2512
2513	+	*/
2514
2515	<	if (calcfast == 1 || search_pix <= 1.0) {
2515	>
2516	>	angle_v=p->view.vert;
2517	>	angle_h=p->view.horiz;
2518	>
2519	>
2520	>	/*printf ("angle_v,angle_h: %f %f \n",angle_v,angle_h) ;
2521	>
2522	>	setting up patches as glare sources */
2523	>
2524	>	patch_pixdistance_x=floor(pict_get_xsize(p)/angle_h*patch_angle);
2525	>	patch_pixdistance_y=floor(pict_get_ysize(p)/angle_v*patch_angle);
2526	>
2527	>	nx_patch=floor(angle_v/patch_angle)+1;
2528	>	ny_patch=floor(angle_h/patch_angle)+1;
2529	>
2530	>	y_offset=floor (patch_pixdistance_y/2);
2531	>	x_offset=floor (patch_pixdistance_x/2);
2532	>	/* printf ("nx_patch,ny_patch,x_offset,y_offset,patch_pixdistance_x,patch_pixdistance_y   %i %i %i %i %i %i\n",nx_patch,ny_patch,x_offset,y_offset,patch_pixdistance_x,patch_pixdistance_y) ; */
2533	>
2534	>	ix_offset=0;
2535	>	for (iy=1; iy<=ny_patch;iy++) {
2536	>
2537	>
2538	>
2539	>	for (ix=1; ix<=nx_patch;ix++) {
2540	>	igs = igs + 1;
2541	>	pict_new_gli(p);
2542	>
2543	>	pict_get_lum_min(p, igs) = HUGE_VAL;
2544	>	pict_get_Eglare(p,igs) = 0.0;
2545	>	pict_get_Dglare(p,igs) = 0.0;
2546	>	pict_get_z1_gsn(p,igs) = 0;
2547	>	pict_get_z2_gsn(p,igs) = 0;
2548	>	pict_get_dx_max(p,igs) = (x_offset+ix_offset*x_offset+(ix-1)*patch_pixdistance_x)*1.0;
2549	>	pict_get_dy_max(p,igs) = (y_offset+(iy-1)*patch_pixdistance_y)*1.0;
2550	>
2551	>	/* printf ("igs, x-patch, y-patch : %i %f %f \n",igs,pict_get_dx_max(p,igs),pict_get_dy_max(p,igs) ) ; */
2552	>
2553	>	}
2554	>	ix_offset=ix_offset+1;
2555	>	if (ix_offset==2) {
2556	>	ix_offset =0 ;
2557	>	}
2558	>
2559	>	}
2560	>	for (y = 0; y < pict_get_ysize(p); y++) {
2561	>	for (x = 0; x < pict_get_xsize(p); x++) {
2562	>
2563	>	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2564	>	if (pict_is_validpixel(p, x, y)) {
2565	>	act_lum = luminance(pict_get_color(p, x, y));
2566	>	if (act_lum > lum_source) {
2567	>	if (act_lum >lum_total_max) {
2568	>	lum_total_max=act_lum;
2569	>	}
2570	>
2571	>	y_lines = floor((y)/patch_pixdistance_y);
2572	>	xxx = (x+0.0)/(patch_pixdistance_x+0.0)-0.5*(y_lines % 2);
2573	>	if (xxx<0 ) { xxx=0.0 ;}
2574	>	i1 = y_lines*(nx_patch)+floor(xxx)+1;
2575	>	i2=0;
2576	>	add=0;
2577	>	if (y_lines % 2 == 1 ) {add=1;}
2578	>
2579	>	if (y >pict_get_dy_max(p,i1)) {
2580	>
2581	>	if (x > pict_get_dx_max(p,i1)) {
2582	>	i2=i1+nx_patch+add;
2583	>	}else {
2584	>	i2=i1+nx_patch-1+add;
2585	>	}
2586	>	}else {
2587	>
2588	>	if (x > pict_get_dx_max(p,i1)) {
2589	>	i2=i1-nx_patch+add;
2590	>	}else {
2591	>	i2=i1-nx_patch-1+add;
2592	>	}
2593	>	}
2594	>
2595	>
2596	>
2597	>
2598	>	if (i2 > igs || i2 < 1) {actual_igs=i1;}else{
2599	>	if ( ((x-pict_get_dx_max(p,i1))*(x-pict_get_dx_max(p,i1))+(y-pict_get_dy_max(p,i1))*(y-pict_get_dy_max(p,i1))) < ((x-pict_get_dx_max(p,i2))*(x-pict_get_dx_max(p,i2))+(y-pict_get_dy_max(p,i2))*(y-pict_get_dy_max(p,i2))) ) {
2600	>	actual_igs=i1; }else {actual_igs=i2;}}
2601	>
2602	>
2603	>	pict_get_gsn(p, x, y) = actual_igs;
2604	>	pict_get_pgs(p, x, y) = 1;
2605	>	add_pixel_to_gs(p, x, y, actual_igs);
2606	>	/*                      setglcolor(p, x, y, actual_igs, uniform_gs, u_r, u_g , u_b); */
2607	>	}
2608	>	}
2609	>	}
2610	>
2611	>
2612	>
2613	>
2614	>
2615	>	}               }
2616	>
2617	>
2618	>
2619	>
2620	>	}
2621	>	/*                    pict_write(p,"firstscan.pic");   */
2622	>
2623	>
2624	>
2625	>
2626	>	if (calcfast ==1 || search_pix <= 1.0 || calcfast == 2 || patchmode > 0) {
2627		skip_second_scan=1;
2628		}
2629	+
2630
2631		/* second glare source scan: combine glare sources facing each other */
2632		change = 1;
#	Line 2304 | Line 2707 | if (calcfast == 1 || search_pix <= 1.0) {
2707
2708		/* extract extremes from glare sources to extra glare source */
2709		if (splithigh == 1 && lum_total_max>limit) {
2710	+	/*             fprintf(stderr,  " split of glare source!\n"); */
2711
2712		r_split = max_angle / 2.0;
2713		for (i = 0; i <= i_max; i++) {
#	Line 2398 | Line 2802 | if (calcfast == 1 || search_pix <= 1.0) {
2802
2803		/* calculation of direct vertical illuminance for CGI and for disability glare, coloring glare sources*/
2804
2805	<	if (calcfast == 0) {
2805	>	if (calcfast == 0 || calcfast == 2) {
2806		for (x = 0; x < pict_get_xsize(p); x++)
2807		for (y = 0; y < pict_get_ysize(p); y++) {
2808		if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
#	Line 2463 | Line 2867 | if (calcfast == 1 || search_pix <= 1.0) {
2867		i=0;
2868		for (x = 0; x <= igs; x++) {
2869		if (pict_get_npix(p, x) > 0) {
2870	+	sum_glare += pow(pict_get_av_lum(p, x),2.0)* pict_get_av_omega(p, x)/pow(get_posindex(p, pict_get_av_posx(p, x), pict_get_av_posy(p, x),posindex_2), 2.0);
2871		lum_sources += pict_get_av_lum(p, x) * pict_get_av_omega(p, x);
2872		omega_sources += pict_get_av_omega(p, x);
2873		i=i+1;
2874		}}
2875	<
2875	>	sum_glare= c2*log10(1 + sum_glare / pow(E_v, a3));
2876		if (sang == omega_sources) {
2877		lum_backg =avlum;
2878		} else {
#	Line 2486 | Line 2891 | if (calcfast == 1 || search_pix <= 1.0) {
2891		lum_backg = lum_backg_cos;
2892		}
2893
2894	+	if (non_cos_lb == 2) {
2895	+	lum_backg = E_v / 3.1415927;
2896	+	}
2897	+
2898	+
2899		/* file writing NOT here
2900		if (checkfile == 1) {
2901		pict_write(p, file_out);
#	Line 2495 | Line 2905 | if (calcfast == 1 || search_pix <= 1.0) {
2905		/* print detailed output */
2906
2907
2498	–	if (detail_out == 1) {
2908
2909		/* masking */
2910
#	Line 2538 | Line 2947 | if (calcfast == 1 || search_pix <= 1.0) {
2947		muc_rvar_get_median(s_mask,lum_mask_median);
2948		muc_rvar_get_bounding_box(s_mask,bbox);
2949		/* PSGV only why masking of window is applied! */
2950	<	pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av);
2950	>
2951	>
2952	>	if (task_lum == 0 || lum_task == 0.0 ) {
2953	>	fprintf(stderr, " warning: Task area not set or task luminance=0 ! pgsv cannot be calculated (set to -99)!!\n");
2954	>	pgsv = -99;
2955	>	} else {
2956	>	pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av,lum_task,avlum);
2957	>	}
2958	>
2959	>	pgsv_con = get_pgsv_con(E_v, E_v_mask, omega_mask, lum_mask_av,avlum);
2960		pgsv_sat =get_pgsv_sat(E_v);
2543	–	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 );
2961
2962	+	if (detail_out == 1) {
2963	+
2964	+	printf ("masking:no_pixels,omega,av_lum,median_lum,std_lum,perc_75,perc_95,lum_min,lum_max,pgsv_con,pgsv_sat,pgsv,Ev_mask: %i %f %f %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_con,pgsv_sat,pgsv,E_v_mask );
2965	+
2966	+	}
2967
2546	–
2968		}
2969
2970		/* zones */
#	Line 2568 | Line 2989 | if (calcfast == 1 || search_pix <= 1.0) {
2989		muc_rvar_add_sample(s_z1, lum_z1);
2990		omega_z1 += pict_get_omega(p, x, y);
2991		lum_z1_av += pict_get_omega(p, x, y)* lum_actual;
2992	+	Ez1 += DOT(p->view.vdir, pict_get_cached_dir(p, x, y))* pict_get_omega(p, x, y)* lum_actual;
2993		setglcolor(p,x,y,1,1 , 0.66, 0.01 ,0.33);
2994		/*check if separation gsn already exist */
2995
#	Line 2584 | Line 3006 | if (calcfast == 1 || search_pix <= 1.0) {
3006		splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
3007		/*          printf("splitgs%i \n",splitgs);       */
3008		split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
3009	+	/* move direct illuminance contribution into  zone -value           */
3010	+	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));
3011	+	pict_get_Eglare(p,act_gsn ) = pict_get_Eglare(p,act_gsn ) - delta_E;
3012	+	pict_get_Eglare(p,igs ) = pict_get_Eglare(p,igs ) + delta_E;
3013	+
3014	+
3015		}
3016		}
3017		/*zone2 */
#	Line 2595 | Line 3023 | if (calcfast == 1 || search_pix <= 1.0) {
3023		muc_rvar_add_sample(s_z2, lum_z2);
3024		omega_z2 +=   pict_get_omega(p, x, y);
3025		lum_z2_av += pict_get_omega(p, x, y)* lum_actual;
3026	+	Ez2 += DOT(p->view.vdir, pict_get_cached_dir(p, x, y))* pict_get_omega(p, x, y)* lum_actual;
3027		setglcolor(p,x,y,1,1 , 0.65, 0.33 ,0.02);
3028		/*                                                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));
3029		*/                                                if (act_gsn > 0){
#	Line 2609 | Line 3038 | if (calcfast == 1 || search_pix <= 1.0) {
3038		splitgs=(int)(pict_get_z2_gsn(p,act_gsn));
3039		/*                                              printf("splitgs %i \n",splitgs);*/
3040		split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
3041	+	/* move direct illuminance contribution into  zone -value           */
3042	+	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));
3043	+	pict_get_Eglare(p,act_gsn ) = pict_get_Eglare(p,act_gsn ) - delta_E;
3044	+	pict_get_Eglare(p,igs ) = pict_get_Eglare(p,igs ) + delta_E;
3045	+
3046		}
3047		}
3048
#	Line 2633 | Line 3067 | if (calcfast == 1 || search_pix <= 1.0) {
3067		per_95_z1=lum_z1_median[0];
3068		muc_rvar_get_median(s_z1,lum_z1_median);
3069		muc_rvar_get_bounding_box(s_z1,bbox_z1);
3070	<
2637	<	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] );
3070	>	if (detail_out == 1) {
3071
3072	+	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,Ez1,i_z1: %f %f %f %f %f %f %f %f %f %i\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],Ez1,i_z1 );
3073	+
3074		if (zones == 2 ) {
3075
3076	<	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] );
3077	<	}
3076	>	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,Ez2,i_z2:  %f %f %f %f %f %f %f %f %f %i\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],Ez2,i_z1 );
3077	>	} }
3078
3079		}
3080
3081	+	new_gs_number = (int *)malloc(sizeof(int)*(igs+1));
3082	+
3083		i = 0;
3084		for (x = 0; x <= igs; x++) {
3085		/* resorting glare source numbers */
3086		if (pict_get_npix(p, x) > 0) {
3087		i = i + 1;
3088	+	pict_get_Dglare(p,x) = i;
3089	+	new_gs_number[x] = i;
3090	+	/*                      printf("%i %i %f %i \n", i,x,pict_get_Dglare(p,x),new_gs_number[x] ); */
3091		}
3092		}
3093		no_glaresources=i;
3094	<
3094	>	/*printf("%i",no_glaresources );*/
3095		/* glare sources */
3096	+
3097	+	if (output == 4 ) {
3098	+
3099	+	i=0;
3100	+	for (x = 0; x <= igs; x++) {
3101	+	if (pict_get_npix(p, x) > 0) {
3102	+	i = i + 1;
3103	+
3104	+	x2=pict_get_av_posx(p, x);
3105	+	y2=pict_get_av_posy(p, x);
3106	+
3107	+	printf("%i %f %f %f %f %.10f %f %f %f %f \n",
3108	+	i, pict_get_npix(p, x), pict_get_av_posx(p, x), pict_get_av_posy(p, x),
3109	+	pict_get_av_lum(p, x), pict_get_av_omega(p, x),
3110	+	get_posindex(p, pict_get_av_posx(p, x),pict_get_av_posy(p, x),posindex_2),
3111	+	pict_get_cached_dir(p, x2,y2)[0],pict_get_cached_dir(p, x2,y2)[1],pict_get_cached_dir(p, x2,y2)[2]);
3112	+	}
3113	+	}
3114	+
3115	+
3116	+	for (y = 0; y < pict_get_ysize(p); y++) {
3117	+	for (x = 0; x < pict_get_xsize(p); x++) {
3118	+
3119	+	if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
3120	+	if (pict_is_validpixel(p, x, y)) {
3121	+	if (pict_get_gsn(p,x,y) >0 ) {
3122	+	i=pict_get_gsn(p,x,y);
3123	+	printf("%i %i %f %f %f \n", i, new_gs_number[i], pict_get_cached_dir(p, x,y)[0],pict_get_cached_dir(p, x,y)[1],pict_get_cached_dir(p, x,y)[2] );
3124	+
3125	+	}
3126	+
3127	+
3128	+
3129	+	}}}}
3130	+
3131	+
3132	+	}
3133	+
3134	+
3135	+
3136	+
3137	+	if (detail_out == 1 && output < 3) {
3138	+	dgp = get_dgp(p, E_v, igs, a1, a2, a3, a4, a5, c1, c2, c3, posindex_2);
3139	+
3140		printf
3141	<	("%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",
3141	>	("%i No pixels x-pos y-pos L_s Omega_s Posindx L_b L_t E_v Edir Max_Lum Sigma xdir ydir zdir Eglare Lveil_cie teta glare_zone r_contrast r_dgp\n",
3142		i);
3143		if (i == 0) {
3144	<	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,
3145	<	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);
3144	>	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n", i, 0.0, 0.0,
3145	>	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,0.0,0.0);
3146
3147		} else {
3148		i = 0;
#	Line 2678 | Line 3162 | if (calcfast == 1 || search_pix <= 1.0) {
3162		Lveil_cie =0 ;
3163		}
3164		Lveil_cie_sum =  Lveil_cie_sum + Lveil_cie;
3165	+	r_glare= c2*log10(1 + pow(pict_get_av_lum(p, x),2)* pict_get_av_omega(p, x)/pow(get_posindex(p, pict_get_av_posx(p, x), pict_get_av_posy(p, x),posindex_2), 2.0) / pow(E_v, a3))  ;
3166	+	r_contrast=r_glare/sum_glare  ;
3167	+	r_dgp=r_glare/dgp ;
3168		if (pict_get_z1_gsn(p,x)<0) {
3169		act_gsn=(int)(-pict_get_z1_gsn(p,x));
3170		}else{
3171		act_gsn=0;
3172		}
3173	<	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %i \n",
3173	>	printf("%i %f %f %f %f %.10f %f %f %f %f %f %f %f %f %f %f %f %f %f %i %f %f \n",
3174		i, pict_get_npix(p, x), pict_get_av_posx(p, x),
3175		pict_get_ysize(p) - pict_get_av_posy(p, x),
3176		pict_get_av_lum(p, x), pict_get_av_omega(p, x),
#	Line 2691 | Line 3178 | if (calcfast == 1 || search_pix <= 1.0) {
3178		pict_get_av_posy(p, x),
3179		posindex_2), lum_backg, lum_task,
3180		E_v, E_v_dir, abs_max, sigma * 180 / 3.1415927
3181	<	,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 );
3181	>	,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,r_contrast,r_dgp );
3182		}
3183		}
3184		}
3185		}
3186
3187	+	if ( output < 3) {
3188
2701	–
3189		/* calculation of indicees */
3190
3191		/* check vertical illuminance range */
#	Line 2711 | Line 3198 | if (calcfast == 1 || search_pix <= 1.0) {
3198		dgp =
3199		get_dgp(p, E_v2, igs, a1, a2, a3, a4, a5, c1, c2, c3, posindex_2);
3200		/* low light correction */
3201	+	if (lowlight ==1) {
3202		if (E_v < 1000) {
3203		low_light_corr=1.0*exp(0.024*E_v-4)/(1+exp(0.024*E_v-4));} else {low_light_corr=1.0 ;}
3204		dgp =low_light_corr*dgp;
3205	<
3205	>	}
3206		/* age correction */
3207
3208		if (age_corr == 1) {
#	Line 2735 | Line 3223 | if (calcfast == 0) {
3223		dgi = get_dgi(p, lum_backg, igs, posindex_2);
3224		ugr = get_ugr(p, lum_backg, igs, posindex_2);
3225		ugp = get_ugp (p,lum_backg, igs, posindex_2);
3226	+	ugp2 = get_ugp2 (p,lum_backg, igs, posindex_2);
3227		ugr_exp = get_ugr_exp (p,lum_backg_cos,lum_a, igs, posindex_2);
3228		dgi_mod = get_dgi_mod(p, lum_a, igs, posindex_2);
3229		cgi = get_cgi(p, E_v, E_v_dir, igs, posindex_2);
#	Line 2745 | Line 3234 | if (calcfast == 0) {
3234		dgi = 0.0;
3235		ugr = 0.0;
3236		ugp = 0.0;
3237	+	ugp2 =0.0;
3238		ugr_exp = 0.0;
3239		dgi_mod = 0.0;
3240		cgi = 0.0;
#	Line 2771 | Line 3261 | if (calcfast == 0) {
3261		get_dgp(p, E_vl_ext, igs, a1, a2, a3, a4, a5, c1, c2, c3,
3262		posindex_2);
3263		dgp = dgp_ext;
3264	<	if (E_vl_ext < 1000) {
3264	>	if (E_vl_ext < 1000 && lowlight ==1) {
3265		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 ;}
3266		dgp =low_light_corr*dgp;
3267		dgp =age_corr_factor*dgp;
#	Line 2784 | Line 3274 | if (calcfast == 0) {
3274
3275
3276		printf
3277	<	("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",
3277	>	("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,ugp2: %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
3278		dgp, avlum, E_v, lum_backg, E_v_dir, dgi, ugr, vcp, cgi,
3279	<	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]);
3279	>	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],ugp2);
3280		} else {
3281		if (detail_out2 == 1) {
3282
#	Line 2799 | Line 3289 | if (calcfast == 0) {
3289		if (ext_vill == 1) {
3290		dgp_ext = get_dgp(p, E_vl_ext, igs, a1, a2, a3, a4, a5, c1, c2, c3,posindex_2);
3291
3292	<	if (E_vl_ext < 1000) {
3292	>	if (E_vl_ext < 1000 && lowlight ==1) {
3293		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 ;}
3294		dgp =low_light_corr*dgp_ext;
3295		dgp =age_corr_factor*dgp;
#	Line 2814 | Line 3304 | if (calcfast == 0) {
3304		get_dgp(p, E_vl_ext, igs, a1, a2, a3, a4, a5, c1, c2, c3,
3305		posindex_2);
3306		dgp = dgp_ext;
3307	<	if (E_vl_ext < 1000) {
3307	>	if (E_vl_ext < 1000 && lowlight ==1) {
3308		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 ;}
3309		dgp =low_light_corr*dgp;
3310	<	dgp =age_corr_factor*dgp;
3311	<	printf("%f\n", dgp);
3310	>
3311	>	if (calcfast == 2) {
3312	>
3313	>	lum_backg_cos=(E_vl_ext-dir_ill)/3.1415927;
3314	>	ugr = get_ugr(p, lum_backg_cos, igs, posindex_2);
3315	>	printf("%f %f \n", dgp,ugr);
3316	>	}else{
3317	>	printf("%f\n", dgp);
3318	>	}
3319		}
3320	+	}
3321
3322	+	}else{
3323	+	/* only multiimagemode
3324	+
3325	+	*/
3326	+
3327	+
3328	+	for (j = 0; j < num_images; j++) {
3329	+
3330	+
3331	+	/* loop over temporal images */
3332	+
3333	+	pict_read(pcoeff,temp_image_name[j] );
3334	+
3335	+	/*printf ("num_img:%i x-size:%i xpos:%i y-size: %i ypos %i bigimg-xsize %i %i ",num_images,pict_get_xsize(pcoeff),x_temp_img[j],pict_get_ysize(pcoeff),y_temp_img[j],pict_get_xsize(p),pict_get_ysize(p));
3336	+	*/
3337	+
3338	+
3339	+	/* loop over scans
3340	+	empty of */
3341	+	for (jj=0;jj<=num_scans;jj++){
3342	+
3343	+	/*printf("scale %i %i %i %f ",j,jj,num_scans,scale_image_scans[j*(num_scans+1)+jj]); */
3344	+
3345	+
3346	+	/* copy luminance value into big image and remove glare sources*/
3347	+	for (x = 0; x < pict_get_xsize(pcoeff); x++) {
3348	+	for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3349	+	xmap=x_temp_img[j]+x;
3350	+	ymap=y_temp_img[j]+y;
3351	+	if (xmap <0) { xmap=0;}
3352	+	if (ymap <0) { ymap=0;}
3353	+
3354	+	pict_get_color(p, xmap, ymap)[RED] = scale_image_scans[j*(num_scans+1)+jj]*pict_get_color(pcoeff, x, y)[RED];
3355	+	pict_get_color(p, xmap, ymap)[GRN] = scale_image_scans[j*(num_scans+1)+jj]*pict_get_color(pcoeff, x, y)[GRN];
3356	+	pict_get_color(p, xmap, ymap)[BLU] = scale_image_scans[j*(num_scans+1)+jj]*pict_get_color(pcoeff, x, y)[BLU];
3357	+	pict_get_gsn(p, xmap, ymap) = 0;
3358	+	pict_get_pgs(p, xmap, ymap) = 0;
3359	+	}}
3360	+
3361	+
3362	+
3363	+
3364	+
3365	+	actual_igs =0;
3366	+
3367	+	/* first glare source scan: find primary glare sources */
3368	+	for (x = 0; x < pict_get_xsize(pcoeff); x++) {
3369	+	lastpixelwas_gs=0;
3370	+	/*              lastpixelwas_peak=0; */
3371	+	for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3372	+	xmap=x_temp_img[j]+x;
3373	+	ymap=y_temp_img[j]+y;
3374	+	if (pict_get_hangle(p, xmap, ymap, p->view.vdir, p->view.vup, &ang)) {
3375	+	if (pict_is_validpixel(p, xmap, ymap)) {
3376	+	act_lum = luminance(pict_get_color(p, xmap, ymap));
3377	+	if (act_lum> lum_source) {
3378	+	if (act_lum >lum_total_max) {
3379	+	lum_total_max=act_lum;
3380	+	}
3381	+
3382	+	if (lastpixelwas_gs==0 || search_pix <= 1.0 ) {
3383	+	actual_igs = find_near_pgs(p, xmap, ymap, max_angle, 0, igs, 1);
3384	+	}
3385	+	if (actual_igs == 0) {
3386	+	igs = igs + 1;
3387	+	pict_new_gli(p);
3388	+	pict_get_Eglare(p,igs) = 0.0;
3389	+	/*  not necessary here                                  pict_get_lum_min(p, igs) = HUGE_VAL;
3390	+	pict_get_Eglare(p,igs) = 0.0;
3391	+	pict_get_Dglare(p,igs) = 0.0;
3392	+	pict_get_z1_gsn(p,igs) = 0;
3393	+	pict_get_z2_gsn(p,igs) = 0; */
3394	+	actual_igs = igs;
3395	+
3396	+	}
3397	+	pict_get_gsn(p, xmap, ymap) = actual_igs;
3398	+	pict_get_pgs(p, xmap, ymap) = 1;
3399	+	add_pixel_to_gs(p, xmap, ymap, actual_igs);
3400	+	lastpixelwas_gs=actual_igs;
3401	+
3402	+
3403	+
3404	+	delta_E=DOT(p->view.vdir, pict_get_cached_dir(p, xmap, ymap))* pict_get_omega(p, xmap, ymap)* luminance(pict_get_color(p, xmap, ymap));
3405	+	pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
3406	+
3407	+
3408	+
3409	+
3410	+	} else {
3411	+	pict_get_pgs(p, xmap, ymap) = 0;
3412	+	lastpixelwas_gs=0;
3413	+	}
3414	+	}
3415	+	}
3416	+	}
3417	+	}
3418	+
3419	+
3420	+	/*                              here should be peak extraction  */
3421	+	i_max=igs;
3422	+	r_split = max_angle / 2.0;
3423	+	for (i = 0; i <= i_max; i++) {
3424	+
3425	+	if (pict_get_npix(p, i) > 0) {
3426	+	l_max = pict_get_lum_max(p, i);
3427	+	i_splitstart = igs + 1;
3428	+	if (l_max >= limit) {
3429	+	for (x = 0; x < pict_get_xsize(pcoeff); x++)
3430	+	for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3431	+	xmap=x_temp_img[j]+x;
3432	+	ymap=y_temp_img[j]+y;
3433	+
3434	+
3435	+	if (pict_get_hangle
3436	+	(p, xmap, ymap, p->view.vdir, p->view.vup, &ang))
3437	+	{
3438	+	if (pict_is_validpixel(p, xmap, ymap)
3439	+	&& luminance(pict_get_color(p, xmap, ymap))
3440	+	>= limit
3441	+	&& pict_get_gsn(p, xmap, ymap) == i) {
3442	+	if (i_splitstart == (igs + 1)) {
3443	+	igs = igs + 1;
3444	+	pict_new_gli(p);
3445	+	pict_get_z1_gsn(p,igs) = 0;
3446	+	pict_get_z2_gsn(p,igs) = 0;
3447	+
3448	+	pict_get_Eglare(p,igs) = 0.0;
3449	+	pict_get_Dglare(p,igs) = 0.0;
3450	+	pict_get_lum_min(p, igs) =
3451	+	99999999999999.999;
3452	+	i_split = igs;
3453	+	} else {
3454	+	i_split =
3455	+	find_split(p, xmap, ymap, r_split,
3456	+	i_splitstart, igs);
3457	+	}
3458	+	if (i_split == 0) {
3459	+	igs = igs + 1;
3460	+	pict_new_gli(p);
3461	+	pict_get_z1_gsn(p,igs) = 0;
3462	+	pict_get_z2_gsn(p,igs) = 0;
3463	+
3464	+	pict_get_Eglare(p,igs) = 0.0;
3465	+	pict_get_Dglare(p,igs) = 0.0;
3466	+	pict_get_lum_min(p, igs) =
3467	+	99999999999999.999;
3468	+	i_split = igs;
3469	+	}
3470	+	split_pixel_from_gs(p, xmap, ymap, i_split, uniform_gs, u_r, u_g , u_b);
3471	+
3472	+	}
3473	+	}
3474	+	}
3475	+
3476	+	}
3477	+	change = 1;
3478	+	while (change == 1) {
3479	+	change = 0;
3480	+	for (x = 0; x < pict_get_xsize(pcoeff); x++)
3481	+	for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3482	+	xmap=x_temp_img[j]+x;
3483	+	ymap=y_temp_img[j]+y;
3484	+	before_igs = pict_get_gsn(p, xmap, ymap);
3485	+	if (before_igs >= i_splitstart) {
3486	+	if (pict_get_hangle
3487	+	(p, xmap, ymap, p->view.vdir, p->view.vup,
3488	+	&ang)) {
3489	+	if (pict_is_validpixel(p, xmap, ymap)
3490	+	&& before_igs > 0) {
3491	+	actual_igs =
3492	+	find_near_pgs(p, xmap, ymap,
3493	+	max_angle,
3494	+	before_igs, igs,
3495	+	i_splitstart);
3496	+	if (!(actual_igs == before_igs)) {
3497	+	change = 1;
3498	+	}
3499	+	if (before_igs > 0) {
3500	+	actual_igs =
3501	+	pict_get_gsn(p, xmap, ymap);
3502	+	/*                                                                                     icol =
3503	+	setglcolor(p, x, y,
3504	+	actual_igs, uniform_gs, u_r, u_g , u_b);*/
3505	+	}
3506	+
3507	+	}
3508	+	}
3509	+	}
3510	+
3511	+	}
3512	+	}
3513	+
3514	+
3515	+	}
3516	+	}
3517	+
3518	+	/*                              end peak extraction  */
3519	+
3520	+
3521	+	/* calculation of direct vertical illuminance for th multi-image-mode */
3522	+
3523	+
3524	+	for (x = 0; x < pict_get_xsize(pcoeff); x++)
3525	+	for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3526	+	xmap=x_temp_img[j]+x;
3527	+	ymap=y_temp_img[j]+y;
3528	+	if (pict_get_hangle(p, xmap, ymap, p->view.vdir, p->view.vup, &ang)) {
3529	+	if (pict_is_validpixel(p, xmap, ymap)) {
3530	+	if (pict_get_gsn(p, xmap, ymap) > 0) {
3531	+	actual_igs = pict_get_gsn(p, xmap, ymap);
3532	+	delta_E=DOT(p->view.vdir, pict_get_cached_dir(p, xmap, ymap))* pict_get_omega(p, xmap, ymap)* luminance(pict_get_color(p, xmap, ymap));
3533	+	pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
3534	+	}
3535	+	}
3536	+	}
3537	+	}
3538	+
3539	+
3540	+
3541	+
3542	+
3543	+
3544	+
3545	+
3546	+	i = 0;
3547	+	for (x = 0; x <= igs; x++) {
3548	+	if (pict_get_npix(p, x) > 0) {
3549	+	i = i + 1;
3550	+	}}
3551	+	no_glaresources=i;
3552	+
3553	+	/*
3554	+
3555	+	sprintf(file_out, "%s%i%s","ray2/img_",j,".hdr");
3556	+	pict_write(p, file_out);
3557	+	*/
3558	+	printf("%i ",no_glaresources);
3559	+	i = 0;
3560	+	for (x = 0; x <= igs; x++) {
3561	+	if (pict_get_npix(p, x) > 0) {
3562	+	i = i + 1;
3563	+	pict_get_sigma(p, pict_get_av_posx(p, x), pict_get_av_posy(p, x), p->view.vdir, p->view.vup, &sigma);
3564	+
3565	+	x2=pict_get_av_posx(p, x);
3566	+	y2=pict_get_av_posy(p, x);
3567	+	printf("%f %.10f %f %f %f %f %f ",      pict_get_av_lum(p, x), pict_get_av_omega(p, x), get_posindex(p, pict_get_av_posx(p, x), pict_get_av_posy(p, x),
3568	+	posindex_2),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) );
3569	+	}
3570	+	pict_get_npix(p, x)=0;
3571	+	pict_get_av_lum(p, x)=0;
3572	+	pict_get_av_posy(p, x)=0;
3573	+	pict_get_av_posx(p, x)=0;
3574	+	pict_get_av_omega(p, x)=0;
3575	+	}
3576	+	printf("\n");
3577	+
3578	+
3579	+	/* empty big image and remove glare sources*/
3580	+	for (x = 0; x < pict_get_xsize(pcoeff); x++) {
3581	+	for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3582	+	xmap=x_temp_img[j]+x;
3583	+	ymap=y_temp_img[j]+y;
3584	+	pict_get_color(p, xmap, ymap)[RED] = 0;
3585	+	pict_get_color(p, xmap, ymap)[GRN] = 0;
3586	+	pict_get_color(p, xmap, ymap)[BLU] = 0;
3587	+	pict_get_gsn(p, xmap, ymap) = 0;
3588	+	pict_get_pgs(p, xmap, ymap) = 0;
3589	+	}}
3590	+	igs=0;
3591	+
3592	+
3593	+	}
3594	+
3595	+
3596	+	}
3597	+
3598	+	}
3599	+
3600	+	/* end multi-image-mode */
3601
3602		/*printf("lowlight=%f\n", low_light_corr); */
3603

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)