Time reference and decimal places

docs/figure_file_format.rst

@@ -129,6 +129,15 @@ Optional settings for each panel::
             "size": "12",
             "position": "topright",
             "color": "FFFFFF"
+        },
+        {
+            // for 'time', 'x', 'y', 'width' and 'height', decimal precision
+            // can be specified in 3rd position (here 2)
+            // 'time' can also be given a frame index as the zero timepoint after a '-' sign
+            "text": "Time (s): [time.secs.2-3]",
+            "size": "12",
+            "position": "topright",
+            "color": "FFFFFF"
         }
     ],
 

omero_figure/scripts/omero/figure_scripts/Figure_To_Pdf.py

@@ -1087,34 +1087,36 @@ def get_crop_region(self, panel):
 
         return {'x': cropx, 'y': cropy, 'width': tile_w, 'height': tile_h}
 
-    def get_time_label_text(self, delta_t, format):
+    def get_time_label_text(self, delta_t, format, dec_prec):
         """ Gets the text for 'live' time-stamp labels """
         # format of "secs" by default
         is_negative = delta_t < 0
         delta_t = abs(delta_t)
-        text = "%d s" % int(round(delta_t))
+        npad = 2 + dec_prec + (dec_prec > 0)
         if format in ["milliseconds", "ms"]:
-            text = "%s ms" % int(round(delta_t * 1000))
+            text = "%.*f ms" % (dec_prec, delta_t * 1000)
         elif format in ["secs", "seconds", "s"]:
-            text = "%d s" % int(round(delta_t))
+            text = "%.*f s" % (dec_prec, delta_t)
         elif format in ["mins", "minutes", "m"]:
-            text = "%s mins" % int(round(delta_t / 60))
+            text = "%.*f mins" % (dec_prec, delta_t / 60)
         elif format in ["mins:secs", "m:s"]:
             m = int(delta_t // 60)
-            s = round(delta_t % 60)
-            text = "%s:%02d" % (m, s)
+            s = delta_t % 60
+            text = "%s:%0*.*f" % (m, npad, dec_prec, s)
         elif format in ["hrs:mins", "h:m"]:
             h = int(delta_t // 3600)
-            m = int(round((delta_t % 3600) / 60))
-            text = "%s:%02d" % (h, m)
+            m = (delta_t % 3600) / 60
+            text = "%s:%0*.*f" % (h, npad, dec_prec, m)
         elif format in ["hrs:mins:secs", "h:m:s"]:
             h = int(delta_t // 3600)
             m = (delta_t % 3600) // 60
-            s = round(delta_t % 60)
-            text = "%s:%02d:%02d" % (h, m, s)
+            s = delta_t % 60
+            text = "%s:%02d:%0*.*f" % (h, m, npad, dec_prec, s)
         else:  # Format unknown
             return ""
-        if text in ["0 s", "0:00", "0 mins", "0:00:00"]:
+        dec_str = "" if dec_prec == 0 else "." + "0" * dec_prec
+        if text in ["0"+dec_str+" s", "0:00"+dec_str,
+                    "0"+dec_str+" mins", "0:00:00"+dec_str]:
             is_negative = False
         return ('-' if is_negative else '') + text
 
@@ -1165,18 +1167,42 @@ def draw_labels(self, panel, page):
                 expr = item.group()[1:-1].split(".")
                 label_value = ""
 
+                tmp = expr[-1].split("-")
+                expr[-1] = tmp[0]
+                ref_idx = None
+                if len(tmp) > 1:
+                    try:
+                        ref_idx = int(tmp[1])
+                    except ValueError:
+                        pass
+
+                dec_prec = None
+                if len(expr) > 2:
+                    try:
+                        dec_prec = int(expr[2])
+                    except ValueError:
+                        pass
+
                 if expr[0] in ["time", "t"]:
                     the_t = panel['theT']
                     timestamps = panel.get('deltaT')
                     # default to index
                     if len(expr) == 1 or expr[1] == "index":
                         label_value = str(the_t + 1)
                     else:
+                        d_t = 0
                         if timestamps and the_t < len(timestamps):
                             d_t = timestamps[the_t]
-                        else:
-                            d_t = 0
-                        label_value = self.get_time_label_text(d_t, expr[1])
+                            if ref_idx is not None:
+                                if 1 <= ref_idx <= len(timestamps):
+                                    d_t -= timestamps[ref_idx-1]
+
+                        # Set the default precision value (0) if not given
+                        dec_prec = 0 if dec_prec is None else dec_prec
+
+                        label_value = self.get_time_label_text(d_t,
+                                                               expr[1],
+                                                               dec_prec)
 
                 elif expr[0] == "image":
                     format = expr[1] if len(expr) > 1 else "name"
@@ -1215,6 +1241,9 @@ def draw_labels(self, panel, page):
                     elif prop == "rot":
                         prop = "rotation"
 
+                    # Set the default precision value (2) if not given
+                    dec_prec = 2 if dec_prec is None else dec_prec
+
                     if prop == "z":
                         size_z = panel.get('sizeZ')
                         pixel_size_z = panel.get('pixel_size_z')
@@ -1229,8 +1258,10 @@ def draw_labels(self, panel, page):
                                 label_value = (str(z_start + 1) + "-"
                                                + str(z_end + 1))
                             elif format == "unit" and size_z:
-                                z_start = f"{(z_start * pixel_size_z):.2f}"
-                                z_end = f"{(z_end * pixel_size_z):.2f}"
+                                z_start = "%.*f" % (dec_prec,
+                                                    (z_start * pixel_size_z))
+                                z_end = "%.*f" % (dec_prec,
+                                                  (z_end * pixel_size_z))
                                 label_value = (z_start + " " + z_symbol + " - "
                                                + z_end + " " + z_symbol)
                         else:
@@ -1239,7 +1270,8 @@ def draw_labels(self, panel, page):
                                 label_value = str(the_z + 1)
                             elif (format == "unit" and size_z
                                   and the_z < size_z):
-                                z_pos = f"{(the_z * pixel_size_z):.2f}"
+                                z_pos = "%.*f" % (dec_prec,
+                                                  (the_z * pixel_size_z))
                                 label_value = (z_pos + " " + z_symbol)
 
                     elif prop == "rotation":
@@ -1255,7 +1287,8 @@ def draw_labels(self, panel, page):
                                 scale = panel['pixel_size_x']
                             elif prop in ['y', 'height']:
                                 scale = panel['pixel_size_y']
-                            rounded = f"{(value * scale):.2f}"
+                            rounded = "%.*f" % (dec_prec,
+                                                (value * scale))
                             label_value = ("" + rounded +
                                            " " + panel['pixel_size_x_symbol'])
 

omero_figure/templates/figure/index.html

@@ -516,7 +516,7 @@ <h4 class="modal-title" id="addImagesLabel">Import from JSON</h4>
                     <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
                     <h4 class="modal-title">Label Formatting</h4>
                 </div>
-                <div class="modal-body" style="max-height:518px">
+                <div class="modal-body" style="max-height:542px">
                     <h4>Markdown formatting</h4>
                     <p>
                         You can use "Markdown" syntax to add formatting to plain text. For example,
@@ -580,6 +580,21 @@ <h4>Dynamic properties</h4>
                             <td>*Height*: **[height.pixel]**</td>
                             <td><i>Height</i>: <strong>300</strong></td>
                         </tr>
+                        <tr>
+                            <th>Width with decimal precision of 3</th>
+                            <td>Width: [width.unit.3]</td>
+                            <td>Width: 4.450 µm</td>
+                        </tr>
+                        <tr>
+                            <th>Time with frame n°3 as the "zero"</th>
+                            <td>Time: [time.milliseconds-3]</td>
+                            <td>Time: -58 ms</td>
+                        </tr>
+                        <tr>
+                            <th>Time with decimal precision (2) and "zero" (3)</th>
+                            <td>Time: [time.seconds.2-3]</td>
+                            <td>Time: -0.058 s</td>
+                        </tr>
                         <tr>
                             <th>Image ID</th>
                             <td>Image ID: [image.id]</td>

src/js/models/panel_model.js

@@ -285,42 +285,50 @@
             return this.get('deltaT')[theT] || 0;
         },
 
-        get_time_label_text: function(format) {
+        get_time_label_text: function(format, ref_idx, dec_prec) {
             var pad = function(digit) {
                 var d = digit + "";
                 return d.length === 1 ? ("0"+d) : d;
             };
             var theT = this.get('theT'),
                 deltaT = this.get('deltaT')[theT] || 0,
-                isNegative = (deltaT < 0),
                 text = "", h, m, s;
+
+            if (ref_idx){
+                shift = this.get('deltaT')[parseInt(ref_idx)-1];
+                deltaT = shift==null?deltaT:deltaT-shift;
+            }
+            var isNegative = (deltaT < 0);
             deltaT = Math.abs(deltaT);
+
+            var padlen = dec_prec>0 ? dec_prec+3 : 2;
             if (format === "index") {
                 isNegative = false;
                 text = "" + (theT + 1);
             } else if (['milliseconds', 'ms'].includes(format)) {
-                text = Math.round(deltaT*1000) + " ms";
+                text = (deltaT*1000).toFixed(dec_prec) + " ms";
             } else if (['seconds', 'secs', 's'].includes(format)) {
-                text = Math.round(deltaT) + " s";
+                text = deltaT.toFixed(dec_prec) + " s";
             } else if (['minutes', 'mins', 'm'].includes(format)) {
-                text = Math.round(deltaT / 60) + " mins";
+                text = (deltaT / 60).toFixed(dec_prec) + " mins";
             } else if (["mins:secs", "m:s"].includes(format)) {
                 m = parseInt(deltaT / 60);
-                s = pad(Math.round(deltaT % 60));
+                s = ((deltaT % 60).toFixed(dec_prec)).padStart(padlen, "0");
                 text = m + ":" + s;
             } else if (["hrs:mins", "h:m"].includes(format)) {
                 h = parseInt(deltaT / 3600);
-                m = pad(Math.round((deltaT % 3600) / 60));
+                m = (((deltaT % 3600) / 60).toFixed(dec_prec)).padStart(padlen, "0");
                 text = h + ":" + m;
             } else if (["hrs:mins:secs", "h:m:s"].includes(format)) {
                 h = parseInt(deltaT / 3600);
                 m = pad(parseInt((deltaT % 3600) / 60));
-                s = pad(Math.round(deltaT % 60));
+                s = ((deltaT % 60).toFixed(dec_prec)).padStart(padlen, "0");
                 text = h + ":" + m + ":" + s;
             } else { // Format unknown
                 return ""
             }
-            if (["0 s", "0:00", "0 mins", "0:00:00"].indexOf(text) > -1) {
+            var dec_str = dec_prec>0 ? "."+"0".repeat(dec_prec) : "";
+            if (["0"+dec_str+" s", "0"+dec_str+" mins", "0:00"+dec_str, "0:00:00"+dec_str].indexOf(text) > -1) {
                 isNegative = false;
             }
             return (isNegative ? '-' : '') + text;
@@ -345,7 +353,7 @@
             return text;
         },
 
-        get_view_label_text: function(property, format) {
+        get_view_label_text: function(property, format, dec_prec) {
             if (format === "px") format = "pixel";
 
             if (property === "w") property = "width";
@@ -361,6 +369,9 @@
             z_size = this.get('pixel_size_z');
             z_size = z_size?z_size:0
 
+            dec_prec = parseInt(dec_prec)
+            dec_prec = dec_prec==null?2:dec_prec; // 2 is the default precision
+
             var text = "";
             if (property === "z") {
                 if (this.get('z_projection')) {
@@ -369,8 +380,8 @@
                     if (format === "pixel") {
                         text = "" + (start+1) + " - " + (end+1);
                     } else if (format === "unit"){
-                        start = (start * z_size).toFixed(2)
-                        end = (end * z_size).toFixed(2)
+                        start = (start * z_size).toFixed(dec_prec)
+                        end = (end * z_size).toFixed(dec_prec)
                         text = ""+ start +" "+ z_symbol
                                + " - " + end +" "+ z_symbol
                     }
@@ -380,7 +391,7 @@
                     if (format === "pixel") {
                         text = "" + (theZ + 1);
                     } else if (format === "unit"){
-                        text = ""+ (theZ * z_size).toFixed(2) +" "+ z_symbol
+                        text = ""+ (theZ * z_size).toFixed(dec_prec) +" "+ z_symbol
                     }
                 }
                 return text
@@ -393,7 +404,7 @@
                 return ""+parseInt(value);
             } else if (format === "unit") {
                 scale = ['x', 'width'].includes(property) ? x_size : y_size
-                text = ""+ (value * scale).toFixed(2) +" "+ x_symbol
+                text = ""+ (value * scale).toFixed(dec_prec) +" "+ x_symbol
             }
             return text
         },

src/js/views/panel_view.js

@@ -198,14 +198,20 @@
                         var new_text = new_text + ljson.text.slice(last_idx, match.index);
                         expr = match[0].slice(1,-1).split(".");
                         var label_value = ""
+
+                        ref_idx = expr[expr.length-1].split("-");
+                        expr[expr.length-1] = ref_idx[0];
+
                         if (['time', 't'].includes(expr[0])) {
-                            label_value = self.model.get_time_label_text(expr[1] ? expr[1] : "index");
+                            dec_prec = (expr[2] ? parseInt(expr[2]) : 0); // decimal places matters only when the format isn't default
+                            label_value = self.model.get_time_label_text(expr[1] ? expr[1] : "index", ref_idx[1], dec_prec);
                         } else if (['image', 'dataset'].includes(expr[0])){
                             label_value = self.model.get_name_label_text(expr[0], expr[1] ? expr[1] : "name");
                             //Escape the underscore for markdown
                             label_value = label_value.replaceAll("_", "\\_");
                         } else if (['x', 'y', 'z', 'width', 'height', 'w', 'h', 'rotation', 'rot'].includes(expr[0])){
-                            label_value = self.model.get_view_label_text(expr[0], expr[1] ? expr[1] : "pixel");
+                            dec_prec = (expr[2] ? parseInt(expr[2]) : 2); // decimal places matters only when the format isn't default
+                            label_value = self.model.get_view_label_text(expr[0], expr[1] ? expr[1] : "pixel", dec_prec);
                         } else if (['channels', 'c'].includes(expr[0])) {
                             label_value = self.model.get_channels_label_text();
                         }