Improve "Show only selected structure" feature in PathManagerUI

Author: tferr

src/main/java/sc/fiji/snt/PathAndFillManager.java

@@ -3690,8 +3690,10 @@ protected void update3DViewerContents() {
             else if (selected) color3f = plugin.selectedColor3f;
             else color3f = plugin.deselectedColor3f;
 
+            final boolean isolationOk = !plugin.isTreeIsolationActive()
+                    || p.getTreeID() == plugin.getIsolatedTreeID();
             p.updateContent3D(plugin.univ, // The appropriate 3D universe
-                    (selected || !showOnlySelectedPaths), // Visible at all?
+                    (selected || !showOnlySelectedPaths) && isolationOk, // Visible at all?
                     plugin.getPaths3DDisplay(), // How to display?
                     color3f, plugin.colorImage); // Colour?
 

src/main/java/sc/fiji/snt/PathManagerUI.java

@@ -739,7 +739,10 @@ protected void done() {
         swcTypeMenu.addSeparator();
         swcTypeMenu.add(jmi);
         if (applyPromptOptions && pathAndFillManager.size() > 0 && guiUtils
-                .getConfirmation("Apply new color options to all paths?", "Apply Colors"))
+                .getConfirmation(plugin.isTreeIsolationActive()
+                        ? "Apply new color options to all paths, including structures currently hidden by "
+                                + "the isolation filter?"
+                        : "Apply new color options to all paths?", "Apply Colors"))
         {
             final List<Path> allPaths = pathAndFillManager.getPathsFiltered();
             if (assignColors) {
@@ -4390,8 +4393,15 @@ private class DeleteCommand implements PathCommand {
             @Override
             public void execute(List<Path> selectedPaths, String cmd) {
                 boolean assumeAll = tree.getSelectionCount() == 0 || tree.getSelectionCount() == tree.getNumberOfNodes();
-                String message = assumeAll ? "Are you really sure you want to delete all paths?"
-                        : "Delete the selected " + selectedPaths.size() + " path(s)?";
+                String message;
+                if (!assumeAll) {
+                    message = "Delete the selected " + selectedPaths.size() + " path(s)?";
+                } else if (plugin.isTreeIsolationActive()) {
+                    message = "Delete all " + selectedPaths.size() + " listed path(s)? (Structures currently "
+                            + "hidden will <i>not</i> be affected.)";
+                } else {
+                    message = "Are you really sure you want to delete all paths?";
+                }
                 if (guiUtils.getConfirmation(message, "Confirm Deletion?")) {
                     deletePaths(selectedPaths);
                 }
@@ -6289,6 +6299,7 @@ void restoreFullModelState() {
             arborChoice = null;
             tree.setModel(fullTreeModel);
             hideOthersButton.setSelected(false);
+            plugin.clearIsolatedTreeID(); // undo any active canvas/Bdv/Bvv isolation from applyHideOthers(true)
             // Re-enable sorting now that the full (multi-arbor) model is restored:
             // applyHideOthers(true) disables it while a single arbor is isolated, and
             // this path (e.g. the "show all structures" button) must undo that.
@@ -6383,7 +6394,11 @@ private void expandAndRevealTree(final String label) {
             }
         }
 
-        /** Show only the chosen arbor or restore the full list. */
+        /**
+         * Show only the chosen arbor (in both the JTree and every tracing viewer - classic canvas,
+         * legacy 3D viewer, and Bdv/Bvv, via {@link SNT#setIsolatedTreeID(int)}) or restore the full
+         * list/display.
+         */
         private void applyHideOthers(final boolean hide) {
             if (fullTreeModel == null || arborChoice == null) return;
 
@@ -6394,10 +6409,17 @@ private void applyHideOthers(final boolean hide) {
                 final Path[] primaryPaths = pathAndFillManager.getPathsStructured();
                 tree.setModel(new HelpfulTreeModel(primaryPaths, arborChoice));
                 sortArborsButton.setEnabled(false);
+                // Mirror the JTree's own filtering in the tracing viewers: getTree(String) returns
+                // null if arborChoice no longer matches any tree (e.g. deleted between UI updates),
+                // in which case clearing isolation is the safer fallback over isolating a stale ID
+                final Tree isolatedTree = pathAndFillManager.getTree(arborChoice);
+                plugin.setIsolatedTreeID((isolatedTree != null) ? isolatedTree.getTreeID() : -1);
+                if (isolatedTree != null) zoomToBoundingBox(isolatedTree.list()); // zoom to selected choice
             } else {
                 hideOthersButton.setSelected(false); // ensure sync
                 tree.setModel(fullTreeModel); // will call reload
                 sortArborsButton.setEnabled(true);
+                plugin.clearIsolatedTreeID();
             }
             GuiUtils.JTrees.expandAllNodes(tree);
             // 3) Restore selection if that exists in the new model

src/main/java/sc/fiji/snt/SNT.java

@@ -245,6 +245,14 @@ public String toString() {
 	protected volatile boolean snapCursor;
 	protected volatile boolean showOnlySelectedPaths;
 	protected volatile boolean showOnlyActiveCTposPaths;
+	/**
+	 * ID of the single tree (arbor) currently isolated for display in PathManagerUI or -1 if no isolation is active
+	 * Orthogonal to path selection: unlike {@code showOnlySelectedPaths}, isolating a tree does not alter which paths
+	 * are considered "selected", nor their rendered color - it only hides paths belonging to other trees.
+	 * Set via {@link #setIsolatedTreeID(int)}; consulted by {@link TracerCanvas}, the legacy 3D viewer
+	 * ({@link PathAndFillManager#update3DViewerContents()}), and Bdv/Bvv ({@code Bvv.PathOverlay}).
+	 */
+	protected volatile int isolatedTreeID = -1;
 	protected volatile boolean autoCT;
 	private boolean drawDiameters;
 	protected double manualRadius;
@@ -2645,8 +2653,7 @@ public synchronized ImagePlus makePathVolume(final Collection<Path> paths, final
 			newStack.addSlice(null, thisSlice.convertToByteProcessor(false));
 		}
 
-		final ImagePlus newImp = new ImagePlus(xy.getShortTitle() +
-				" Rendered Paths", newStack);
+		final ImagePlus newImp = new ImagePlus("Rasterized Paths", newStack);
 		newImp.setCalibration(getCalibration());
 		return newImp;
 	}
@@ -4949,6 +4956,35 @@ public void setShowOnlySelectedPaths(final boolean showOnlySelectedPaths) {
 		setShowOnlySelectedPaths(showOnlySelectedPaths, true);
 	}
 
+	/**
+	 * Isolates a single tree (arbor) for display across every tracing viewer, hiding paths belonging to any other tree.
+	 * Orthogonal to {@link #setShowOnlySelectedPaths(boolean)}: does not touch path selection or rendered colors, it
+	 * only restricts which trees are candidates for display at all. Pass -1 (or call {@link #clearIsolatedTreeID()}) to
+	 * lift the restriction.
+	 *
+	 * @param treeID the ID of the tree to isolate (see {@link Tree#getTreeID()}), or -1 to show all
+	 * @see PathManagerUI
+	 */
+	public void setIsolatedTreeID(final int treeID) {
+		this.isolatedTreeID = treeID;
+		updateTracingViewers(true);
+	}
+
+	/** Convenience for {@code setIsolatedTreeID(-1)}: lifts any active tree isolation. */
+	public void clearIsolatedTreeID() {
+		setIsolatedTreeID(-1);
+	}
+
+	/** @return the ID of the currently isolated tree, or -1 if no isolation is active */
+	public int getIsolatedTreeID() {
+		return isolatedTreeID;
+	}
+
+	/** @return whether a single tree is currently isolated for display (see {@link #setIsolatedTreeID(int)}) */
+	public boolean isTreeIsolationActive() {
+		return isolatedTreeID != -1;
+	}
+
 	/**
 	 * Gets the Image associated with a view pane.
 	 *

src/main/java/sc/fiji/snt/TracerCanvas.java

@@ -127,6 +127,7 @@ protected void drawOverlay(final Graphics2D g) {
 				// not the fitted copy, so test against p rather than drawPath
 				final boolean isSelected = pathAndFillManager.isSelected(p);
 				if (!isSelected && plugin.isOnlySelectedPathsVisible()) continue;
+				if (plugin.isTreeIsolationActive() && p.getTreeID() != plugin.getIsolatedTreeID()) continue;
 				if (enforceActiveCTpos && (imp.getC() != drawPath
 					.getChannel() || imp.getT() != drawPath.getFrame()))
 				{

src/main/java/sc/fiji/snt/Tree.java

@@ -1271,6 +1271,27 @@ public String getLabel() {
 		return label;
 	}
 
+	/**
+	 * Returns the ID shared by every {@link Path} in this tree (see {@link Path#getTreeID()}), i.e., the arbor's
+	 * identity as tracked by the {@link PathAndFillManager} that assigned it.
+	 * <p>
+	 * <b>Uniqueness is scoped to a single {@link PathAndFillManager} instance</b>, e.g., all the Trees of a running SNT
+	 * session, or all the Trees parsed from one multi-tree reconstruction file. It is <i>not</i> guaranteed across
+	 * independently-created Trees: each standalone parse (a call to {@link #fromFile(String)}, or each individual file
+	 * visited by {@link #listFromFile(String)}/{@link #listFromDir(String)}) gets its own manager with its own ID
+	 * sequence starting from scratch, so two such Trees - even from the same {@code listFromDir()} call - may share the
+	 * same ID. Once a Tree is merged into a live manager (e.g., via {@link PathAndFillManager#addTree(Tree)}), its
+	 * paths are assigned fresh, unique, collision-free IDs scoped to that manager; any IDs from the Tree's
+	 * original source file are discarded.
+	 * </p>
+	 *
+	 * @return the tree ID, or -1 if this tree has no paths (a treeID is always &gt;= 1 otherwise -
+	 *         see {@code PathAndFillManager#maxUsedTreeID})
+	 */
+	public int getTreeID() {
+		return (isEmpty()) ? -1 : list().getFirst().getTreeID();
+	}
+
 	public List<SWCPoint> getNodesAsSWCPoints() throws IllegalArgumentException {
 		if (isEmpty()) return new ArrayList<>();
 		initPathAndFillManager();

src/main/java/sc/fiji/snt/viewer/Bvv.java

@@ -3812,18 +3812,35 @@ boolean isRenderingEnable() {
         }
 
         void updatePaths() {
-            final Collection<Tree> trees = sntViewer.getRenderedTrees();
+            final Collection<Tree> trees = filterIsolated(sntViewer.getRenderedTrees());
             overlayRenderer.updatePaths(trees);
             viewerPanel.requestRepaint();
         }
 
         void updatePaths(final Tree transientTree) {
             final Collection<Tree> trees = new ArrayList<>(sntViewer.getRenderedTrees());
             if (transientTree != null) trees.add(transientTree);
-            overlayRenderer.updatePaths(trees);
+            overlayRenderer.updatePaths(filterIsolated(trees));
             viewerPanel.requestRepaint();
         }
 
+        /**
+         * Restricts {@code trees} to the single tree isolated via {@link SNT#setIsolatedTreeID(int)}
+         * (e.g. {@code PathManagerUI}'s "Hide others" toolbar button), if any; a no-op passthrough
+         * otherwise. Shared by both {@code updatePaths()} overloads above, and - since {@code Bdv}
+         * reuses this same {@code PathOverlay} class (see its class javadoc) - covers both viewers.
+         */
+        private Collection<Tree> filterIsolated(final Collection<Tree> trees) {
+            final SNT snt = sntViewer.getSNT();
+            if (snt == null || !snt.isTreeIsolationActive()) return trees;
+            final int isolatedID = snt.getIsolatedTreeID();
+            final List<Tree> filtered = new ArrayList<>();
+            for (final Tree tree : trees) {
+                if (tree.getTreeID() == isolatedID) filtered.add(tree);
+            }
+            return filtered;
+        }
+
         /**
          * Lightweight alternative to {@link #updatePaths()} for pure selection changes: patches
          * color/thickness in place for already-rendered trees. See {@link OverlayRenderer#recolor(Tree)}.