Changeset 305 for trunk

Timestamp:

04/01/10 10:10:59 (3 years ago)

Author:

msl

Message:

neuer komplett überarbeiteter DOF-Rechner
*

• Betrifft alle Kameras
• Danke an den Autor rudi und allen Testern

*

• wichtigste Änderung:

+ Die mathematischen Grundlagen stammen von dofmaster.com
+ Script und OSD DOF-Berechnung erfolgen im selben Modul und liefern daher identische Ergebnisse.
+ Die Entfernung wird immer "von Linse" gemessen (entspricht CANON Entfernung bei MF). Menü-Eintrag "Entfernung von Linse" entfällt.
+ DOF-Werte werden ab Linse berechnet auch bei aktivierter Menü-Option "Benutze EXIF Motiv-Dist".
+ Besondere Behandlung von Blenden-Werten im AV- und M-Mode und von Entfernungswerten bei manuellem Fokus.
+ Außer der Fernpunktdistanz werden alle berechneten Entfernungswert gerundet. Dadurch liegen der Nahpunkt und der Fernpunkt innerhalb der akzeptablen Schärfe.
*

• Änderungen im OSD:

+ Neue Optionen im DOF-Menü "Zeige DOF-Rechner" [+Separate], [+In Misc]. Dort werden unveränderte Werte seit dem letzten erfolgreichen fokussieren (halb gedrückter Auslöser oder shoot_half) grün (gültig) angezeigt.
+ In [+In Misc] werden DOF-Werte live geändert.
+ Bei [Seperate] und [+Seperate] wurde die Überschrift in "S/NL/FL:" (Motiventfernung/Nahpunktdistanz/Fernpunktdistanz) geändert.
*

• neu in uBasic:

+ Neue Funktion get_min_stack_dist - berechnet die kleinste Entfernung zum Motiv, ab der gestackt werden sollte.
*

• Änderungen in Lua:

+ Die Funktionen get_near_limit, get_far_limit, get_dof, get_hyp_dist, get_focal_length wurden entfernt. Alte Skripte mit diesen befehlen müssen geändert werden!
+ Die neue Funktion get_dofinfo() liefert dieses Datenfeld zurück.

• BOOL hyp_valid: hyperfokale Distanz ist gültig (wird durch Blende und Brennweite beeinflusst)
• BOOL focus_valid: Entfernungswerte sind gültig (wird durch Motiventfernung und hyperfokale Distanz beeinflusst)
• INT aperture: Blendenwert [x 1000]
• INT coc: kleinster Zerstreuungskreis [x 1000 mm]
• INT focal_length: Brennweite [x 1000 mm]
• INT eff_focal_length: äquivalente 35mm Brennweite [x 1000 mm]
• INT focus: Motiventfernung [mm]
• INT near: Nahpunktdistanz [mm]
• INT far: Fernpunktdistanz [mm]
• INT dof: Schärfentiefe [mm]
• INT hyp_dist: hyperfokale Distanz [mm]
• INT min_stack_dist: kleinste, sinnvolle Stack Entfernung [mm]

• Zur deutlichen Unterscheidung erhält diese Version die Versionsnummer 1.1.0-DE.

Location:

trunk

Files:

• core/conf.c (modified) (1 diff)
• core/gui.c (modified) (5 diffs)
• core/gui_osd.c (modified) (7 diffs)
• core/gui_osd.h (modified) (1 diff)
• core/luascript.c (modified) (5 diffs)
• core/luascript.h (modified) (1 diff)
• include/conf.h (modified) (1 diff)
• include/platform.h (modified) (2 diffs)
• lib/ubasic/camera_functions.c (modified) (1 diff)
• lib/ubasic/tokenizer.c (modified) (1 diff)
• lib/ubasic/tokenizer.h (modified) (1 diff)
• lib/ubasic/ubasic.c (modified) (1 diff)
• platform/generic/shooting.c (modified) (3 diffs)
• version.inc (modified) (1 diff)

trunk/core/conf.c

@@ -278 +278 @@
     CONF_INFO(124, conf.show_osd_in_review,         CONF_DEF_VALUE, i:0, NULL),
     
-    CONF_INFO(125, conf.dof_dist_from_lens,         CONF_DEF_VALUE, i:0, NULL),
+//    CONF_INFO(125, conf.dof_dist_from_lens,         CONF_DEF_VALUE, i:0, NULL),
     
     CONF_INFO(126, conf.clear_bracket,              CONF_DEF_VALUE, i:1, NULL),

trunk/core/gui.c

@@ -484 +484 @@
       {0x5c,LANG_MENU_DOF_HYPERFOCAL_IN_MISC,       MENUITEM_BOOL,      &conf.dof_hyperfocal_in_misc},                          
       {0x5c,LANG_MENU_DOF_DEPTH_LIMIT_IN_MISC,      MENUITEM_BOOL,      &conf.dof_depth_in_misc},                       
-      {0x5c,LANG_MENU_DOF_DIST_FROM_LENS,           MENUITEM_BOOL,      &conf.dof_dist_from_lens},                            
           {0x51,LANG_MENU_BACK,                            MENUITEM_UP },
     {0}
@@ -1302 +1301 @@
 
 const char* gui_dof_show_value_enum(int change, int arg) {
-    static const char* modes[]={ "Don't", "Separate", "In Misc" };
+    static const char* modes[]={ "Don't", "Separate", "+Separate", "In Misc", "+In Misc" };
 
     conf.show_dof+=change;
@@ -2420 +2419 @@
                                   int m=mode_get()&MODE_SHOOTING_MASK;
                                   if ((m==MODE_M) || (m==MODE_AV)) 
-                                    conf.subj_dist_override_value=(int)shooting_get_hyperfocal_distance_f(shooting_get_aperture_from_av96(shooting_get_user_av96()),get_focal_length(lens_get_zoom_point()));
+                                    conf.subj_dist_override_value=(int)shooting_get_hyperfocal_distance_1e3_f(shooting_get_aperture_from_av96(shooting_get_user_av96()),get_focal_length(lens_get_zoom_point()))/1000;
                                   else conf.subj_dist_override_value=(int)shooting_get_hyperfocal_distance();           
                   shooting_set_focus(shooting_get_subject_distance_override_value(), SET_NOW);
@@ -2824 +2823 @@
            if (conf.show_dof!=DOF_DONT_SHOW) gui_osd_calc_dof();
            
-           if (conf.show_dof==DOF_SHOW_IN_DOF) gui_osd_draw_dof();  
+           if ((conf.show_dof==DOF_SHOW_IN_DOF) || (conf.show_dof==DOF_SHOW_IN_DOF_EX)) gui_osd_draw_dof();  
            
            if (conf.values_show_real_iso || conf.values_show_market_iso || conf.values_show_ev_seted || conf.values_show_ev_measured || conf.values_show_bv_measured || conf.values_show_bv_seted || conf.values_show_overexposure || conf.values_show_canon_overexposure || conf.values_show_luminance) gui_osd_calc_expo_param();                        
@@ -2833 +2832 @@
             if ((conf.show_values==SHOW_ALWAYS && mode_photo) || ((mode_video || movie_status > 1)&& conf.show_values_in_video) || ((kbd_is_key_pressed(KEY_SHOOT_HALF) || (recreview_hold==1)) && (conf.show_values==SHOW_HALF)))
                    gui_osd_draw_values(1);
-        else if  (shooting_get_common_focus_mode() && mode_photo && conf.show_values && !(conf.show_dof==DOF_SHOW_IN_DOF) )   
+        else if  (shooting_get_common_focus_mode() && mode_photo && conf.show_values && !((conf.show_dof==DOF_SHOW_IN_DOF) || (conf.show_dof==DOF_SHOW_IN_DOF_EX)))   
            gui_osd_draw_values(2);
             else if  (conf.show_values==SHOW_HALF)

trunk/core/gui_osd.c

@@ -82 +82 @@
 #endif
 
-static DOF_TYPE dof;
+DOF_TYPE dof_values;
 static EXPO_TYPE expo;
 
@@ -338 +338 @@
                         gui_grid_draw_osd(1);
                     }
-                    if (conf.show_dof == DOF_SHOW_IN_DOF) {
+                    if ((conf.show_dof == DOF_SHOW_IN_DOF) || (conf.show_dof == DOF_SHOW_IN_DOF_EX)) {
                         gui_osd_draw_dof();
                     }
@@ -858 +858 @@
 void gui_osd_calc_dof() {
     
-    int av, av_min, c_of_c, fl, v, v1, m;
-    //long lfpfl=lens_get_focus_pos_fl();
-
-#if CAM_HAS_IRIS_DIAPHRAGM
-    av=shooting_get_real_aperture();
-#else
-    av=shooting_get_min_real_aperture();
-#endif
-    fl=get_focal_length(lens_get_zoom_point()); 
-    dof.far_limit=-1.0;
-    dof.near_limit=-1.0;
-    dof.depth_of_field=-1.0;
-    dof.hyperfocal_distance=-1.0;
-    dof.subject_distance=-1.0;
-        
-    if ((av!=0) && (fl!=0)) {
-      if (conf.dof_subj_dist_as_near_limit) {
-        v1=(fl*fl);
-        dof.near_limit=shooting_get_canon_subject_distance();
-        av_min=shooting_get_min_real_aperture();
-        c_of_c=circle_of_confusion*10;
-        if ((av_min!=0) && (c_of_c!=0)) dof.hyperfocal_distance=v1/(c_of_c*av_min);
-                if ((dof.near_limit>0) && (dof.near_limit<MAX_DIST)) {
-                        v=(dof.hyperfocal_distance-dof.near_limit);
-                        m=dof.hyperfocal_distance*dof.near_limit;
-                        if ((v>0) && (m>0)) dof.subject_distance=m/v;  
-                }
-        dof.hyperfocal_distance=v1/(c_of_c*av);
-        if ((dof.subject_distance>0) && (dof.subject_distance<MAX_DIST)) {
-          v = (dof.hyperfocal_distance-dof.subject_distance);
-          m=dof.hyperfocal_distance*dof.subject_distance;
-          if ((v>0) && (m>0))  dof.far_limit=m/v;
-          dof.depth_of_field=dof.far_limit-dof.near_limit;
-        }
-     }
-     else {     
-       dof.subject_distance=shooting_get_canon_subject_distance();      
-           dof.hyperfocal_distance=(fl*fl)/(10*circle_of_confusion*av);
-       if (dof.subject_distance>0 && dof.subject_distance<MAX_DIST) {
-          m = dof.hyperfocal_distance*dof.subject_distance;
-          v = (dof.hyperfocal_distance+dof.subject_distance);
-          if ((v>0) && (m>0))  dof.near_limit=m/v;
-          v = (dof.hyperfocal_distance-dof.subject_distance);
-          if ((v>0) && (m>0))  dof.far_limit=m/v;
-          dof.depth_of_field=dof.far_limit-dof.near_limit;    
-        }
-     }  
-    }
-    if (conf.dof_dist_from_lens) {
-      int h=shooting_get_lens_to_focal_plane_width();   
-      if (dof.subject_distance>0) dof.subject_distance-=h;
-      if (dof.far_limit>0) dof.far_limit-=h;
-      if (dof.near_limit>0) dof.near_limit-=h;
-      if (dof.hyperfocal_distance>0) dof.hyperfocal_distance-=h;
-    }
+  shooting_update_dof_values();
 }
 
@@ -934 +880 @@
 void gui_osd_draw_dof() {
 
-    //gui_osd_calc_dof();
-    //strcpy(osd_buf, "");
-    draw_string(conf.dof_pos.x, conf.dof_pos.y, "S/R1/R2:", conf.osd_color);
-    sprintf_dist(osd_buf, dof.subject_distance);
-    int i=strlen(osd_buf);
-    osd_buf[i]='/';
-    sprintf_dist(osd_buf+i+1, dof.near_limit);
-    i=strlen(osd_buf);
-    osd_buf[i]='/';
-    sprintf_dist(osd_buf+i+1, dof.far_limit);
-    draw_string(conf.dof_pos.x+8*FONT_WIDTH, conf.dof_pos.y, osd_buf, conf.osd_color);
-    
-        draw_string(conf.dof_pos.x, conf.dof_pos.y+FONT_HEIGHT, "DOF/HYP:", conf.osd_color);
-    sprintf_dist(osd_buf, dof.depth_of_field);
+    color valid_col = (conf.osd_color & 0xff00) | COLOR_GREEN;
+    int i=8;
+    short f_ex = (conf.show_dof==DOF_SHOW_IN_DOF_EX);
+    draw_string(conf.dof_pos.x, conf.dof_pos.y, "S/NL/FL:", conf.osd_color);
+    sprintf_dist(osd_buf, (float)dof_values.subject_distance);
     int j=strlen(osd_buf);
-    osd_buf[j]='/';
-    sprintf_dist(osd_buf+j+1, dof.hyperfocal_distance);
-    draw_string(conf.dof_pos.x+8*FONT_WIDTH, conf.dof_pos.y+FONT_HEIGHT, osd_buf, conf.osd_color);
-   
+    draw_string(conf.dof_pos.x+i*FONT_WIDTH, conf.dof_pos.y, osd_buf, 
+      (f_ex && (dof_values.distance_valid || shooting_get_focus_mode()))?valid_col:conf.osd_color);
+    i=i+j;
+    draw_string(conf.dof_pos.x+i*FONT_WIDTH, conf.dof_pos.y, "/", conf.osd_color);
+    sprintf_dist(osd_buf, (float)dof_values.near_limit);
+    j=strlen(osd_buf);
+    draw_string(conf.dof_pos.x+(++i)*FONT_WIDTH, conf.dof_pos.y, osd_buf, 
+      (f_ex && dof_values.distance_valid)?valid_col:conf.osd_color);
+    i=i+j;
+    draw_string(conf.dof_pos.x+i*FONT_WIDTH, conf.dof_pos.y, "/", conf.osd_color);
+    sprintf_dist(osd_buf, (float)dof_values.far_limit);
+    draw_string(conf.dof_pos.x+(++i)*FONT_WIDTH, conf.dof_pos.y, osd_buf,
+      (f_ex && dof_values.distance_valid)?valid_col:conf.osd_color);
+    i=8;
+          draw_string(conf.dof_pos.x, conf.dof_pos.y+FONT_HEIGHT, "DOF/HYP:", conf.osd_color);
+    sprintf_dist(osd_buf, (float)dof_values.depth_of_field);
+    j=strlen(osd_buf);
+    draw_string(conf.dof_pos.x+i*FONT_WIDTH, conf.dof_pos.y+FONT_HEIGHT, osd_buf, 
+      (f_ex && dof_values.distance_valid)?valid_col:conf.osd_color);
+    i=i+j;
+    draw_string(conf.dof_pos.x+i*FONT_WIDTH, conf.dof_pos.y+FONT_HEIGHT, "/", conf.osd_color);
+    sprintf_dist(osd_buf, (float)dof_values.hyperfocal_distance);
+    draw_string(conf.dof_pos.x+(++i)*FONT_WIDTH, conf.dof_pos.y+FONT_HEIGHT, osd_buf,
+      (f_ex && dof_values.hyperfocal_valid)?valid_col:conf.osd_color);
 }
 
@@ -1014 +971 @@
 }
 
-
+/*
 void gui_print_osd_misc_string_dist(const char * title, int value) {
   strcpy(osd_buf, title);
@@ -1021 +978 @@
   osd_buf[9]=0;
   draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
+  m+=FONT_HEIGHT;
+}
+*/
+
+void gui_print_osd_dof_string_dist(const char * title, int value, short use_good_color) {
+  strcpy(osd_buf, title);
+  int i=strlen(osd_buf);
+  if (i<8) {
+    draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
+    sprintf_dist(osd_buf, (float)value);
+    sprintf(osd_buf+strlen(osd_buf), "%9s", "");
+    osd_buf[9-i]=0;
+    draw_string(conf.values_pos.x+i*FONT_WIDTH, conf.values_pos.y+m, osd_buf, use_good_color?((conf.osd_color & 0xff00) | COLOR_GREEN):conf.osd_color);
+  } else {
+    osd_buf[9]=0;
+    draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
+  }
   m+=FONT_HEIGHT;
 }
@@ -1177 +1151 @@
     }
     
-    
     if ((conf.values_show_real_aperture) && (showtype==1)) 
              gui_print_osd_misc_string_float("Av :", "%d.%02d ", 100, shooting_get_real_aperture());
-    if ((conf.show_dof==DOF_SHOW_IN_MISC) && (showtype)) { 
-         //if (kbd_is_key_pressed(KEY_SHOOT_HALF) && (mode_photo || (m&MODE_SHOOTING_MASK)==MODE_STITCH))       
-         //gui_osd_calc_dof();
-         if (conf.dof_subj_dist_in_misc) gui_print_osd_misc_string_dist("SD :", dof.subject_distance);
-         if (conf.dof_near_limit_in_misc) gui_print_osd_misc_string_dist("NL :", dof.near_limit);
-         if (conf.dof_far_limit_in_misc) gui_print_osd_misc_string_dist("FL :", dof.far_limit);
-         if (conf.dof_depth_in_misc) gui_print_osd_misc_string_dist("DOF:", dof.depth_of_field);
-         if (conf.dof_hyperfocal_in_misc) gui_print_osd_misc_string_dist("HYP:", dof.hyperfocal_distance);
+    short f_ex = (conf.show_dof==DOF_SHOW_IN_MISC_EX);
+    if (((conf.show_dof==DOF_SHOW_IN_MISC) && (showtype)) || f_ex) {
+      if (f_ex) gui_osd_calc_dof();
+          if (conf.dof_subj_dist_in_misc) gui_print_osd_dof_string_dist("SD :", dof_values.subject_distance,
+             f_ex && (dof_values.distance_valid || shooting_get_focus_mode()));
+      if (conf.dof_near_limit_in_misc) gui_print_osd_dof_string_dist("NL :", dof_values.near_limit, 
+         f_ex && dof_values.distance_valid);
+          if (conf.dof_far_limit_in_misc) gui_print_osd_dof_string_dist("FL :", dof_values.far_limit, 
+             f_ex && dof_values.distance_valid);
+      if (conf.dof_depth_in_misc) gui_print_osd_dof_string_dist("DOF:", dof_values.depth_of_field, 
+         f_ex && dof_values.distance_valid);
+      if (conf.dof_hyperfocal_in_misc) gui_print_osd_dof_string_dist("HYP:", dof_values.hyperfocal_distance, 
+         f_ex && dof_values.hyperfocal_valid);
     }
     if (showtype==1) {

trunk/core/gui_osd.h

@@ -30 +30 @@
 #define DOF_DONT_SHOW                   0
 #define DOF_SHOW_IN_DOF                 1
-#define DOF_SHOW_IN_MISC                2
+#define DOF_SHOW_IN_DOF_EX              2
+#define DOF_SHOW_IN_MISC                3
+#define DOF_SHOW_IN_MISC_EX             4
 //ARM End
 

trunk/core/luascript.c

@@ -18 +18 @@
 #include "curves.h"
 
+DOF_TYPE dof_values;
+
 static int luaCB_set_curve_state( lua_State* L )
 {
@@ -129 +131 @@
 }
 
-static int luaCB_get_dof( lua_State* L )
-{
-  lua_pushnumber( L, shooting_get_depth_of_field() );
-  return 1;
-}
-
-static int luaCB_get_far_limit( lua_State* L )
-{
-  lua_pushnumber( L, shooting_get_far_limit_of_acceptable_sharpness() );
+static int luaCB_get_dofinfo( lua_State* L )
+{
+  shooting_update_dof_values();
+  lua_createtable(L, 0, 12);
+  SET_BOOL_FIELD("hyp_valid", (dof_values.hyperfocal_valid!=0));
+  SET_BOOL_FIELD("focus_valid", (dof_values.distance_valid!=0));
+  SET_INT_FIELD("aperture", dof_values.aperture_value);
+  SET_INT_FIELD("coc", circle_of_confusion);
+  SET_INT_FIELD("focal_length", dof_values.focal_length);
+  SET_INT_FIELD("eff_focal_length", get_effective_focal_length(lens_get_zoom_point()));
+  SET_INT_FIELD("focus", dof_values.subject_distance);
+  SET_INT_FIELD("near", dof_values.near_limit);
+  SET_INT_FIELD("far", dof_values.far_limit);
+  SET_INT_FIELD("hyp_dist", dof_values.hyperfocal_distance);
+  SET_INT_FIELD("dof", dof_values.depth_of_field);
+  SET_INT_FIELD("min_stack_dist", dof_values.min_stack_distance);
   return 1;
 }
@@ -153 +162 @@
 }
 
-static int luaCB_get_focal_length( lua_State* L )
-{
-  lua_pushnumber( L, get_focal_length(lens_get_zoom_point()) );
-  return 1;
-}
-
-static int luaCB_get_hyp_dist( lua_State* L )
-{
-  lua_pushnumber( L, shooting_get_hyperfocal_distance() );
-  return 1;
-}
-
 static int luaCB_get_iso_market( lua_State* L )
 {
@@ -186 +183 @@
 {
   lua_pushnumber( L, GetJpgCount() );
-  return 1;
-}
-
-static int luaCB_get_near_limit( lua_State* L )
-{
-  lua_pushnumber( L, shooting_get_near_limit_of_acceptable_sharpness() );
   return 1;
 }
@@ -1364 +1355 @@
   FUNC(get_day_seconds);
   FUNC(get_disk_size);
-  FUNC(get_dof);
-  FUNC(get_far_limit);
+  FUNC(get_dofinfo);
   FUNC(get_free_disk_space);
   FUNC(get_focus);
-  FUNC(get_focal_length);
-  FUNC(get_hyp_dist);
   FUNC(get_iso_market);
   FUNC(get_iso_mode);
   FUNC(get_iso_real);
   FUNC(get_jpg_count);
-  FUNC(get_near_limit);
   FUNC(get_prop);
   FUNC(get_raw_count);

trunk/core/luascript.h

@@ -7 +7 @@
 
 #endif
+
+#define SET_STR_FIELD( KEY, VAL ) \
+  lua_pushstring( L, VAL ); \
+  lua_setfield( L, -2, KEY )
+
+#define SET_INT_FIELD( KEY, VAL ) \
+  lua_pushnumber( L, VAL ); \
+  lua_setfield( L, -2, KEY )
+
+#define SET_BOOL_FIELD( KEY, VAL ) \
+  lua_pushboolean( L, VAL ); \
+  lua_setfield( L, -2, KEY )
+

trunk/include/conf.h

@@ -219 +219 @@
     int dof_hyperfocal_in_misc;
     int dof_depth_in_misc;
-    int dof_dist_from_lens;
+//    int dof_dist_from_lens;
     
     

trunk/include/platform.h

@@ -143 +143 @@
 
 typedef struct {
-    int    subject_distance;
-    int     near_limit;
-    int     far_limit;
-    int     hyperfocal_distance;
-    int     depth_of_field;
-    int     lens_to_focal_plane_width;
+    short hyperfocal_valid;
+    short distance_valid;
+    int   hyperfocal_distance_1e3;
+    int   aperture_value;
+    int   focal_length;
+    int   subject_distance;
+    int   near_limit;
+    int   far_limit;
+    int   hyperfocal_distance;
+    int   depth_of_field;
+    int   min_stack_distance;
 } DOF_TYPE;
+
+extern DOF_TYPE dof_values;
 
 typedef struct {
@@ -320 +327 @@
 short shooting_get_focus_state();
 short shooting_get_focus_ok();
+void shooting_update_dof_values();
 int shooting_get_hyperfocal_distance();
-int shooting_get_hyperfocal_distance_f(int av, int fl);
+int shooting_get_hyperfocal_distance_1e3_f(int av, int fl);
 int shooting_get_near_limit_of_acceptable_sharpness();
 int shooting_get_far_limit_of_acceptable_sharpness();
 int shooting_get_depth_of_field();
+int shooting_get_min_stack_distance();
 int shooting_get_subject_distance();
 int shooting_get_subject_distance_override_value();

trunk/lib/ubasic/camera_functions.c

@@ -362 +362 @@
 }
 
+short shooting_get_min_stack_distance()
+{
+    printf("*** shooting_get_min_stack_distance ***\n");
+    return 77;
+}
+
 short shooting_get_iso_market()
 {

trunk/lib/ubasic/tokenizer.c

@@ -125 +125 @@
   {"get_iso",                 TOKENIZER_GET_ISO_MODE}, //FOR COMPATIBILITY
   {"get_jpg_count",           TOKENIZER_GET_JPG_COUNT},
+  {"get_min_stack_dist",      TOKENIZER_GET_MIN_STACK_DIST},
   {"get_movie_status",        TOKENIZER_GET_MOVIE_STATUS},
   {"get_mode",                                  TOKENIZER_GET_MODE},  // Returns 0 in recordmode, 1 in playmode

trunk/lib/ubasic/tokenizer.h

@@ -199 +199 @@
   TOKENIZER_GET_FOCUS_STATE,
   TOKENIZER_GET_FOCUS_OK,
+  TOKENIZER_GET_MIN_STACK_DIST,
   
 } ubasic_token;

trunk/lib/ubasic/ubasic.c

@@ -540 +540 @@
     r = get_focal_length(lens_get_zoom_point());
     break;
+  case TOKENIZER_GET_MIN_STACK_DIST:
+    accept(TOKENIZER_GET_MIN_STACK_DIST);
+    r = shooting_get_min_stack_distance();
+    break;
   }
   default:

trunk/platform/generic/shooting.c

@@ -60 +60 @@
 static EXPO_BRACKETING_VALUES bracketing;
 
+DOF_TYPE dof_values;
+
 //***********************
 /*
@@ -419 +421 @@
 }
 
-int shooting_get_hyperfocal_distance_()
-{
-  int av=shooting_get_real_aperture();
-  int fl=get_focal_length(lens_get_zoom_point());       
-  if ((av>0) && (fl>0)) return (fl*fl)/(10*circle_of_confusion*av);
+short shooting_get_aperture_from_av96_1e3(short av96) {
+        if (av96) return (short)(pow(sqrt2, (((double)av96)/96.0))*1000.0 + 0.5);
+        else return -1;
+}
+
+int shooting_get_hyperfocal_distance_1e3_f2(int av_1e3, int fl)
+{
+  if ((av_1e3>0) && (fl>0) && (circle_of_confusion>0)) 
+    return (((fl*fl)/(av_1e3*circle_of_confusion)*2000)+2*fl+1)/2;
   else return (-1);
 }
 
+int shooting_get_hyperfocal_distance_1e3_f(int av, int fl)
+{
+  if ((av>0) && (fl>0) && (circle_of_confusion>0)) 
+    return (((fl*fl)/(av*circle_of_confusion)*200)+2*fl+1)/2;
+  else return (-1);
+}
+
+int shooting_get_near_limit_f(int s, int av, int fl)
+{
+  int h_1e3 = shooting_get_hyperfocal_distance_1e3_f(av, fl);
+  int m = ((h_1e3 - fl)+500)/1000*s;
+  int v = ((h_1e3 + 1000*s - 2*fl)+500)/1000;
+  if ((m>0) && (v>0)) return ((2*m/v+1)/2);
+  else return (-1);
+}
+
+int shooting_get_far_limit_f(int s, int av, int fl)
+{
+  if (s<MAX_DIST) {
+    int h_1e3 = shooting_get_hyperfocal_distance_1e3_f(av, fl);
+    int m = ((h_1e3 - fl)+500)/1000*s;
+    int v = ((h_1e3 - 1000*s)+500)/1000;
+    if ((m>0) && (v>0)) return ((2*m/v+1)/2);
+    else return (-1);
+  } else return (-1);
+}
+
+int shooting_get_canon_subject_distance()
+{
+        if (conf.dof_use_exif_subj_dist) 
+          return shooting_get_exif_subject_dist();
+        else
+          return (lens_get_focus_pos_from_lens());
+}
+
+int shooting_get_subject_distance_()
+{
+   if (!conf.dof_subj_dist_as_near_limit) return shooting_get_canon_subject_distance();
+   else return shooting_get_far_limit_f(shooting_get_canon_subject_distance(),
+                                         shooting_get_min_real_aperture(), 
+                                         get_focal_length(lens_get_zoom_point()));
+}
+
+void shooting_update_dof_values()
+{
+  short f_focus_ok = shooting_get_focus_ok();
+  short f_hyp_calc = 0;
+  short f_dist_calc = 0;
+
+  int av_1e3 = shooting_get_aperture_from_av96_1e3(_GetCurrentAvValue() & ~1);
+  int man_av_1e3 = shooting_get_aperture_from_av96_1e3(shooting_get_user_av96());
+  int dist = shooting_get_subject_distance_();
+  int fl = get_focal_length(lens_get_zoom_point());
+
+  int mode = mode_get()&MODE_SHOOTING_MASK;
+  if ((mode==MODE_M || mode==MODE_AV) && (man_av_1e3>0) && !f_focus_ok) { 
+    av_1e3 = man_av_1e3;  //manual av in AV and M Mode and not shoot_half
+  }
+
+  int hyp_1e3 = dof_values.hyperfocal_distance_1e3;
+  int hyp = dof_values.hyperfocal_distance;
+  
+  if (dof_values.aperture_value!=av_1e3 || dof_values.focal_length!=fl || (hyp_1e3<0)) { 
+    //calc new hyperfocal distance and min stack distance
+    f_hyp_calc = 1;
+    hyp_1e3 = -1;
+    hyp = -1;
+    dof_values.aperture_value = av_1e3;
+    dof_values.focal_length = fl;
+    hyp_1e3 = shooting_get_hyperfocal_distance_1e3_f2(av_1e3, fl);
+    if (hyp_1e3>0) {
+      hyp = (hyp_1e3+500)/1000;
+      dof_values.min_stack_distance = MAX_DIST;
+      int  v = ((hyp_1e3 - fl)/250 + 2 + 1)/2;
+      if (v>0) {
+        int t1 = ((fl*((fl - hyp_1e3)/1000 - 1)/500)/v + 1)/2;
+        int t2 = ((hyp*((2*fl - hyp_1e3)/500))/v + 1)/2;
+        dof_values.min_stack_distance = sqrt(t1*t1 - t2) - t1;
+      }  
+    }
+  }
+
+  if ((dof_values.subject_distance!=dist || (dof_values.hyperfocal_distance_1e3!=hyp_1e3)) &&
+      (hyp_1e3>0)) {
+    //calc new NEAR, FAR, DOF values
+    f_dist_calc = 1;
+    dof_values.subject_distance = dist;
+    dof_values.near_limit = -1;
+    dof_values.far_limit = -1;
+    dof_values.depth_of_field = -1;
+    if ((av_1e3>0) && (fl>0) && (dist>0) && (dist<MAX_DIST) && (hyp_1e3>0)) {
+      int v;
+      int m = ((hyp_1e3 - fl)/500*dist + 1)/2;
+        if (conf.dof_subj_dist_as_near_limit) { 
+          dof_values.near_limit = dist;
+        } else {
+        v = ((hyp_1e3 + 1000*dist - 2*fl)/500 + 1)/2;
+            if (v>0) { dof_values.near_limit = m/v; }
+          }
+          if (dof_values.near_limit>=MAX_DIST) { dof_values.near_limit = -1;}
+      v = ((hyp_1e3 - 1000*dist)/500 + 1)/2;
+      if (v>0) { dof_values.far_limit = m/v; }
+          if (dof_values.far_limit>=MAX_DIST) { dof_values.far_limit = -1;}
+      if ((dof_values.near_limit>0) && (dof_values.far_limit>0)) {
+        dof_values.depth_of_field = dof_values.far_limit - dof_values.near_limit; }
+    }
+  }
+  dof_values.hyperfocal_distance_1e3 = hyp_1e3;
+  dof_values.hyperfocal_distance = hyp; 
+  f_focus_ok = (f_focus_ok && shooting_get_focus_ok());
+  dof_values.hyperfocal_valid = (f_focus_ok || (dof_values.hyperfocal_valid && !f_hyp_calc));
+  dof_values.distance_valid = (f_focus_ok || (dof_values.distance_valid && !f_dist_calc)||(dof_values.hyperfocal_valid && shooting_get_focus_mode()));
+  return;
+}
+
+int shooting_get_subject_distance()
+{
+  shooting_update_dof_values();
+  return dof_values.subject_distance;
+}
+
 int shooting_get_hyperfocal_distance()
 {
- int h=shooting_get_hyperfocal_distance_();
- if ((h>0) && (conf.dof_dist_from_lens)) 
-   return (h-shooting_get_lens_to_focal_plane_width());
- else return h;
-}
-
-int shooting_get_hyperfocal_distance_f(int av, int fl)
-{
-  if ((av>0) && (fl>0) && (circle_of_confusion>0)) return (fl*fl)/(10*circle_of_confusion*av);
-  else return (-1);
-}
-
-int shooting_get_canon_subject_distance()
-{
-        if (conf.dof_use_exif_subj_dist) return shooting_get_exif_subject_dist();
-        else return lens_get_focus_pos();
-}
-
-int shooting_get_subject_distance_()
-{
-   if (!conf.dof_subj_dist_as_near_limit) return shooting_get_canon_subject_distance();
-   else {
-        int h, v, m;
-                int fl=get_focal_length(lens_get_zoom_point()); 
-        int near=shooting_get_canon_subject_distance(); 
-        int v1=(fl*fl);
-        int av_min=shooting_get_min_real_aperture();
-        int c_of_c=circle_of_confusion*10;
-        if ((av_min!=0) && (c_of_c!=0) && (v1)) {
-                    h=v1/(c_of_c*av_min);
-            if ((near>0) && (near<MAX_DIST)) {
-                  v=(h-near);
-                  m=h*near;
-                  if ((v>0) && (m>0)) return m/v;  
-             }
-        }
-        return (-1);
-    }
-}
-
-int shooting_get_subject_distance()
-{
- int h=shooting_get_subject_distance_();
- if ((h>0) && (conf.dof_dist_from_lens)) 
-   return (h-shooting_get_lens_to_focal_plane_width());
- else return h;
-}
-
-int shooting_get_near_limit_of_acceptable_sharpness_()
-{
-        int s=shooting_get_canon_subject_distance();    
-        if (conf.dof_subj_dist_as_near_limit) return s;
-    else {
-      int h = shooting_get_hyperfocal_distance_();      
-      int m = h*s;
-      int v = h+s;
-      if ((m>0) && (v>0)) return (m/v);
-      else return (-1);
-    }
+  shooting_update_dof_values();
+  return dof_values.hyperfocal_distance;
 }
 
 int shooting_get_near_limit_of_acceptable_sharpness()
 {
- int h=shooting_get_near_limit_of_acceptable_sharpness_();
- if ((h>0) && (conf.dof_dist_from_lens)) 
-   return (h-shooting_get_lens_to_focal_plane_width());
- else return h;
-}
-
-int shooting_get_near_limit_f(int s, int a, int fl)
-{
-      int h = shooting_get_hyperfocal_distance_f(a, fl);        
-      int m = h*s;
-      int v = h+s;
-      if ((m>0) && (v>0)) return (m/v);
-      else return (-1);
-}
-
-int shooting_get_far_limit_of_acceptable_sharpness_()
-{
-        int s=shooting_get_subject_distance_(), h=shooting_get_hyperfocal_distance_();  
-    int v = h-s;
-    int m = h*s;
-    if ((m>0) && (v>0)) return (m/v);
-    else return (-1);
+  shooting_update_dof_values();
+  return dof_values.near_limit;
 }
 
 int shooting_get_far_limit_of_acceptable_sharpness()
 {
- int h=shooting_get_far_limit_of_acceptable_sharpness_();
- if ((h>0) && (conf.dof_dist_from_lens)) 
-   return (h-shooting_get_lens_to_focal_plane_width());
- else return h;
+  shooting_update_dof_values();
+  return dof_values.far_limit;
 }
 
 int shooting_get_depth_of_field()
 {
-  int far=shooting_get_far_limit_of_acceptable_sharpness_(), near=shooting_get_near_limit_of_acceptable_sharpness_();
-  if ((far>0) && (near>0)) return far-near;
-  else return (-1);
+  shooting_update_dof_values();
+  return dof_values.depth_of_field;
+}
+
+int shooting_get_min_stack_distance()
+{
+  shooting_update_dof_values();
+  return dof_values.min_stack_distance;
 }
 
@@ -985 +1038 @@
 void shooting_set_focus(int v, short is_now) {
         int s=v;
-if ((mode_get()&MODE_MASK) != MODE_PLAY){
-        if ((is_now) && shooting_can_focus()) {
-          if (conf.dof_dist_from_lens) s+=shooting_get_lens_to_focal_plane_width();
-          if ((!conf.dof_subj_dist_as_near_limit) && (s>0)) lens_set_focus_pos((s<MAX_DIST)?s:MAX_DIST); 
-          else {
-        int near=shooting_get_near_limit_f(s,shooting_get_min_real_aperture(),get_focal_length(lens_get_zoom_point()));
-        if (near>0) lens_set_focus_pos((near<MAX_DIST)?near:MAX_DIST); 
+  if ((mode_get()&MODE_MASK) != MODE_PLAY){
+          if ((is_now) && shooting_can_focus()) {
+          if (conf.dof_subj_dist_as_near_limit) {
+        s=shooting_get_near_limit_f(v,shooting_get_min_real_aperture(),get_focal_length(lens_get_zoom_point()));
+            }     
+            if (!conf.dof_use_exif_subj_dist) s+=shooting_get_lens_to_focal_plane_width();
+      if (s>0) lens_set_focus_pos((s<MAX_DIST)?s:MAX_DIST); 
           }
-        }
-        else photo_param_put_off.subj_dist=v;
-}
+          else photo_param_put_off.subj_dist=v;
+  }
 }
 

trunk/version.inc

@@ -1 @@
-BUILD_NUMBER := 1.0.1-DE
+BUILD_NUMBER := 1.1.0-DE