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.5 by greg, Tue Aug 2 16:35:01 2016 UTC vs.
Revision 2.11 by greg, Tue Jun 30 15:57:30 2020 UTC

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

Diff Legend

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