Explorer: Refine Z Autofocus can now exclude edge tiles

Author: nicost

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'
@@ -2778,7 +2831,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,6 +2852,16 @@ 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.
+         if (!interior.isEmpty()) {
+            tiles = interior;
+         } else {
+            setRefineZStatus("Edge margin too large for this grid; using all tiles.");
+         }
+      }
       java.util.List<Tile> chosen = chooseSpreadTiles(tiles, nPoints);
       if (chosen.isEmpty()) {
          setRefineZStatus("No tiles to refine.");

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_);