@@ -92,8 +92,9 @@ Step 3: Add Tissue Detection
 3. Configure the ``DetectTissueInStackAndReturn`` node with the following parameters:
 
     1. :guilabel:`planes`: number of z-planes checked for tissue.
-    2. :guilabel:`percentage`: required image fraction containing tissue to return ``true``.
-    3. :guilabel:`detect_func`: tissue detection function from :doc:`remove_empty_tiles </05_reference/_autosummary/navigate.model.features.remove_empty_tiles>`. If set to ``None``, **navigate** uses ``detect_tissue()``.
+    2. :guilabel:`percentage`: required fraction of tissue-positive frames in the stack to return ``true``.
+    3. :guilabel:`detect_func`: tissue detection function from :doc:`remove_empty_tiles </05_reference/_autosummary/navigate.model.features.remove_empty_tiles>`. If set to ``None``, **navigate** uses ``detect_tissue3()``.
+    4. :guilabel:`threshold`: intensity threshold passed to the tissue detection function.
 
 .. tip::
 
 
@@ -35,6 +35,7 @@
 from queue import Queue
 
 # Third Party Imports
+from skimage.filters import threshold_otsu
 
 # Local Imports
 from navigate.model.analysis.boundary_detect import find_tissue_boundary_2d
@@ -132,6 +133,30 @@ def detect_tissue2(image_data, percentage=0.0):
     return False
 
 
+def detect_tissue3(image_data, threshold=150):
+    """Detect tissue in an image using the computed Otsu threshold.
+
+    This function computes the Otsu threshold value for an image and compares that
+    computed value against a minimum threshold.
+
+    Parameters:
+    -----------
+    image_data : numpy.ndarray
+        The input image data as a NumPy array.
+    threshold : float, optional
+        The minimum computed Otsu threshold required for tissue detection.
+        Default is 150.
+
+    Returns:
+    --------
+    bool
+        True if the computed Otsu threshold is greater than or equal to
+        ``threshold``; False otherwise.
+    """
+    t = threshold_otsu(image_data)
+    return t >= threshold
+
+
 class DetectTissueInStack:
     """Detect Tissue in a Stack of Images.
 
@@ -140,7 +165,9 @@ class DetectTissueInStack:
     presence.
     """
 
-    def __init__(self, model, planes=1, percentage=0.75, detect_func=None):
+    def __init__(
+        self, model, planes=1, percentage=0.75, detect_func=None, threshold=150
+    ):
         """Initialize the DetectTissueInStack class.
 
         Parameters:
@@ -150,11 +177,14 @@ def __init__(self, model, planes=1, percentage=0.75, detect_func=None):
         planes : int, optional
             The number of Z planes to capture in the stack. Default is 1.
         percentage : float, optional
-            The minimum percentage of tissue required to consider a frame as having
-            tissue. Default is 0.75 (75%).
+            The minimum fraction of tissue-positive frames required for the stack to
+            be considered as having tissue. Default is 0.75 (75%).
         detect_func : function, optional
             The custom tissue detection function to use. If not specified, the default
-            `detect_tissue` function will be used.
+            `detect_tissue3` function will be used. The function must accept
+            ``(image_data, threshold)`` and return whether the frame contains tissue.
+        threshold : float, optional
+            The intensity threshold passed to ``detect_func``. Default is 150.
         """
 
         #: navigate.model.Model: The model object representing the microscope.
@@ -163,14 +193,16 @@ def __init__(self, model, planes=1, percentage=0.75, detect_func=None):
         #: int: The number of Z planes to capture in the stack.
         self.planes = int(planes)
 
-        #: float: The minimum percentage of tissue required to consider a frame as
-        # having tissue.
+        #: float: The intensity threshold for tissue detection.
+        self.threshold = float(threshold)
+
+        #: float: The minimum percentage of images having tissue in a stack.
         self.percentage = float(percentage)
 
         # if not specify a detect function, use the default one
         if detect_func is None:
             #: function: The tissue detection function used to analyze image frames.
-            self.detect_func = detect_tissue
+            self.detect_func = detect_tissue3
         else:
             self.detect_func = detect_func
 
@@ -198,14 +230,26 @@ def pre_func_signal(self):
         """
 
         microscope_config = self.model.configuration["experiment"]["MicroscopeState"]
+
+        # primary z and f axes, secondary stack settings
+        self.primary_z_axis = microscope_config.get("primary_z_axis", "z")
+        self.primary_f_axis = microscope_config.get("primary_f_axis", "f")
+
         # get current z and f position
         pos = self.model.get_stage_position()
 
+        #: current stage position
+        self.starting_pos = pos
+
         #: float: The current Z position of the microscope stage.
-        self.current_z_pos = pos["z_pos"] + float(microscope_config["start_position"])
+        self.current_z_pos = pos[f"{self.primary_z_axis}_pos"] + float(
+            microscope_config["start_position"]
+        )
 
         #: float: The current F position of the microscope stage.
-        self.current_f_pos = pos["f_pos"] + float(microscope_config["start_focus"])
+        self.current_f_pos = pos[f"{self.primary_f_axis}_pos"] + float(
+            microscope_config["start_focus"]
+        )
 
         # calculate Z and F stage step sizes
         z_pos_range = float(microscope_config["end_position"]) - float(
@@ -239,11 +283,15 @@ def in_func_signal(self):
 
         # move to Z anf F position
         self.model.logger.debug(
-            f"move to position (z, f): ({self.current_z_pos}, {self.current_f_pos}), "
+            f"move to position ({self.primary_z_axis}, {self.primary_f_axis}): "
+            f"({self.current_z_pos}, {self.current_f_pos}), "
             f"{self.scan_num}, {self.model.frame_id}"
         )
         self.model.move_stage(
-            {"z_abs": self.current_z_pos, "f_abs": self.current_f_pos},
+            {
+                f"{self.primary_z_axis}_abs": self.current_z_pos,
+                f"{self.primary_f_axis}_abs": self.current_f_pos,
+            },
             wait_until_done=True,
         )
         self.scan_num += 1
@@ -260,9 +308,21 @@ def end_func_signal(self):
             True if the signal phase should end, False otherwise.
         """
         self.model.logger.debug(
-            f"*** detect tissue signal end function: " f"{self.scan_num}"
+            f"*** detect tissue signal end function: {self.scan_num}"
         )
         if self.scan_num >= self.planes:
+            # move stage back to starting position
+            self.model.move_stage(
+                {
+                    f"{self.primary_z_axis}_abs": self.starting_pos[
+                        f"{self.primary_z_axis}_pos"
+                    ],
+                    f"{self.primary_f_axis}_abs": self.starting_pos[
+                        f"{self.primary_f_axis}_pos"
+                    ],
+                },
+                wait_until_done=True,
+            )
             return True
         self.current_z_pos += self.z_step
         self.current_f_pos += self.f_step
@@ -281,6 +341,9 @@ def pre_func_data(self):
         #: int: The number of received frames.
         self.received_frames = 0
 
+        #: int: The number of images having tissue detected.
+        self.tissue_frames = 0
+
         #: bool: Flag indicating whether tissue is detected.
         self.has_tissue_flag = False
 
@@ -305,13 +368,16 @@ def in_func_data(self, frame_ids):
         if not self.has_tissue_flag:
             for frame_id in frame_ids:
                 # check if the frame has tissue
-                r = self.detect_func(self.model.data_buffer[frame_id], self.percentage)
+                r = self.detect_func(self.model.data_buffer[frame_id], self.threshold)
                 if r:
-                    self.model.logger.debug(
-                        f"*** this frame has enough percentage of tissue!{frame_id}"
-                    )
-                    self.has_tissue_flag = True
-                    break
+                    self.model.logger.debug(f"*** this frame has tissue!{frame_id}")
+                    self.tissue_frames += 1
+                    # self.has_tissue_flag = True
+                    self.has_tissue_flag = (
+                        self.tissue_frames / self.planes
+                    ) >= self.percentage
+                    if self.has_tissue_flag:
+                        break
         self.received_frames += len(frame_ids)
         return self.has_tissue_flag
 
@@ -330,7 +396,9 @@ def end_func_data(self):
 
 
 class DetectTissueInStackAndReturn(DetectTissueInStack):
-    def __init__(self, model, planes=1, percentage=0.75, detect_func=None):
+    def __init__(
+        self, model, planes=1, percentage=0.75, detect_func=None, threshold=150
+    ):
         """Initialize the DetectTissueInStackAndReturn class.
 
         Parameters:
@@ -340,13 +408,16 @@ def __init__(self, model, planes=1, percentage=0.75, detect_func=None):
         planes : int, optional
             The number of Z planes to capture in the stack. Default is 1.
         percentage : float, optional
-            The minimum percentage of tissue required to consider a frame as having
-            tissue. Default is 0.75 (75%).
+            The minimum fraction of tissue-positive frames required for the stack to
+            be considered as having tissue. Default is 0.75 (75%).
         detect_func : function, optional
             The custom tissue detection function to use. If not specified, the default
-            `detect_tissue` function will be used.
+            `detect_tissue3` function will be used. The function must accept
+            ``(image_data, threshold)`` and return whether the frame contains tissue.
+        threshold : float, optional
+            The intensity threshold passed to ``detect_func``. Default is 150.
         """
-        super().__init__(model, planes, percentage, detect_func)
+        super().__init__(model, planes, percentage, detect_func, threshold)
 
         self.detect_tissue_queue = Queue()
         self.result_sent_flag = False
@@ -429,7 +500,13 @@ class DetectTissueInStackAndRecord(DetectTissueInStack):
     """
 
     def __init__(
-        self, model, planes=1, percentage=0.75, position_records=[], detect_func=None
+        self,
+        model,
+        planes=1,
+        percentage=0.75,
+        position_records=None,
+        detect_func=None,
+        threshold=150,
     ):
         """Initialize the DetectTissueInStackAndRecord class.
 
@@ -440,18 +517,23 @@ def __init__(
         planes : int, optional
             The number of Z planes to capture in the stack. Default is 1.
         percentage : float, optional
-            The minimum percentage of tissue required to consider a frame as having
-            tissue. Default is 0.75 (75%).
+            The minimum fraction of tissue-positive frames required for the stack to
+            be considered as having tissue. Default is 0.75 (75%).
         position_records : list, optional
-            A list to record positions where tissue was detected. Default is an empty
-            list.
+            A list to record positions where tissue was detected. A new list is
+            created when no list is provided.
         detect_func : function, optional
             The custom tissue detection function to use. If not specified, the default
-            `detect_tissue` function will be used.
+            `detect_tissue3` function will be used. The function must accept
+            ``(image_data, threshold)`` and return whether the frame contains tissue.
+        threshold : float, optional
+            The intensity threshold passed to ``detect_func``. Default is 150.
         """
-        super().__init__(model, planes, percentage, detect_func)
+        super().__init__(model, planes, percentage, detect_func, threshold)
 
         #: list: A list to record positions where tissue was detected.
+        if position_records is None:
+            position_records = []
         self.position_records = position_records
 
     def pre_func_data(self):
 
@@ -0,0 +1,72 @@
+import numpy as np
+
+from navigate.model.features.feature_related_functions import SharedList
+from navigate.model.features.remove_empty_tiles import (
+    DetectTissueInStack,
+    DetectTissueInStackAndRecord,
+    DetectTissueInStackAndReturn,
+    detect_tissue3,
+)
+
+
+class _Logger:
+    def debug(self, *args, **kwargs):
+        pass
+
+
+class _Model:
+    def __init__(self):
+        self.data_buffer = {}
+        self.logger = _Logger()
+
+
+def test_return_detector_preserves_legacy_positional_arguments():
+    feature = DetectTissueInStackAndReturn(_Model(), 1, 0.5, None)
+
+    assert feature.planes == 1
+    assert feature.percentage == 0.5
+    assert feature.threshold == 150
+    assert feature.detect_func is detect_tissue3
+
+
+def test_record_detector_preserves_legacy_positional_records_argument():
+    records = SharedList([], "records")
+
+    feature = DetectTissueInStackAndRecord(_Model(), 5, 0.75, records)
+
+    assert feature.planes == 5
+    assert feature.percentage == 0.75
+    assert feature.threshold == 150
+    assert feature.position_records is records
+
+
+def test_record_detector_default_records_are_not_shared():
+    first = DetectTissueInStackAndRecord(_Model())
+    second = DetectTissueInStackAndRecord(_Model())
+
+    first.position_records.append(True)
+
+    assert second.position_records == []
+
+
+def test_stack_decision_uses_percentage_of_tissue_positive_frames():
+    model = _Model()
+    model.data_buffer = {0: False, 1: True, 2: True}
+    feature = DetectTissueInStack(
+        model,
+        planes=3,
+        percentage=2 / 3,
+        detect_func=lambda frame, threshold: frame,
+    )
+    feature.pre_func_data()
+
+    assert not feature.in_func_data([0, 1])
+    assert feature.in_func_data([2])
+
+
+def test_detect_tissue3_documents_computed_otsu_threshold_contract():
+    assert "computed Otsu threshold" in (detect_tissue3.__doc__ or "")
+
+    image_data = np.full((4, 4), 200, dtype=np.uint16)
+
+    assert detect_tissue3(image_data, threshold=150)