ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/evalglare.c
(Generate patch)

Comparing ray/src/util/evalglare.c (file contents):
Revision 2.4 by greg, Thu Jul 28 16:46:10 2016 UTC vs.
Revision 2.12 by greg, Tue Jun 3 21:31:51 2025 UTC

# Line 1 | Line 1
1   #ifndef lint
2   static const char RCSid[] = "$Id$";
3   #endif
4 < /* EVALGLARE V1.29
4 > /* EVALGLARE V2.10
5   * Evalglare Software License, Version 2.0
6   *
7 < * Copyright (c) 1995 - 2016 Fraunhofer ISE, EPFL.
7 > * Copyright (c) 1995 - 2020 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   #define EVALGLARE
361   #define PROGNAME "evalglare"
362 < #define VERSION "1.30 release 29.07.2016 by EPFL, J.Wienold"
362 > #define VERSION "2.10 release 25.06.2020 by EPFL, J.Wienold"
363   #define RELEASENAME PROGNAME " " VERSION
364  
365  
# Line 323 | Line 370 | changed masking threshold to 0.05 cd/m2
370   #include "platform.h"
371   #include "muc_randvar.h"
372  
326 – char *progname;
327 –
373   /* subroutine to add a pixel to a glare source */
374   void add_pixel_to_gs(pict * p, int x, int y, int gsn)
375   {
# Line 723 | Line 768 | void add_secondary_gs(pict * p, int x, int y, float r,
768   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)
769   {
770          int old_gsn, icol;
771 <        double old_av_posx, old_av_posy, old_av_lum, old_omega, act_omega,
771 >        double old_av_posx, old_av_posy, old_av_lum, old_omega, act_omega, delta_E,
772                  new_omega, act_lum;
773  
774  
# Line 735 | Line 780 | void split_pixel_from_gs(pict * p, int x, int y, int n
780          old_av_posx = pict_get_av_posx(p, old_gsn);
781          old_av_posy = pict_get_av_posy(p, old_gsn);
782          old_omega = pict_get_av_omega(p, old_gsn);
783 +        
784 +        
785 +        
786  
787          new_omega = old_omega - act_omega;
788          pict_get_av_omega(p, old_gsn) = new_omega;
# Line 752 | Line 800 | void split_pixel_from_gs(pict * p, int x, int y, int n
800  
801          add_pixel_to_gs(p, x, y, new_gsn);
802  
803 +
804 +
805 +
806   /* color pixel of new gs */
807  
808   /*      icol = setglcolor(p, x, y, new_gsn, uniform_gs, u_r, u_g , u_b); */
# Line 1164 | Line 1215 | float get_vcp(float dgr )
1215   {
1216          float vcp;
1217  
1218 <        vcp = 50 * erf((6.347 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1218 >        vcp = 50 * erf((6.374 - 1.3227 * log(dgr)) / 1.414213562373) + 50;
1219          if (dgr > 750) {
1220                  vcp = 0;
1221          }
# Line 1199 | Line 1250 | float get_ugr(pict * p, double lum_backg, int igs, int
1250                  }
1251          }
1252          ugr = 8 * log10(0.25 / lum_backg * sum_glare);
1253 <
1253 >        if (sum_glare==0) {
1254 >        ugr=0.0;
1255 >        }
1256 >        if (lum_backg<=0) {
1257 >        ugr=-99.0;
1258 >        }
1259 >        
1260          return ugr;
1261  
1262   }
# Line 1329 | Line 1386 | float get_cgi(pict * p, double E_v, double E_v_dir, in
1386          return cgi;
1387   }      
1388  
1389 < /* 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! */
1390 < float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av)
1389 >
1390 >
1391 > /* 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! */
1392 > float get_pgsv_con(double E_v, double E_mask,double omega_mask,double lum_mask_av, double Lavg)
1393   {
1394 <        float pgsv;
1394 >        float pgsv_con;
1395          double Lb;
1396  
1397 <        Lb = (E_v-E_mask)/1.414213562373;
1397 > /*        Lb = (E_v-E_mask)/3.14159265359;  */
1398 > /*        Lb = (2*E_v-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask); */
1399 >          Lb = (2*3.14159265359*Lavg-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask);
1400  
1340 –        pgsv =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1401  
1402 +        pgsv_con =3.2*log10(lum_mask_av)-0.64*log10(omega_mask)+(0.79*log10(omega_mask)-0.61)*log10(Lb)-8.2 ;
1403  
1404 <        return pgsv;
1404 >
1405 >        return pgsv_con;
1406   }
1407  
1408   /* 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 1410 | float get_pgsv_sat(double E_v)
1410   {
1411          float pgsv_sat;
1412  
1413 <        pgsv_sat =3.3-(0.57+3.3)/pow((1+E_v/1.414213562373/1250),1.7);
1413 >        pgsv_sat =3.3-(0.57+3.3)/(1+pow(E_v/3.14159265359/1250,1.7));
1414  
1415  
1416          return pgsv_sat;
1417   }
1418  
1419 + /* 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! */
1420  
1421 + float get_pgsv(double E_v, double E_mask,double omega_mask,double lum_mask_av,double Ltask, double Lavg)
1422 + {
1423 +        float pgsv;
1424 +        double Lb;
1425  
1426 + /*        Lb = (E_v-E_mask)/3.14159265359;  */
1427 + /*        Lb = (2*E_v-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask); */
1428 +          Lb = (2*3.14159265359*Lavg-lum_mask_av*omega_mask)/(2*3.14159265359-omega_mask);
1429 +        
1430 +        if (Lb==0.0 ) {
1431 +               fprintf(stderr,  " warning: Background luminance is 0 or masking area = full image! pgsv cannot be calculated (set to -99)!!\n");
1432 +                pgsv=-99;
1433 +                        }else{
1434 +                if ( (lum_mask_av/Lb) > (E_v/(3.14159265359*Ltask))) {
1435 +                        pgsv=get_pgsv_con(E_v,E_mask,omega_mask,lum_mask_av, Lavg);
1436 +                }else{
1437 +                        pgsv=get_pgsv_sat(E_v)  ;
1438 +                        }}
1439 +        return pgsv;
1440  
1441 + }
1442 +
1443 +
1444 +
1445   #ifdef  EVALGLARE
1446  
1447  
# Line 1366 | Line 1451 | float get_pgsv_sat(double E_v)
1451  
1452   int main(int argc, char **argv)
1453   {
1454 <        #define CLINEMAX 4095 /* memory allocated for command line string */
1454 >        #define CLINEMAX 999999999 /* memory allocated for command line string */
1455          pict *p = pict_create();
1456          pict *pm = pict_create();
1457 <        int     skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1458 <                ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,
1459 <                i_split, posindex_2, task_lum, checkfile, rval, i, i_max, x, y,x2,y2,x_zone,y_zone, i_z1, i_z2,
1457 >        pict *pcoeff = pict_create();
1458 >        int     lowlight,skip_second_scan,calcfast,age_corr,cut_view,cut_view_type,calc_vill, output, detail_out2, x1,y1, fill, yfillmax, yfillmin,
1459 >                ext_vill, set_lum_max, set_lum_max2, img_corr,x_disk,y_disk,task_color, i_splitstart,zones,act_gsn,splitgs,j,multi_image_mode,
1460 >                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,
1461                  igs, actual_igs, lastpixelwas_gs, icol, xt, yt, change,checkpixels, before_igs, sgs, splithigh,uniform_gs,x_max, y_max,y_mid,
1462 <                detail_out, posindex_picture, non_cos_lb, rx, ry, rmx,rmy,apply_disability,band_calc,band_color,masking,i_mask,no_glaresources,force;
1463 <        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,
1464 <                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,
1465 <                search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,
1466 <                omegat, sang, E_v, E_v2, E_v_dir, avlum, act_lum, ang, angle_z1, angle_z2,per_95_band,per_75_band,pos,
1462 >                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;
1463 >        double  LUM_replace,lum_total_max,age_corr_factor,age,dgp_ext,dgp,low_light_corr,omega_cos_contr, setvalue, lum_ideal, E_v_contr, sigma,om,delta_E,
1464 >                E_vl_ext, lum_max, new_lum_max, r_center, ugp, ugr_exp, dgi_mod,lum_a, E_v_mask,angle_disk,dist,n_corner_px,zero_corner_px,
1465 >                search_pix, a1, a2, a3, a4, a5, c3, c1, c2, r_split, max_angle,r_actual,lum_actual,dir_ill,
1466 >                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,
1467                  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,
1468                  lum, lum_source,teta,Lveil_cie,Lveil_cie_sum,disability_thresh,u_r,u_g,u_b,band_angle,band_avlum,
1469                  lum_mask[1],lum_mask_av,lum_mask_std[1],lum_mask_median[1],omega_mask,bbox[2],
# Line 1385 | Line 1471 | int main(int argc, char **argv)
1471                  lum_z1[1],lum_z1_av,lum_z1_std[1],lum_z1_median[1],omega_z1,bbox_z1[2],
1472                  lum_z2[1],lum_z2_av,lum_z2_std[1],lum_z2_median[1],omega_z2,bbox_z2[2],
1473                  lum_pos[1],lum_nopos_median[1],lum_pos_median[1],lum_pos2_median[1],lum_pos_mean,lum_pos2_mean;
1474 <        float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,
1474 >        float lum_task, lum_thres, dgi,  vcp, cgi, ugr, limit, dgr,pgsv ,pgsv_sat,pgsv_con,
1475                  abs_max, Lveil;
1476 <        char maskfile[500],file_out[500], file_out2[500], version[500];
1476 >        char maskfile[500],file_out[500], file_out2[500], version[500],correction_type[500];
1477          char *cline;
1478 +        char** temp_image_name;
1479 +        int *x_temp_img, *y_temp_img;
1480          VIEW userview = STDVIEW;
1481          int gotuserview = 0;
1482 +        
1483          struct muc_rvar* s_mask;
1484          s_mask = muc_rvar_create();
1485          muc_rvar_set_dim(s_mask, 1);
# Line 1425 | Line 1514 | int main(int argc, char **argv)
1514          muc_rvar_clear(s_posweight2);
1515  
1516          /*set required user view parameters to invalid values*/
1517 +        lowlight=1;
1518 +        multi_image_mode=0;
1519 +        lastpixelwas_peak=0;    
1520 +        num_images=0;        
1521 +        dir_ill=0.0;
1522          delta_E=0.0;
1523          no_glaresources=0;
1524          n_corner_px=0;
# Line 1446 | Line 1540 | int main(int argc, char **argv)
1540          lum_band_av = 0.0;
1541          omega_band = 0.0;
1542          pgsv = 0.0 ;
1543 +        pgsv_con = 0.0 ;
1544          pgsv_sat = 0.0 ;
1545          E_v_mask = 0.0;
1546 +        Ez1 = 0.0;
1547 +        Ez2 = 0.0;
1548          lum_z1_av = 0.0;
1549          omega_z1 = 0.0;
1550          lum_z2_av = 0.0;
# Line 1487 | Line 1584 | int main(int argc, char **argv)
1584          omega_cos_contr = 0.0;
1585          lum_ideal = 0.0;
1586          max_angle = 0.2;
1587 <        lum_thres = 5.0;
1587 >        lum_thres = 2000.0;
1588 >        lum_task = 0.0;
1589          task_lum = 0;
1590          sgs = 0;
1591          splithigh = 1;
# Line 1505 | Line 1603 | int main(int argc, char **argv)
1603          c1 = 5.87e-05;
1604          c2 = 0.092;
1605          c3 = 0.159;
1606 <        non_cos_lb = 1;
1606 >        non_cos_lb = 0;
1607          posindex_2 = 0;
1608          task_color = 0;
1609          limit = 50000.0;
# Line 1513 | Line 1611 | int main(int argc, char **argv)
1611          set_lum_max2 = 0;
1612          img_corr=0;
1613          abs_max = 0;
1614 <        progname = argv[0];
1614 >        fixargv0(argv[0]);
1615          E_v_contr = 0.0;
1616          strcpy(version, "1.19 release 09.12.2015 by J.Wienold");
1617          low_light_corr=1.0;
# Line 1527 | Line 1625 | int main(int argc, char **argv)
1625          omega_mask=0.0;
1626          i_mask=0;
1627          actual_igs=0;
1628 +        LUM_replace=0;
1629 +        thres_activate=0;
1630   /* command line for output picture*/
1631  
1632 <        cline = (char *) malloc(CLINEMAX+1);
1632 >        cline = (char *) malloc(CLINEMAX+100);
1633          cline[0] = '\0';
1634          for (i = 0; i < argc; i++) {
1635   /*       fprintf(stderr, "%d %d \n",i,strlen(argv[i]));*/
# Line 1577 | Line 1677 | int main(int argc, char **argv)
1677                          break;
1678                  case 'b':
1679                          lum_thres = atof(argv[++i]);
1680 +                        lum_source =lum_thres;
1681 +                        thres_activate = 1;
1682                          break;
1683                  case 'c':
1684                          checkfile = 1;
# Line 1665 | Line 1767 | int main(int argc, char **argv)
1767                          strcpy(file_out2, argv[++i]);
1768   /*                      printf("max lum set to %f\n",new_lum_max);*/
1769                          break;
1770 +                case 'O':
1771 +                        img_corr = 1;
1772 +                        set_lum_max2 = 3;
1773 +                        x_disk = atoi(argv[++i]);
1774 +                        y_disk = atoi(argv[++i]);
1775 +                        angle_disk = atof(argv[++i]);
1776 +                        LUM_replace = atof(argv[++i]);
1777 +                        strcpy(file_out2, argv[++i]);
1778 + /*                      printf("max lum set to %f\n",new_lum_max);*/
1779 +                        break;
1780  
1781 <                case 'n':
1781 >
1782 > /* deactivated          case 'n':
1783                          non_cos_lb = 0;
1784                          break;
1785 + */
1786 +                case 'q':
1787 +                        non_cos_lb = atoi(argv[++i]);
1788 +                        break;
1789  
1790                  case 't':
1791                          task_lum = 1;
# Line 1733 | Line 1850 | int main(int argc, char **argv)
1850                          /*case 'v':
1851                          printf("evalglare  %s \n",version);
1852                          exit(1); */
1853 +                case 'C':
1854 +                        strcpy(correction_type,argv[++i]);
1855 +                        
1856 +                        if (!strcmp(correction_type,"l-")  ){
1857 +                /*      printf("low light off!\n"); */
1858 +                                                                                        lowlight = 0; }
1859 +                        if (!strcmp(correction_type,"l+")  ){
1860 +                /*      printf("low light on!\n"); */
1861 +                                                                                        lowlight = 1; }
1862 +                        if (!strcmp(correction_type,"0")  ){
1863 +                /*      printf("all corrections off!\n"); */
1864 +                                                                                        lowlight = 0; }
1865 +                        
1866 +                        break;
1867  
1868 +                        /*case 'v':
1869 +                        printf("evalglare  %s \n",version);
1870 +                        exit(1); */
1871 +
1872                  case '1':
1873                          output = 1;
1874                          break;
1875 <
1875 >                case '2':
1876 >                        output = 2;
1877 >                        dir_ill = atof(argv[++i]);
1878 >                        break;
1879 >                case '3':
1880 >                        output = 3;
1881 >                        break;
1882 >                case '4':
1883 >                        lowlight = 0;
1884 >                        break;
1885 >                case 'Q':
1886 >                        multi_image_mode=1;
1887 >                        output= 3;                      
1888 >                        calcfast=1;
1889 >                        num_images =atoi(argv[++i]);
1890 >                        temp_image_name = malloc(sizeof(char*)*num_images);
1891 >                        
1892 >                        x_temp_img=(int *) malloc(sizeof(int) * num_images);
1893 >                        y_temp_img=(int *) malloc(sizeof(int) * num_images);
1894 >                        
1895 >                        
1896 >        /* iterate through all images and allocate 256 characters to each: */
1897 >                        for (j = 0; j < num_images; j++) {
1898 >                                temp_image_name[j] = malloc(256*sizeof(char));
1899 >                                strcpy(temp_image_name[j], argv[++i]);
1900 >                                x_temp_img[j] = atoi(argv[++i]);
1901 >                                y_temp_img[j] = atoi(argv[++i]);
1902 >                        }
1903 >                
1904 >                
1905 >                        break;
1906                  case 'v':
1907                          if (argv[i][2] == '\0') {
1908                               printf("%s \n",RELEASENAME);                              
# Line 1766 | Line 1931 | int main(int argc, char **argv)
1931                  }
1932          }
1933  
1934 + /* set multiplier for task method to 5, if not specified */
1935 +
1936 + if ( task_lum == 1 && thres_activate == 0){
1937 +                lum_thres = 5.0;
1938 + }
1939   /*fast calculation, if gendgp_profile is used: No Vertical illuminance calculation, only dgp is calculated*/
1940  
1941 < if (output == 1 && ext_vill == 1) {
1941 > if (output == 1 && ext_vill == 1 ) {
1942                         calcfast=1;
1943                         }
1944 +                      
1945 + if (output == 2 && ext_vill == 1 ) {
1946 +                       calcfast=2;
1947 +                       }
1948 +                      
1949   /*masking and zoning cannot be applied at the same time*/
1950  
1951   if (masking ==1 && zones >0) {
# Line 1831 | Line 2006 | if (masking ==1 && zones >0) {
2006  
2007          if (masking == 1) {
2008  
2009 <                if (!pict_get_xsize(p)==pict_get_xsize(pm) || !pict_get_ysize(p)==pict_get_ysize(pm)) {
2009 >                if (pict_get_xsize(p)!=pict_get_xsize(pm) || pict_get_ysize(p)!=pict_get_ysize(pm)) {
2010                  fprintf(stderr, "error: masking image has other resolution than main image ! \n");
2011                  fprintf(stderr, "size must be identical \n");
2012                  printf("resolution main image : %dx%d\n",pict_get_xsize(p),pict_get_ysize(p));
# Line 1866 | Line 2041 | if (masking ==1 && zones >0) {
2041  
2042                  }
2043          }
2044 <
2044 >        
2045 >
2046   /* Check task position  */
2047  
2048          if (task_lum == 1) {
# Line 1890 | Line 2066 | if (masking ==1 && zones >0) {
2066          pict_get_z1_gsn(p,igs) = 0;
2067          pict_get_z2_gsn(p,igs) = 0;
2068  
2069 + if (multi_image_mode<1) {
2070  
2071 +
2072   /* cut out GUTH field of view and exit without glare evaluation */
2073   if (cut_view==2) {
2074          if (cut_view_type==1) {
# Line 2059 | Line 2237 | if (cut_view==2) {
2237          lum_pos_mean= lum_pos_mean/sang;
2238          lum_pos2_mean= lum_pos2_mean/sang;
2239  
2240 <        if (set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0) {
2240 >        if ((set_lum_max2 >= 1 && E_v_contr > 0 && (E_vl_ext - E_v) > 0 ) || set_lum_max2==3) {
2241  
2242 +                if (set_lum_max2<3){
2243                  lum_ideal = (E_vl_ext - E_v + E_v_contr) / omega_cos_contr;
2244                  if (set_lum_max2 == 2 && lum_ideal >= 2e9) {
2245                  printf("warning! luminance of replacement pixels would be larger than 2e9 cd/m2. Value set to 2e9cd/m2!\n") ;
# Line 2071 | Line 2250 | if (cut_view==2) {
2250                  }
2251                  printf("change luminance values!! lum_ideal,setvalue,E_vl_ext,E_v,E_v_contr %f  %f %f %f %f\n",
2252                           lum_ideal, setvalue, E_vl_ext, E_v, E_v_contr);
2253 +                          }else{setvalue=LUM_replace;
2254 +                         }
2255  
2256              
2257                  for (x = 0; x < pict_get_xsize(p); x++)
# Line 2090 | Line 2271 | if (cut_view==2) {
2271                                                          pict_get_color(p, x, y)[BLU] =
2272                                                                  setvalue / 179.0;
2273  
2274 <                                                }else{ if(set_lum_max2 ==2 ) {
2274 >                                                }else{ if(set_lum_max2 >1 ) {
2275                                                          r_actual =acos(DOT(pict_get_cached_dir(p, x_disk, y_disk), pict_get_cached_dir(p, x, y))) * 2;
2276                                                          if (x_disk == x && y_disk==y ) r_actual=0.0;
2277  
# Line 2103 | Line 2284 | if (cut_view==2) {
2284                                                          pict_get_color(p, x, y)[BLU] =
2285                                                                  setvalue / 179.0;
2286                                                        
2287 <                                                       }
2107 <                                                                
2108 <                                                
2287 >                                                       }                                                
2288                                                  }
2289                                                  }
2290                                          }
# Line 2178 | Line 2357 | if (cut_view==1) {
2357  
2358   /* first glare source scan: find primary glare sources */
2359          for (x = 0; x < pict_get_xsize(p); x++) {
2360 < /*                lastpixelwas_gs=0; */
2360 >                lastpixelwas_gs=0;
2361 > /*              lastpixelwas_peak=0; */
2362                  for (y = 0; y < pict_get_ysize(p); y++) {
2363                          if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
2364                                  if (pict_is_validpixel(p, x, y)) {
# Line 2188 | Line 2368 | if (cut_view==1) {
2368                                                                               lum_total_max=act_lum;
2369                                                                                 }
2370   /* speed improvement first scan: when last pixel was glare source, then use this glare source number instead of searching.
2371 <   has been deactivated with v1.25
2371 >   has been deactivated with v1.25, reactivated with v2.10 */
2372                        
2373 <                                                if (lastpixelwas_gs==0 || search_pix <= 1.0 ) { */
2373 >                                                if (lastpixelwas_gs==0 || search_pix <= 1.0 ) {
2374                                                  actual_igs = find_near_pgs(p, x, y, max_angle, 0, igs, 1);
2375 < /*  }*/
2375 >  }
2376                                                  if (actual_igs == 0) {
2377                                                          igs = igs + 1;
2378                                                          pict_new_gli(p);
# Line 2208 | Line 2388 | if (cut_view==1) {
2388                                                  pict_get_gsn(p, x, y) = actual_igs;
2389                                                  pict_get_pgs(p, x, y) = 1;
2390                                                  add_pixel_to_gs(p, x, y, actual_igs);
2391 < /*                                                lastpixelwas_gs=actual_igs; */
2391 >                                                lastpixelwas_gs=actual_igs;
2392  
2393                                          } else {
2394                                                  pict_get_pgs(p, x, y) = 0;
2395 < /*                                               lastpixelwas_gs=0;*/
2395 >                                                lastpixelwas_gs=0;
2396                                          }
2397                                  }
2398                          }
# Line 2221 | Line 2401 | if (cut_view==1) {
2401   /*      pict_write(p,"firstscan.pic");   */
2402  
2403  
2404 < if (calcfast == 1 || search_pix <= 1.0) {
2404 >
2405 >
2406 > if (calcfast ==1 || search_pix <= 1.0 || calcfast == 2 ) {
2407     skip_second_scan=1;
2408     }
2409 +  
2410  
2411   /* second glare source scan: combine glare sources facing each other */
2412          change = 1;
# Line 2304 | Line 2487 | if (calcfast == 1 || search_pix <= 1.0) {
2487  
2488   /* extract extremes from glare sources to extra glare source */
2489          if (splithigh == 1 && lum_total_max>limit) {
2490 + /*             fprintf(stderr,  " split of glare source!\n"); */
2491  
2492                  r_split = max_angle / 2.0;
2493                  for (i = 0; i <= i_max; i++) {
# Line 2398 | Line 2582 | if (calcfast == 1 || search_pix <= 1.0) {
2582  
2583   /* calculation of direct vertical illuminance for CGI and for disability glare, coloring glare sources*/
2584  
2585 <        if (calcfast == 0) {
2585 >        if (calcfast == 0 || calcfast == 2) {
2586          for (x = 0; x < pict_get_xsize(p); x++)
2587                  for (y = 0; y < pict_get_ysize(p); y++) {
2588                          if (pict_get_hangle(p, x, y, p->view.vdir, p->view.vup, &ang)) {
# Line 2486 | Line 2670 | if (calcfast == 1 || search_pix <= 1.0) {
2670                          lum_backg = lum_backg_cos;
2671          }
2672  
2673 +        if (non_cos_lb == 2) {
2674 +                        lum_backg = E_v / 3.1415927;
2675 +        }
2676 +
2677 +
2678   /* file writing NOT here
2679          if (checkfile == 1) {
2680                  pict_write(p, file_out);
# Line 2495 | Line 2684 | if (calcfast == 1 || search_pix <= 1.0) {
2684   /* print detailed output */
2685          
2686          
2498 –        if (detail_out == 1) {
2687  
2688   /* masking */
2689  
# Line 2538 | Line 2726 | if (calcfast == 1 || search_pix <= 1.0) {
2726                  muc_rvar_get_median(s_mask,lum_mask_median);
2727                  muc_rvar_get_bounding_box(s_mask,bbox);
2728   /* PSGV only why masking of window is applied! */
2729 <                 pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av);
2729 >
2730 >        
2731 >        if (task_lum == 0 || lum_task == 0.0 ) {
2732 >                        fprintf(stderr, " warning: Task area not set or task luminance=0 ! pgsv cannot be calculated (set to -99)!!\n");
2733 >                        pgsv = -99;
2734 >                } else {
2735 >                        pgsv = get_pgsv(E_v, E_v_mask, omega_mask, lum_mask_av,lum_task,avlum);
2736 >                        }
2737 >
2738 >                 pgsv_con = get_pgsv_con(E_v, E_v_mask, omega_mask, lum_mask_av,avlum);
2739                   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 );
2740  
2741 +        if (detail_out == 1) {
2742 +
2743 +                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 );
2744 +
2745 +        }      
2746                  
2546 –                
2747          }
2748  
2749   /* zones */
# Line 2568 | Line 2768 | if (calcfast == 1 || search_pix <= 1.0) {
2768                                                    muc_rvar_add_sample(s_z1, lum_z1);
2769                                                    omega_z1 += pict_get_omega(p, x, y);
2770                                                    lum_z1_av += pict_get_omega(p, x, y)* lum_actual;
2771 +                                                  Ez1 += DOT(p->view.vdir, pict_get_cached_dir(p, x, y))* pict_get_omega(p, x, y)* lum_actual;
2772 +
2773                                                    setglcolor(p,x,y,1,1 , 0.66, 0.01 ,0.33);
2774   /*check if separation gsn already exist */
2775  
# Line 2584 | Line 2786 | if (calcfast == 1 || search_pix <= 1.0) {
2786                                                      splitgs=(int)(pict_get_z1_gsn(p,act_gsn));
2787                                          /*          printf("splitgs%i \n",splitgs);       */              
2788                                                      split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2789 +                                        /* move direct illuminance contribution into  zone -value           */
2790 +                                                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));
2791 +                                                pict_get_Eglare(p,act_gsn ) = pict_get_Eglare(p,act_gsn ) - delta_E;
2792 +                                                pict_get_Eglare(p,igs ) = pict_get_Eglare(p,igs ) + delta_E;
2793 +            
2794 +                                                    
2795                                                  }                                
2796                                                    }
2797   /*zone2 */
# Line 2595 | Line 2803 | if (calcfast == 1 || search_pix <= 1.0) {
2803                                                    muc_rvar_add_sample(s_z2, lum_z2);
2804                                                    omega_z2 +=   pict_get_omega(p, x, y);
2805                                                    lum_z2_av += pict_get_omega(p, x, y)* lum_actual;
2806 +                                                  Ez2 += DOT(p->view.vdir, pict_get_cached_dir(p, x, y))* pict_get_omega(p, x, y)* lum_actual;
2807                                                    setglcolor(p,x,y,1,1 , 0.65, 0.33 ,0.02);
2808   /*                                                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));
2809   */                                                if (act_gsn > 0){
# Line 2609 | Line 2818 | if (calcfast == 1 || search_pix <= 1.0) {
2818                                                  splitgs=(int)(pict_get_z2_gsn(p,act_gsn));
2819   /*                                              printf("splitgs %i \n",splitgs);*/                              
2820                                                      split_pixel_from_gs(p, x, y, splitgs, uniform_gs, u_r, u_g , u_b);
2821 +                                        /* move direct illuminance contribution into  zone -value           */
2822 +                                                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));
2823 +                                                pict_get_Eglare(p,act_gsn ) = pict_get_Eglare(p,act_gsn ) - delta_E;
2824 +                                                pict_get_Eglare(p,igs ) = pict_get_Eglare(p,igs ) + delta_E;
2825 +
2826                                             }
2827                                  }
2828  
# Line 2633 | Line 2847 | if (calcfast == 1 || search_pix <= 1.0) {
2847                  per_95_z1=lum_z1_median[0];
2848                  muc_rvar_get_median(s_z1,lum_z1_median);
2849                  muc_rvar_get_bounding_box(s_z1,bbox_z1);
2850 <
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] );
2850 >        if (detail_out == 1) {
2851  
2852 +                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: %f %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],Ez1 );
2853 +
2854                 if (zones == 2 ) {
2855  
2856 <                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] );
2857 < }            
2856 >                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,Ez1:  %f %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],Ez2 );
2857 > } }            
2858                  
2859          }
2860  
# Line 2651 | Line 2866 | if (calcfast == 1 || search_pix <= 1.0) {
2866                          }
2867                  }
2868                  no_glaresources=i;
2869 <
2869 > /*printf("%i",no_glaresources );*/
2870   /* glare sources */
2871 +        if (detail_out == 1 && output != 3) {
2872 +
2873                  printf
2874                          ("%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",
2875                           i);
# Line 2697 | Line 2914 | if (calcfast == 1 || search_pix <= 1.0) {
2914                  }
2915          }
2916  
2917 + if ( output != 3) {
2918  
2701 –
2919   /* calculation of indicees */
2920  
2921   /* check vertical illuminance range */
# Line 2711 | Line 2928 | if (calcfast == 1 || search_pix <= 1.0) {
2928          dgp =
2929                  get_dgp(p, E_v2, igs, a1, a2, a3, a4, a5, c1, c2, c3, posindex_2);
2930   /* low light correction */
2931 +     if (lowlight ==1) {
2932         if (E_v < 1000) {
2933         low_light_corr=1.0*exp(0.024*E_v-4)/(1+exp(0.024*E_v-4));} else {low_light_corr=1.0 ;}
2934         dgp =low_light_corr*dgp;
2935 <      
2935 >       }
2936   /* age correction */
2937        
2938          if (age_corr == 1) {
# Line 2817 | Line 3035 | if (calcfast == 0) {
3035                                  if (E_vl_ext < 1000) {
3036                                  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 ;}
3037                                  dgp =low_light_corr*dgp;
3038 <                                dgp =age_corr_factor*dgp;
3039 <                printf("%f\n", dgp);
3038 >
3039 >                     if (calcfast == 2) {
3040 >                    
3041 >                         lum_backg_cos=(E_vl_ext-dir_ill)/3.1415927;
3042 >                         ugr = get_ugr(p, lum_backg_cos, igs, posindex_2);
3043 >                         printf("%f %f \n", dgp,ugr);
3044 >                     }else{      
3045 >                         printf("%f\n", dgp);
3046 >                }
3047          }
3048 + }
3049  
3050 + }else{
3051 + /* only multiimagemode */
3052 +
3053 +
3054 +                       for (j = 0; j < num_images; j++) {
3055 +
3056 +                                
3057 + /* loop over temporal images */
3058 +
3059 + pict_read(pcoeff,temp_image_name[j] );
3060 +
3061 + /*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));
3062 + */
3063 +
3064 + /* copy luminance value into big image and remove glare sources*/
3065 +        for (x = 0; x < pict_get_xsize(pcoeff); x++) {
3066 +                for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3067 +                        xmap=x_temp_img[j]+x-1;
3068 +                        ymap=y_temp_img[j]+y-1;
3069 +                        if (xmap <0) { xmap=0;}
3070 +                        if (ymap <0) { ymap=0;}
3071 +                        
3072 +                        pict_get_color(p, xmap, ymap)[RED] = pict_get_color(pcoeff, x, y)[RED];
3073 +                        pict_get_color(p, xmap, ymap)[GRN] = pict_get_color(pcoeff, x, y)[GRN];
3074 +                        pict_get_color(p, xmap, ymap)[BLU] = pict_get_color(pcoeff, x, y)[BLU];
3075 +                        pict_get_gsn(p, xmap, ymap) = 0;
3076 +                        pict_get_pgs(p, xmap, ymap) = 0;
3077 + }}
3078 +
3079 + actual_igs =0;
3080 +
3081 + /* first glare source scan: find primary glare sources */
3082 +        for (x = 0; x < pict_get_xsize(pcoeff); x++) {
3083 +                lastpixelwas_gs=0;
3084 + /*              lastpixelwas_peak=0; */
3085 +                for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3086 +                        xmap=x_temp_img[j]+x;
3087 +                        ymap=y_temp_img[j]+y;
3088 +                        if (pict_get_hangle(p, xmap, ymap, p->view.vdir, p->view.vup, &ang)) {
3089 +                                if (pict_is_validpixel(p, xmap, ymap)) {
3090 +                                        act_lum = luminance(pict_get_color(p, xmap, ymap));
3091 +                                        if (act_lum > lum_source) {
3092 +                                                if (act_lum >lum_total_max) {
3093 +                                                                             lum_total_max=act_lum;
3094 +                                                                               }
3095 +                      
3096 +                                                if (lastpixelwas_gs==0 || search_pix <= 1.0 ) {
3097 +                                                actual_igs = find_near_pgs(p, xmap, ymap, max_angle, 0, igs, 1);
3098 +  }
3099 +                                                if (actual_igs == 0) {
3100 +                                                        igs = igs + 1;
3101 +                                                        pict_new_gli(p);
3102 +                                                        pict_get_Eglare(p,igs) = 0.0;
3103 + /*  not necessary here                                  pict_get_lum_min(p, igs) = HUGE_VAL;
3104 +                                                        pict_get_Eglare(p,igs) = 0.0;
3105 +                                                        pict_get_Dglare(p,igs) = 0.0;
3106 +                                                        pict_get_z1_gsn(p,igs) = 0;
3107 +                                                        pict_get_z2_gsn(p,igs) = 0; */
3108 +                                                        actual_igs = igs;
3109 +                                                        
3110 +                                                }
3111 +                                                pict_get_gsn(p, xmap, ymap) = actual_igs;
3112 +                                                pict_get_pgs(p, xmap, ymap) = 1;
3113 +                                                add_pixel_to_gs(p, xmap, ymap, actual_igs);
3114 +                                                lastpixelwas_gs=actual_igs;
3115 +                                                
3116 +                                                
3117 +                                                
3118 +                                                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));
3119 +                                                pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
3120 +
3121 +                                              
3122 +                                                
3123 +
3124 +                                        } else {
3125 +                                                pict_get_pgs(p, xmap, ymap) = 0;
3126 +                                                lastpixelwas_gs=0;
3127 +                                        }
3128 +                                }
3129 +                        }
3130 +                }
3131 +             }
3132 +
3133 +
3134 + /*                              here should be peak extraction  */
3135 + i_max=igs;
3136 +                r_split = max_angle / 2.0;
3137 +                for (i = 0; i <= i_max; i++) {
3138 +
3139 +                        if (pict_get_npix(p, i) > 0) {
3140 +                                l_max = pict_get_lum_max(p, i);
3141 +                                i_splitstart = igs + 1;
3142 +                                if (l_max >= limit) {
3143 +                                        for (x = 0; x < pict_get_xsize(pcoeff); x++)
3144 +                                                for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3145 +                                                xmap=x_temp_img[j]+x;
3146 +                                                ymap=y_temp_img[j]+y;
3147 +                                                
3148 +                                                
3149 +                                                        if (pict_get_hangle
3150 +                                                                (p, xmap, ymap, p->view.vdir, p->view.vup, &ang))
3151 +                                                        {
3152 +                                                                if (pict_is_validpixel(p, xmap, ymap)
3153 +                                                                        && luminance(pict_get_color(p, xmap, ymap))
3154 +                                                                        >= limit
3155 +                                                                        && pict_get_gsn(p, xmap, ymap) == i) {
3156 +                                                                        if (i_splitstart == (igs + 1)) {
3157 +                                                                                igs = igs + 1;
3158 +                                                                                pict_new_gli(p);
3159 +                                                                                pict_get_z1_gsn(p,igs) = 0;
3160 +                                                                                pict_get_z2_gsn(p,igs) = 0;
3161 +
3162 +                                                                                pict_get_Eglare(p,igs) = 0.0;
3163 +                                                                                pict_get_Dglare(p,igs) = 0.0;
3164 +                                                                                pict_get_lum_min(p, igs) =
3165 +                                                                                        99999999999999.999;
3166 +                                                                                i_split = igs;
3167 +                                                                        } else {
3168 +                                                                                i_split =
3169 +                                                                                        find_split(p, xmap, ymap, r_split,
3170 +                                                                                                           i_splitstart, igs);
3171 +                                                                        }
3172 +                                                                        if (i_split == 0) {
3173 +                                                                                igs = igs + 1;
3174 +                                                                                pict_new_gli(p);
3175 +                                                                                pict_get_z1_gsn(p,igs) = 0;
3176 +                                                                                pict_get_z2_gsn(p,igs) = 0;
3177 +
3178 +                                                                                pict_get_Eglare(p,igs) = 0.0;
3179 +                                                                                pict_get_Dglare(p,igs) = 0.0;
3180 +                                                                                pict_get_lum_min(p, igs) =
3181 +                                                                                        99999999999999.999;
3182 +                                                                                i_split = igs;
3183 +                                                                        }
3184 +                                                                        split_pixel_from_gs(p, xmap, ymap, i_split, uniform_gs, u_r, u_g , u_b);
3185 +
3186 +                                                                }
3187 +                                                        }
3188 +                                                }
3189 +
3190 +                                }
3191 +                                change = 1;
3192 +                                while (change == 1) {
3193 +                                        change = 0;
3194 +                                        for (x = 0; x < pict_get_xsize(pcoeff); x++)
3195 +                                                for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3196 +                                                xmap=x_temp_img[j]+x;
3197 +                                                ymap=y_temp_img[j]+y;
3198 +                                                        before_igs = pict_get_gsn(p, xmap, ymap);
3199 +                                                        if (before_igs >= i_splitstart) {
3200 +                                                                if (pict_get_hangle
3201 +                                                                        (p, xmap, ymap, p->view.vdir, p->view.vup,
3202 +                                                                         &ang)) {
3203 +                                                                        if (pict_is_validpixel(p, xmap, ymap)
3204 +                                                                                && before_igs > 0) {
3205 +                                                                                actual_igs =
3206 +                                                                                        find_near_pgs(p, xmap, ymap,
3207 +                                                                                                                  max_angle,
3208 +                                                                                                                  before_igs, igs,
3209 +                                                                                                                  i_splitstart);
3210 +                                                                                if (!(actual_igs == before_igs)) {
3211 +                                                                                        change = 1;
3212 +                                                                                }
3213 +                                                                                if (before_igs > 0) {
3214 +                                                                                        actual_igs =
3215 +                                                                                                pict_get_gsn(p, xmap, ymap);
3216 + /*                                                                                     icol =
3217 +                                                                                                setglcolor(p, x, y,
3218 +                                                                                                                   actual_igs, uniform_gs, u_r, u_g , u_b);*/
3219 +                                                                                }
3220 +
3221 +                                                                        }
3222 +                                                                }
3223 +                                                        }
3224 +
3225 +                                                }
3226 +                                }
3227 +
3228 +
3229 +                        }
3230 +                }
3231 +
3232 + /*                              end peak extraction  */
3233 +
3234 +
3235 + /* calculation of direct vertical illuminance for th multi-image-mode */
3236 +
3237 +
3238 +        for (x = 0; x < pict_get_xsize(pcoeff); x++)
3239 +                for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3240 +                        xmap=x_temp_img[j]+x;
3241 +                        ymap=y_temp_img[j]+y;
3242 +                        if (pict_get_hangle(p, xmap, ymap, p->view.vdir, p->view.vup, &ang)) {
3243 +                                if (pict_is_validpixel(p, xmap, ymap)) {
3244 +                                        if (pict_get_gsn(p, xmap, ymap) > 0) {
3245 +                                                actual_igs = pict_get_gsn(p, xmap, ymap);
3246 +                                                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));
3247 +                                                pict_get_Eglare(p,actual_igs ) = pict_get_Eglare(p,actual_igs ) + delta_E;
3248 +                                        }
3249 +                                }
3250 +                        }
3251 +                }
3252 +
3253 +
3254 +
3255 +
3256 +
3257 +
3258 +
3259 +
3260 +                        i = 0;
3261 +                        for (x = 0; x <= igs; x++) {
3262 +                                if (pict_get_npix(p, x) > 0) {
3263 +                                        i = i + 1;
3264 +                                        }}
3265 + no_glaresources=i;                      
3266 +
3267 + /*
3268 +
3269 + sprintf(file_out, "%s%i%s","ray2/img_",j,".hdr");
3270 + pict_write(p, file_out);
3271 + */
3272 + printf("%i ",no_glaresources);
3273 +                        i = 0;
3274 +                        for (x = 0; x <= igs; x++) {
3275 +                                if (pict_get_npix(p, x) > 0) {
3276 +                                        i = i + 1;
3277 +                                        pict_get_sigma(p, pict_get_av_posx(p, x), pict_get_av_posy(p, x), p->view.vdir, p->view.vup, &sigma);
3278 +                                                                  
3279 +                                        x2=pict_get_av_posx(p, x);
3280 +                                        y2=pict_get_av_posy(p, x);
3281 +                                        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),
3282 +                                                                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) );
3283 +                                }
3284 + pict_get_npix(p, x)=0;
3285 + pict_get_av_lum(p, x)=0;
3286 + pict_get_av_posy(p, x)=0;
3287 + pict_get_av_posx(p, x)=0;
3288 + pict_get_av_omega(p, x)=0;
3289 +                        }
3290 + printf("\n");
3291 +
3292 +
3293 + /* empty big image and remove glare sources*/
3294 +        for (x = 0; x < pict_get_xsize(pcoeff); x++) {
3295 +                for (y = 0; y < pict_get_ysize(pcoeff); y++) {
3296 +                        xmap=x_temp_img[j]+x;
3297 +                        ymap=y_temp_img[j]+y;
3298 +                        pict_get_color(p, xmap, ymap)[RED] = 0;
3299 +                        pict_get_color(p, xmap, ymap)[GRN] = 0;
3300 +                        pict_get_color(p, xmap, ymap)[BLU] = 0;
3301 +                        pict_get_gsn(p, xmap, ymap) = 0;
3302 +                        pict_get_pgs(p, xmap, ymap) = 0;
3303 + }}
3304 + igs=0;
3305 +
3306 +
3307 +
3308 +
3309 +
3310 + }
3311 +
3312 + }
3313 +
3314 + /* end multi-image-mode */
3315  
3316   /*printf("lowlight=%f\n", low_light_corr); */
3317  

Diff Legend

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