Merge pull request micro-manager#2403 from nicost/explorer

Explorer: Refine Z Autofocus can now exclude edge tiles

Author: nicost

libraries/TiledDataViewer/src/main/java/org/micromanager/tileddataviewer/internal/gui/ImageMaker.java

@@ -210,6 +210,16 @@ public synchronized Image makeOrGetImage(DataViewCoords viewCoords) {
                TaggedImage imageForDisplay = getDisplayImage(axes, viewCoords.getResolutionIndex(),
                        viewOffsetAtResX, viewOffsetAtResY, imagePixelWidth, imagePixelHeight);
 
+               // The requested resolution level / region may have no data yet - e.g. a zoom
+               // that requests a pyramid level still being generated while tiles are acquired
+               // concurrently. Skip this channel for now (keeping the last frame for it); the
+               // next render fills it in once the data is ready. Without this guard the null
+               // deref below throws, aborts the render, and leaves the canvas blank until the
+               // zoom level changes.
+               if (imageForDisplay == null) {
+                  continue;
+               }
+
                if (latestTags_ == null
                         || (viewCoords.getAxesPositions().containsKey(TiledDataViewer.CHANNEL_AXIS)
                         && viewCoords.getAxesPositions().get(TiledDataViewer.CHANNEL_AXIS)

plugins/Explorer/src/main/java/org/micromanager/explorer/ExplorerManager.java

@@ -1989,6 +1989,63 @@ private java.util.List<Tile> collectAcceptedTiles(boolean withinVesselOnly) thro
       return computePositionGrid(withinVesselOnly).tiles;
    }
 
+   /**
+    * Drops tiles within {@code margin} grid tiles of the edge of the occupied region, per well.
+    * The edge is followed raggedly: a tile is excluded when it is within {@code margin} of the
+    * first/last occupied column in its own grid row OR of the first/last occupied row in its own
+    * grid column. This removes the outer ring(s) of tiles - which often only partially overlap the
+    * sample and make autofocus fail - while tracking a non-rectangular (curved/diagonal) ROI
+    * outline rather than a plain bounding box. Returns the kept tiles (input order preserved).
+    */
+   private java.util.List<Tile> excludeEdgeTiles(java.util.List<Tile> tiles, int margin) {
+      if (margin <= 0 || tiles.isEmpty()) {
+         return new java.util.ArrayList<>(tiles);
+      }
+      // Per-well occupied extents: for each (well,row) the min/max col, for each (well,col) the
+      // min/max row. Non-plate tiles share a single well key of 0.
+      java.util.Map<Long, int[]> colRangeByRow = new java.util.HashMap<>(); // {minCol,maxCol}
+      java.util.Map<Long, int[]> rowRangeByCol = new java.util.HashMap<>(); // {minRow,maxRow}
+      for (Tile t : tiles) {
+         long well = wellKeyOf(t);
+         long rowKey = (well << 24) ^ (t.row & 0xffffffL);
+         long colKey = (well << 24) ^ (t.col & 0xffffffL);
+         int[] cr = colRangeByRow.get(rowKey);
+         if (cr == null) {
+            colRangeByRow.put(rowKey, new int[] {t.col, t.col});
+         } else {
+            cr[0] = Math.min(cr[0], t.col);
+            cr[1] = Math.max(cr[1], t.col);
+         }
+         int[] rr = rowRangeByCol.get(colKey);
+         if (rr == null) {
+            rowRangeByCol.put(colKey, new int[] {t.row, t.row});
+         } else {
+            rr[0] = Math.min(rr[0], t.row);
+            rr[1] = Math.max(rr[1], t.row);
+         }
+      }
+      java.util.List<Tile> kept = new java.util.ArrayList<>();
+      for (Tile t : tiles) {
+         long well = wellKeyOf(t);
+         int[] cr = colRangeByRow.get((well << 24) ^ (t.row & 0xffffffL));
+         int[] rr = rowRangeByCol.get((well << 24) ^ (t.col & 0xffffffL));
+         boolean edge = (t.col - cr[0] < margin) || (cr[1] - t.col < margin)
+               || (t.row - rr[0] < margin) || (rr[1] - t.row < margin);
+         if (!edge) {
+            kept.add(t);
+         }
+      }
+      return kept;
+   }
+
+   /** Packs a tile's well {row,col} (or 0 for non-plate) into a stable long key. */
+   private static long wellKeyOf(Tile t) {
+      if (t.well == null) {
+         return 0L;
+      }
+      return ((long) t.well[0] << 32) | (t.well[1] & 0xffffffffL);
+   }
+
    /**
     * Chooses up to {@code n} tiles TOTAL, spread across the given set using farthest-point sampling
     * in stage space. On multi-well plates the total budget {@code n} is distributed across the
@@ -2003,11 +2060,7 @@ private java.util.List<Tile> chooseSpreadTiles(java.util.List<Tile> tiles, int n
       // Group by well so the budget is spread across wells; non-plate -> single group.
       java.util.Map<Long, java.util.List<Tile>> byWell = new java.util.LinkedHashMap<>();
       for (Tile t : tiles) {
-         long key = 0;
-         if (t.well != null) {
-            key = ((long) t.well[0] << 32) | (t.well[1] & 0xffffffffL);
-         }
-         byWell.computeIfAbsent(key, k -> new java.util.ArrayList<>()).add(t);
+         byWell.computeIfAbsent(wellKeyOf(t), k -> new java.util.ArrayList<>()).add(t);
       }
       int nWells = byWell.size();
       // Distribute n across wells: a base count each, plus one extra to the first 'remainder'
@@ -2025,6 +2078,104 @@ private java.util.List<Tile> chooseSpreadTiles(java.util.List<Tile> tiles, int n
       return result;
    }
 
+   /**
+    * Orders the chosen autofocus tiles into a short stage route to minimize XY travel. Uses a
+    * greedy nearest-neighbor tour seeded at the current stage position (so the first hop is short
+    * too), then a 2-opt cleanup pass to remove the obvious crossings the greedy pass leaves. Point
+    * counts here are small (a handful per run), so the O(n^2)/O(n^3) cost is negligible. On
+    * multi-well plates the chosen points are already spatially clustered per well, so nearest-
+    * neighbor naturally finishes one well before crossing to the next.
+    */
+   private java.util.List<Tile> orderForTravel(java.util.List<Tile> chosen) {
+      if (chosen.size() <= 2) {
+         return chosen;
+      }
+      java.util.List<Tile> remaining = new java.util.ArrayList<>(chosen);
+
+      // Seed at the tile nearest the current stage position when it is readable, else the first.
+      double curX = 0;
+      double curY = 0;
+      boolean haveCur = false;
+      try {
+         String xy = studio_.core().getXYStageDevice();
+         if (xy != null && !xy.isEmpty()) {
+            curX = studio_.core().getXPosition(xy);
+            curY = studio_.core().getYPosition(xy);
+            haveCur = true;
+         }
+      } catch (Exception ignore) {
+         // Stage position unavailable -- start from the first chosen tile.
+      }
+      Tile start = remaining.get(0);
+      if (haveCur) {
+         double best = Double.MAX_VALUE;
+         for (Tile t : remaining) {
+            double d = dist2(t.stageX, t.stageY, curX, curY);
+            if (d < best) {
+               best = d;
+               start = t;
+            }
+         }
+      }
+      remaining.remove(start);
+      java.util.List<Tile> route = new java.util.ArrayList<>(chosen.size());
+      route.add(start);
+
+      // Greedy nearest-neighbor.
+      while (!remaining.isEmpty()) {
+         Tile last = route.get(route.size() - 1);
+         Tile next = remaining.get(0);
+         double best = Double.MAX_VALUE;
+         for (Tile t : remaining) {
+            double d = dist2(last.stageX, last.stageY, t.stageX, t.stageY);
+            if (d < best) {
+               best = d;
+               next = t;
+            }
+         }
+         remaining.remove(next);
+         route.add(next);
+      }
+
+      twoOpt(route);
+      return route;
+   }
+
+   /** In-place 2-opt improvement of an open tour (route start/end are not joined). */
+   private void twoOpt(java.util.List<Tile> route) {
+      int n = route.size();
+      boolean improved = true;
+      while (improved) {
+         improved = false;
+         for (int i = 0; i < n - 1; i++) {
+            for (int k = i + 1; k < n; k++) {
+               // Reversing route[i..k] changes only the edges entering i and leaving k.
+               double before = (i > 0 ? edge(route, i - 1, i) : 0)
+                     + (k < n - 1 ? edge(route, k, k + 1) : 0);
+               double after = (i > 0 ? edge(route, i - 1, k) : 0)
+                     + (k < n - 1 ? edge(route, i, k + 1) : 0);
+               if (after + 1e-6 < before) {
+                  java.util.Collections.reverse(route.subList(i, k + 1));
+                  improved = true;
+               }
+            }
+         }
+      }
+   }
+
+   /** Euclidean stage distance between route entries a and b. */
+   private double edge(java.util.List<Tile> route, int a, int b) {
+      Tile ta = route.get(a);
+      Tile tb = route.get(b);
+      return Math.sqrt(dist2(ta.stageX, ta.stageY, tb.stageX, tb.stageY));
+   }
+
+   private static double dist2(double x1, double y1, double x2, double y2) {
+      double dx = x1 - x2;
+      double dy = y1 - y2;
+      return dx * dx + dy * dy;
+   }
+
    /** Farthest-point sampling of {@code count} tiles from {@code group} (Euclidean stage XY). */
    private java.util.List<Tile> farthestPointSample(java.util.List<Tile> group, int count) {
       java.util.List<Tile> chosen = new java.util.ArrayList<>();
@@ -2778,7 +2929,8 @@ public void cancelRefineZ() {
     * runs the selected autofocus method, and records the resulting Z of every checked Z stage.
     * Runs off the EDT.
     */
-   public void startRefineZAutomatic(int nPoints, String afMethodName, boolean withinVesselOnly) {
+   public void startRefineZAutomatic(int nPoints, String afMethodName, boolean withinVesselOnly,
+         int edgeMargin) {
       if (dataSource_ == null || !exploring_ || loadedData_ || !hasPositionRoi()) {
          setRefineZStatus("Draw an ROI first.");
          return;
@@ -2798,11 +2950,28 @@ public void startRefineZAutomatic(int nPoints, String afMethodName, boolean with
          setRefineZStatus(ex.getMessage());
          return;
       }
+      if (edgeMargin > 0) {
+         java.util.List<Tile> interior = excludeEdgeTiles(tiles, edgeMargin);
+         // Only apply the exclusion if it leaves something to focus on; otherwise the grid is
+         // too thin for the requested margin and we fall back to the full set. Warn modally so
+         // the fallback is not lost under the "Refining Z..."/progress status updates that follow.
+         if (!interior.isEmpty()) {
+            tiles = interior;
+         } else {
+            JOptionPane.showMessageDialog(refineZFrame_ != null ? refineZFrame_ : frame_,
+                  "The edge margin of " + edgeMargin + " tile(s) excludes every tile in this "
+                  + "grid.\nRefine Z will use all tiles instead.",
+                  "Refine Z", JOptionPane.WARNING_MESSAGE);
+         }
+      }
       java.util.List<Tile> chosen = chooseSpreadTiles(tiles, nPoints);
       if (chosen.isEmpty()) {
          setRefineZStatus("No tiles to refine.");
          return;
       }
+      // The spread-sampling order is travel-arbitrary; reorder into a short stage route so
+      // autofocus visits points with minimal XY motion.
+      chosen = orderForTravel(chosen);
       setRefineZRunningUi(true);
       setRefineZStatus("Refining Z...");
       refineZWorker_ = new RefineZWorker(chosen, zStages, afMethodName);

plugins/Explorer/src/main/java/org/micromanager/explorer/RefineZFrame.java

@@ -16,6 +16,7 @@
 import org.micromanager.Studio;
 import org.micromanager.internal.positionlist.utils.ZGenerator;
 import org.micromanager.internal.utils.WindowPositioning;
+import org.micromanager.propertymap.MutablePropertyMapView;
 
 /**
  * Stand-alone window for Refine Z. Opened from the Explorer dialog's "Refine Z..." button so the
@@ -28,15 +29,20 @@
  */
 public class RefineZFrame extends JFrame {
 
+   private static final String EDGE_MARGIN = "RefineZEdgeMargin";
+   private static final String AF_METHOD = "RefineZAutofocusMethod";
+
    private final Studio studio_;
    private final ExplorerManager explorerManager_;
    private final ExplorerFrame explorerFrame_;
+   private final MutablePropertyMapView settings_;
 
    private final JRadioButton autoRadio_;
    private final JRadioButton manualRadio_;
    private final JComboBox<ZGenerator.Type> interpCombo_;
    private final JComboBox<String> afCombo_;
    private final JSpinner pointsSpinner_;
+   private final JSpinner edgeMarginSpinner_;
    private final JButton startButton_;
    private final JButton cancelButton_;
    private final JButton setButton_;
@@ -62,6 +68,7 @@ public RefineZFrame(Studio studio, ExplorerManager explorerManager,
       studio_ = studio;
       explorerManager_ = explorerManager;
       explorerFrame_ = explorerFrame;
+      settings_ = studio_.profile().getSettings(RefineZFrame.class);
 
       setTitle("Refine Z");
       URL iconUrl = getClass().getResource("/org/micromanager/icons/microscope.gif");
@@ -104,6 +111,7 @@ public RefineZFrame(Studio studio, ExplorerManager explorerManager,
       afCombo_.addActionListener(e -> {
          Object sel = afCombo_.getSelectedItem();
          if (sel != null && !syncingAf_) {
+            settings_.putString(AF_METHOD, sel.toString());
             try {
                studio_.getAutofocusManager().setAutofocusMethodByName(sel.toString());
             } catch (Exception ex) {
@@ -112,16 +120,29 @@ public RefineZFrame(Studio studio, ExplorerManager explorerManager,
          }
       });
       panel.add(afCombo_);
+      // Created before the Start button so its action listener can read it (final field).
+      edgeMarginSpinner_ = new JSpinner(new SpinnerNumberModel(
+            settings_.getInteger(EDGE_MARGIN, 0), 0, 99, 1));
+      edgeMarginSpinner_.setToolTipText(
+            "Exclude reference points within this many tiles of the grid edge. "
+            + "Outer tiles often only partially overlap the sample and can fail autofocus. "
+            + "0 = use all tiles.");
+      edgeMarginSpinner_.addChangeListener(e ->
+            settings_.putInteger(EDGE_MARGIN, (Integer) edgeMarginSpinner_.getValue()));
       startButton_ = new JButton("Start");
       startButton_.addActionListener(e -> {
          Object af = afCombo_.getSelectedItem();
          explorerManager_.startRefineZAutomatic(
                (Integer) pointsSpinner_.getValue(),
                af != null ? af.toString() : null,
-               explorerFrame_.isWithinVesselSelected());
+               explorerFrame_.isWithinVesselSelected(),
+               (Integer) edgeMarginSpinner_.getValue());
       });
       panel.add(startButton_, "wrap");
 
+      panel.add(new JLabel("Exclude edge margin (tiles):"), "split 2");
+      panel.add(edgeMarginSpinner_, "wrap");
+
       cancelButton_ = new JButton("Cancel");
       cancelButton_.setToolTipText("Cancel the running automatic Refine Z");
       cancelButton_.addActionListener(e -> explorerManager_.cancelRefineZ());
@@ -155,8 +176,11 @@ public RefineZFrame(Studio studio, ExplorerManager explorerManager,
 
       add(panel, "growx, wrap");
 
-      // Populate autofocus methods and select the current interpolation method.
+      // Populate autofocus methods. Restore the method saved in the profile when it is still
+      // available, applying it to the main MM window so the two stay in sync; otherwise fall back
+      // to whatever method MM currently has active.
       refreshAfMethods();
+      restoreSavedAfMethod();
       explorerManager_.setRefineZMethod((ZGenerator.Type) interpCombo_.getSelectedItem());
 
       // Re-sync the AF method from the main window each time this window regains focus, since the
@@ -197,6 +221,25 @@ private void refreshAfMethods() {
       }
    }
 
+   /**
+    * Selects the autofocus method remembered in the profile (if present and still installed) and
+    * pushes it to the main MM window. Called once at construction so a remembered choice wins over
+    * MM's current method; later focus-driven {@link #refreshAfMethods()} calls follow MM.
+    */
+   private void restoreSavedAfMethod() {
+      String saved = settings_.getString(AF_METHOD, null);
+      if (saved == null || saved.isEmpty()) {
+         return;
+      }
+      for (int i = 0; i < afCombo_.getItemCount(); i++) {
+         if (saved.equals(afCombo_.getItemAt(i))) {
+            // Not syncing: we want this selection to propagate to the AutofocusManager.
+            afCombo_.setSelectedItem(saved);
+            return;
+         }
+      }
+   }
+
    /** Notifies whether an automatic Refine-Z run is in progress; switches to EDT. */
    public void setRefineZRunning(boolean running) {
       SwingUtilities.invokeLater(() -> {
@@ -218,6 +261,7 @@ private void updateEnabled() {
       autoRadio_.setEnabled(!running_);
       manualRadio_.setEnabled(!running_);
       pointsSpinner_.setEnabled(auto && !running_);
+      edgeMarginSpinner_.setEnabled(auto && !running_);
       afCombo_.setEnabled(auto && !running_);
       startButton_.setEnabled(auto && !running_);
       cancelButton_.setEnabled(auto && running_);