neuro-sam 0.1.0__py3-none-any.whl

neuro_sam/brightest_path_lib/connected_componen.py

@@ -0,0 +1,329 @@
+import cc3d
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage import io
+from matplotlib.colors import ListedColormap
+import os
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+def analyze_dendrite_stack(image_path, delta_value=10, connectivity=26):
+    """
+    Analyze 3D dendrite TIFF stack using connected-components-3d with delta parameter
+    
+    Parameters:
+    - image_path: Path to the TIFF stack
+    - delta_value: Delta parameter for cc3d (controls intensity similarity threshold)
+    - connectivity: Neighborhood connectivity (6/18/26 for 3D)
+    """
+    # Load the image stack
+    print(f"Loading 3D TIFF stack from {image_path}")
+    image = io.imread(image_path)
+    
+    # Print image info
+    print(f"Image stack shape: {image.shape}")
+    print(f"Image dtype: {image.dtype}")
+    print(f"Value range: {image.min()} to {image.max()}")
+    
+    # Apply connected components with delta parameter
+    print(f"Running connected components with delta={delta_value}, connectivity={connectivity}")
+    labels_out = cc3d.connected_components(image, delta=delta_value, connectivity=connectivity)
+    
+    # Get number of unique components (excluding background 0)
+    unique_labels = np.unique(labels_out)
+    num_components = len(unique_labels) - (1 if 0 in unique_labels else 0)
+    print(f"Found {num_components} connected components")
+    
+    # Get component statistics
+    stats = cc3d.statistics(labels_out)
+    
+    # Sort components by size (voxel count) to identify main dendrites vs spines
+    component_sizes = [(label, stats["voxel_counts"][label]) for label in stats["voxel_counts"]]
+    component_sizes.sort(key=lambda x: x[1], reverse=True)
+    
+    # Print sizes of largest components
+    print("\nLargest components (possibly main dendrites):")
+    for i, (label, size) in enumerate(component_sizes[:5]):
+        if i >= len(component_sizes):
+            break
+        print(f"Component {label}: {size} voxels")
+    
+    # Print sizes of some medium components (might be spines)
+    if len(component_sizes) > 10:
+        print("\nMedium-sized components (possibly spines):")
+        middle_idx = len(component_sizes) // 2
+        for i, (label, size) in enumerate(component_sizes[middle_idx:middle_idx+5]):
+            if middle_idx + i >= len(component_sizes):
+                break
+            print(f"Component {label}: {size} voxels")
+    
+    # Visualize several slices from the stack
+    n_slices = min(4, image.shape[0])
+    slice_indices = np.linspace(0, image.shape[0]-1, n_slices, dtype=int)
+    
+    # Make a random colormap for visualization
+    np.random.seed(42)  # For reproducible colors
+    colors = np.random.rand(num_components+1, 3)
+    colors[0] = [0, 0, 0]  # background black
+    cmap = ListedColormap(colors)
+    
+    fig, axs = plt.subplots(n_slices, 2, figsize=(12, 4*n_slices))
+    
+    if n_slices == 1:
+        axs = np.array([axs])  # Make it 2D for consistent indexing
+    
+    for i, slice_idx in enumerate(slice_indices):
+        # Original image slice
+        im1 = axs[i, 0].imshow(image[slice_idx], cmap='gray')
+        axs[i, 0].set_title(f'Original Image (Slice {slice_idx})')
+        divider = make_axes_locatable(axs[i, 0])
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        plt.colorbar(im1, cax=cax)
+        
+        # Connected components slice
+        im2 = axs[i, 1].imshow(labels_out[slice_idx], cmap=cmap)
+        axs[i, 1].set_title(f'Connected Components (Slice {slice_idx})')
+        divider = make_axes_locatable(axs[i, 1])
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        plt.colorbar(im2, cax=cax)
+    
+    plt.tight_layout()
+    plt.show()
+    
+    # Optional: Show 3D maximum intensity projection
+    if image.shape[0] > 1:  # Only if it's truly 3D
+        print("\nCreating maximum intensity projections...")
+        
+        # Create maximum intensity projections
+        orig_z_proj = np.max(image, axis=0)
+        labels_z_proj = np.max(labels_out, axis=0)
+        
+        fig, axs = plt.subplots(1, 2, figsize=(14, 7))
+        
+        # Original MIP
+        im1 = axs[0].imshow(orig_z_proj, cmap='gray')
+        axs[0].set_title('Original Image (Z-Max Projection)')
+        divider = make_axes_locatable(axs[0])
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        plt.colorbar(im1, cax=cax)
+        
+        # Labels MIP
+        im2 = axs[1].imshow(labels_z_proj, cmap=cmap)
+        axs[1].set_title('Connected Components (Z-Max Projection)')
+        divider = make_axes_locatable(axs[1])
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        plt.colorbar(im2, cax=cax)
+        
+        plt.tight_layout()
+        plt.show()
+    
+    return labels_out, stats
+
+def delta_comparison_for_dendrites(image_path, delta_values=[5, 15, 30, 50], connectivity=26):
+    """
+    Compare different delta values for dendrite/spine segmentation
+    """
+    # Load the 3D stack
+    print(f"Loading 3D TIFF stack from {image_path}")
+    image = io.imread(image_path)
+    
+    print(f"Image stack shape: {image.shape}")
+    
+    # Choose a representative slice in the middle
+    if len(image.shape) >= 3:
+        middle_slice = image.shape[0] // 2
+    else:
+        middle_slice = 0
+        print("Warning: Image appears to be 2D, not a stack")
+    
+    # Determine number of rows (original + each delta value)
+    n_rows = len(delta_values) + 1
+    
+    fig, axs = plt.subplots(n_rows, 1, figsize=(10, 5*n_rows))
+    
+    # Show original image
+    im0 = axs[0].imshow(image[middle_slice], cmap='gray')
+    axs[0].set_title(f'Original Image (Slice {middle_slice})')
+    plt.colorbar(im0, ax=axs[0], fraction=0.046, pad=0.04)
+    
+    # Process with different delta values
+    results = []
+    
+    for i, delta in enumerate(delta_values):
+        print(f"Processing with delta={delta}...")
+        # Apply connected components
+        labels = cc3d.connected_components(image, delta=delta, connectivity=connectivity)
+        results.append(labels)
+        
+        # Get component count
+        num_components = len(np.unique(labels)) - 1
+        
+        # Make a random colormap for visualization
+        np.random.seed(i)  # Different seed for each delta
+        colors = np.random.rand(num_components+1, 3)
+        colors[0] = [0, 0, 0]  # background black
+        cmap = ListedColormap(colors)
+        
+        # Display the result
+        im = axs[i+1].imshow(labels[middle_slice], cmap=cmap)
+        axs[i+1].set_title(f'Connected Components with delta={delta} ({num_components} components)')
+        plt.colorbar(im, ax=axs[i+1], fraction=0.046, pad=0.04)
+    
+    plt.tight_layout()
+    plt.show()
+    
+    # Also show Z-projections for each delta value
+    if len(image.shape) >= 3 and image.shape[0] > 1:
+        print("\nCreating maximum intensity projections for each delta value...")
+        
+        fig, axs = plt.subplots(1, len(delta_values) + 1, figsize=(5*(len(delta_values) + 1), 5))
+        
+        # Original MIP
+        orig_z_proj = np.max(image, axis=0)
+        im0 = axs[0].imshow(orig_z_proj, cmap='gray')
+        axs[0].set_title('Original (Z-Max Projection)')
+        plt.colorbar(im0, ax=axs[0], fraction=0.046, pad=0.04)
+        
+        # Show MIP for each delta result
+        for i, (delta, labels) in enumerate(zip(delta_values, results)):
+            labels_z_proj = np.max(labels, axis=0)
+            
+            # Get component count
+            num_components = len(np.unique(labels)) - 1
+            
+            # Make colormap
+            np.random.seed(i)
+            colors = np.random.rand(10000, 3)  # Large number to accommodate many labels
+            colors[0] = [0, 0, 0]
+            cmap = ListedColormap(colors[:num_components+1])
+            
+            im = axs[i+1].imshow(labels_z_proj, cmap=cmap)
+            axs[i+1].set_title(f'delta={delta} ({num_components} components)')
+            plt.colorbar(im, ax=axs[i+1], fraction=0.046, pad=0.04)
+        
+        plt.tight_layout()
+        plt.show()
+    
+    return results
+
+def visualize_specific_components(image, labels, component_ids, slice_idx=None):
+    """
+    Visualize specific components (useful for inspecting dendrites vs spines)
+    
+    Parameters:
+    - image: Original image data
+    - labels: Connected components labeled image
+    - component_ids: List of component IDs to visualize
+    - slice_idx: Slice to visualize (if None, uses middle slice)
+    """
+    if slice_idx is None:
+        slice_idx = image.shape[0] // 2
+    
+    # Create a mask for the selected components
+    mask = np.zeros_like(labels, dtype=bool)
+    for cid in component_ids:
+        mask = np.logical_or(mask, labels == cid)
+    
+    # Display the results
+    fig, axs = plt.subplots(1, 3, figsize=(18, 6))
+    
+    # Original image
+    im0 = axs[0].imshow(image[slice_idx], cmap='gray')
+    axs[0].set_title(f'Original Image (Slice {slice_idx})')
+    plt.colorbar(im0, ax=axs[0], fraction=0.046, pad=0.04)
+    
+    # All components
+    # Random colormap
+    num_components = len(np.unique(labels)) - 1
+    np.random.seed(42)
+    colors = np.random.rand(num_components+1, 3)
+    colors[0] = [0, 0, 0]
+    cmap = ListedColormap(colors)
+    
+    im1 = axs[1].imshow(labels[slice_idx], cmap=cmap)
+    axs[1].set_title(f'All Components (Slice {slice_idx})')
+    plt.colorbar(im1, ax=axs[1], fraction=0.046, pad=0.04)
+    
+    # Selected components
+    selected = np.zeros_like(labels[slice_idx])
+    for i, cid in enumerate(component_ids):
+        selected[labels[slice_idx] == cid] = i + 1
+    
+    # Colormap for selected components
+    n_selected = len(component_ids)
+    np.random.seed(100)
+    sel_colors = np.random.rand(n_selected+1, 3)
+    sel_colors[0] = [0, 0, 0]
+    sel_cmap = ListedColormap(sel_colors)
+    
+    im2 = axs[2].imshow(selected, cmap=sel_cmap)
+    axs[2].set_title(f'Selected Components {component_ids} (Slice {slice_idx})')
+    plt.colorbar(im2, ax=axs[2], fraction=0.046, pad=0.04)
+    
+    plt.tight_layout()
+    plt.show()
+
+    # Also show 3D projections of selected components
+    if image.shape[0] > 1:
+        # Create maximum intensity projections
+        orig_z_proj = np.max(image, axis=0)
+        
+        # Project selected components
+        selected_3d = np.zeros_like(labels)
+        for i, cid in enumerate(component_ids):
+            selected_3d[labels == cid] = i + 1
+        
+        selected_z_proj = np.max(selected_3d, axis=0)
+        
+        fig, axs = plt.subplots(1, 2, figsize=(14, 7))
+        
+        # Original MIP
+        im1 = axs[0].imshow(orig_z_proj, cmap='gray')
+        axs[0].set_title('Original Image (Z-Max Projection)')
+        plt.colorbar(im1, ax=axs[0], fraction=0.046, pad=0.04)
+        
+        # Selected components MIP
+        im2 = axs[1].imshow(selected_z_proj, cmap=sel_cmap)
+        axs[1].set_title(f'Selected Components {component_ids} (Z-Max Projection)')
+        plt.colorbar(im2, ax=axs[1], fraction=0.046, pad=0.04)
+        
+        plt.tight_layout()
+        plt.show()
+
+# Example usage
+if __name__ == "__main__":
+    # Replace with your dendrite TIFF stack path
+    image_path = r'DeepD3_Benchmark.tif'  # Update this with your actual file path
+    
+    # Check if the file exists
+    if not os.path.exists(image_path):
+        print(f"Error: File {image_path} does not exist")
+    else:
+        # Option 1: Compare different delta values to find the best one
+        results = delta_comparison_for_dendrites(
+            image_path, 
+            delta_values=[5, 10, 20, 50], 
+            connectivity=26
+        )
+        
+        # Option 2: Analyze with a specific delta value
+        # labels, stats = analyze_dendrite_stack(
+        #     image_path, 
+        #     delta_value=20,  # Adjust based on Option 1 results
+        #     connectivity=26
+        # )
+        
+        # Option 3: Visualize specific components (e.g., to examine spines vs. dendrites)
+        # Uncomment after running Option 2
+        # # Visualize the 3 largest components (likely main dendrites)
+        # large_components = [comp_id for comp_id, _ in sorted(
+        #     stats["voxel_counts"].items(), 
+        #     key=lambda x: x[1], 
+        #     reverse=True
+        # )[:3]]
+        # visualize_specific_components(io.imread(image_path), labels, large_components)
+        
+        # # Visualize some medium-sized components (likely spines)
+        # sorted_components = sorted(stats["voxel_counts"].items(), key=lambda x: x[1], reverse=True)
+        # medium_idx = len(sorted_components) // 2
+        # medium_components = [comp_id for comp_id, _ in sorted_components[medium_idx:medium_idx+3]]
+        # visualize_specific_components(io.imread(image_path), labels, medium_components)

neuro_sam/brightest_path_lib/cost/__init__.py

@@ -0,0 +1,8 @@
+from .cost import Cost
+from .reciprocal import Reciprocal
+
+DO_TRANSONIC = False
+if DO_TRANSONIC:
+    from .reciprocal_transonic import ReciprocalTransonic
+else:
+    from .reciprocal import Reciprocal as ReciprocalTransonic

neuro_sam/brightest_path_lib/cost/cost.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+
+class Cost(ABC):
+    """Base class for cost function
+    """
+
+    @abstractmethod
+    def cost_of_moving_to(self, intensity_at_new_point: float) -> float:
+        """calculates the cost of moving to a point
+
+        Parameters
+        ----------
+        intensity_at_new_point : float
+            The intensity of the new point under consideration
+        
+        Returns
+        -------
+        float
+            the cost of moving to the new point
+        """
+        pass
+
+    @abstractmethod
+    def minimum_step_cost(self) -> float:
+        """calculates the minimum step cost
+        (depends on the cost function implementation)
+        
+        Returns
+        -------
+        float
+            the minimum step cost
+        """
+        pass

neuro_sam/brightest_path_lib/cost/reciprocal.py

@@ -0,0 +1,90 @@
+from numba import njit, float64
+from neuro_sam.brightest_path_lib.cost import Cost
+
+# Standalone Numba-optimized function for the cost calculation
+@njit(fastmath=True)
+def _calculate_cost(intensity_at_new_point, min_intensity, max_intensity, 
+                   reciprocal_min, reciprocal_max):
+    """Numba-optimized cost calculation function"""
+    # Normalize intensity
+    intensity_at_new_point = reciprocal_max * (intensity_at_new_point - min_intensity) / (max_intensity - min_intensity)
+    
+    # Ensure minimum value - use max for better vectorization
+    intensity_at_new_point = max(intensity_at_new_point, reciprocal_min)
+    
+    # Return reciprocal (1/intensity)
+    return 1.0 / intensity_at_new_point
+
+class Reciprocal(Cost):
+    """Uses the reciprocal of pixel/voxel intensity to compute the cost of moving
+    to a neighboring point. Optimized with Numba.
+
+    Parameters
+    ----------
+    min_intensity : float
+        The minimum intensity a pixel/voxel can have in a given image
+    max_intensity : float
+        The maximum intensity a pixel/voxel can have in a given image
+
+    Attributes
+    ----------
+    RECIPROCAL_MIN : float
+        To cope with zero intensities, RECIPROCAL_MIN is added to the intensities
+        in the range before reciprocal calculation
+    RECIPROCAL_MAX : float
+        We set the maximum intensity <= RECIPROCAL_MAX so that the intensity
+        is between RECIPROCAL MIN and RECIPROCAL_MAX
+    """
+
+    def __init__(self, min_intensity: float, max_intensity: float) -> None:
+        super().__init__()
+        if min_intensity is None or max_intensity is None:
+            raise TypeError
+        if min_intensity > max_intensity:
+            raise ValueError
+            
+        self.min_intensity = min_intensity
+        self.max_intensity = max_intensity
+        self.RECIPROCAL_MIN = float(1E-6)
+        self.RECIPROCAL_MAX = 255.0
+        self._min_step_cost = 1.0 / self.RECIPROCAL_MAX
+
+    def cost_of_moving_to(self, intensity_at_new_point: float) -> float:
+        """calculates the cost of moving to a point
+
+        Parameters
+        ----------
+        intensity_at_new_point : float
+            The intensity of the new point under consideration
+        
+        Returns
+        -------
+        float
+            the cost of moving to the new point
+        
+        Notes
+        -----
+        - To cope with zero intensities, RECIPROCAL_MIN is added to the intensities in the range before reciprocal calculation
+        - We set the maximum intensity <= RECIPROCAL_MAX so that the intensity is between RECIPROCAL MIN and RECIPROCAL_MAX
+        """
+        if intensity_at_new_point > self.max_intensity:
+            raise ValueError
+            
+        # Use the Numba-optimized standalone function
+        return _calculate_cost(
+            intensity_at_new_point,
+            self.min_intensity,
+            self.max_intensity,
+            self.RECIPROCAL_MIN,
+            self.RECIPROCAL_MAX
+        )
+    
+    def minimum_step_cost(self) -> float:
+        """calculates the minimum step cost
+        
+        Returns
+        -------
+        float
+            the minimum step cost
+        """
+        return self._min_step_cost

neuro_sam/brightest_path_lib/cost/reciprocal_transonic.py

@@ -0,0 +1,86 @@
+from transonic import boost
+
+from neuro_sam.brightest_path_lib.cost import Cost
+
+@boost
+class ReciprocalTransonic(Cost):
+    """Uses the reciprocal of pixel/voxel intensity to compute the cost of moving
+    to a neighboring point
+
+    Parameters
+    ----------
+    min_intensity : float
+        The minimum intensity a pixel/voxel can have in a given image
+    max_intensity : float
+        The maximum intensity a pixel/voxel can have in a given image
+
+    Attributes
+    ----------
+    RECIPROCAL_MIN : float
+        To cope with zero intensities, RECIPROCAL_MIN is added to the intensities
+        in the range before reciprocal calculation
+    RECIPROCAL_MAX : float
+        We set the maximum intensity <= RECIPROCAL_MAX so that the intensity
+        is between RECIPROCAL MIN and RECIPROCAL_MAX
+
+    """
+
+    min_intensity: float
+    max_intensity: float
+    RECIPROCAL_MIN: float
+    RECIPROCAL_MAX: float
+    _min_step_cost: float
+
+    def __init__(self, min_intensity: float, max_intensity: float) -> None:
+        super().__init__()
+        if min_intensity is None or max_intensity is None:
+            raise TypeError
+        if min_intensity > max_intensity:
+            raise ValueError
+        self.min_intensity = min_intensity
+        self.max_intensity = max_intensity
+        self.RECIPROCAL_MIN = float(1E-6)
+        self.RECIPROCAL_MAX = 255.0
+        self._min_step_cost = 1.0 / self.RECIPROCAL_MAX
+
+
+    @boost
+    def cost_of_moving_to(self, intensity_at_new_point: float) -> float:
+        """calculates the cost of moving to a point
+
+        Parameters
+        ----------
+        intensity_at_new_point : float
+            The intensity of the new point under consideration
+        
+        Returns
+        -------
+        float
+            the cost of moving to the new point
+        
+        Notes
+        -----
+        - To cope with zero intensities, RECIPROCAL_MIN is added to the intensities in the range before reciprocal calculation
+        - We set the maximum intensity <= RECIPROCAL_MAX so that the intensity is between RECIPROCAL MIN and RECIPROCAL_MAX
+        
+        """
+        if intensity_at_new_point > self.max_intensity:
+            raise ValueError
+
+        intensity_at_new_point = self.RECIPROCAL_MAX * (intensity_at_new_point - self.min_intensity) / (self.max_intensity - self.min_intensity)
+
+        if intensity_at_new_point < self.RECIPROCAL_MIN:
+            intensity_at_new_point = self.RECIPROCAL_MIN
+        
+        return 1.0 / intensity_at_new_point
+    
+    @boost
+    def minimum_step_cost(self) -> float:
+        """calculates the minimum step cost
+        
+        Returns
+        -------
+        float
+            the minimum step cost
+        """
+        return self._min_step_cost

neuro_sam/brightest_path_lib/heuristic/__init__.py

@@ -0,0 +1,2 @@
+from .heuristic import Heuristic
+from .euclidean import Euclidean

neuro_sam/brightest_path_lib/heuristic/euclidean.py

@@ -0,0 +1,101 @@
+from neuro_sam.brightest_path_lib.heuristic import Heuristic
+import math
+import numpy as np
+from typing import Tuple
+from numba import njit, float64
+
+# Ultra-simple but very fast 2D distance calculation
+@njit(fastmath=True)
+def _fast_euclidean_distance_2d(current_y, current_x, goal_y, goal_x, scale_x, scale_y):
+    """Minimal, efficient 2D Euclidean distance calculation"""
+    dx = (goal_x - current_x) * scale_x
+    dy = (goal_y - current_y) * scale_y
+    return math.sqrt(dx*dx + dy*dy)
+
+# Ultra-simple but very fast 3D distance calculation
+@njit(fastmath=True)
+def _fast_euclidean_distance_3d(current_z, current_y, current_x, goal_z, goal_y, goal_x, 
+                               scale_x, scale_y, scale_z):
+    """Minimal, efficient 3D Euclidean distance calculation"""
+    dx = (goal_x - current_x) * scale_x
+    dy = (goal_y - current_y) * scale_y
+    dz = (goal_z - current_z) * scale_z
+    return math.sqrt(dx*dx + dy*dy + dz*dz)
+
+# Simple but efficient dispatcher
+@njit(fastmath=True)
+def _fast_estimate_cost(current_point, goal_point, scale_x, scale_y, scale_z):
+    """Simplified but efficient cost estimation"""
+    # Direct dimension check
+    if current_point.shape[0] == 2:  # 2D case
+        return _fast_euclidean_distance_2d(
+            current_point[0], current_point[1],  # y, x for current
+            goal_point[0], goal_point[1],        # y, x for goal
+            scale_x, scale_y
+        )
+    else:  # 3D case
+        return _fast_euclidean_distance_3d(
+            current_point[0], current_point[1], current_point[2],  # z, y, x for current
+            goal_point[0], goal_point[1], goal_point[2],          # z, y, x for goal
+            scale_x, scale_y, scale_z
+        )
+
+class Euclidean(Heuristic):
+    """Simplified and optimized heuristic cost using Euclidean distance
+
+    Parameters
+    ----------
+    scale : Tuple
+        the scale of the image's axes. For example (1.0 1.0) for a 2D image.
+        - for 2D points, the order of scale is: (x, y)
+        - for 3D points, the order of scale is: (x, y, z)
+    
+    Attributes
+    ----------
+    scale_x : float
+        the scale of the image's X-axis
+    scale_y : float
+        the scale of the image's Y-axis
+    scale_z : float
+        the scale of the image's Z-axis
+    """
+    def __init__(self, scale: Tuple):
+        if scale is None:
+            raise TypeError("Scale cannot be None")
+        if len(scale) == 0:
+            raise ValueError("Scale cannot be empty")
+
+        self.scale_x = scale[0]
+        self.scale_y = scale[1]
+        self.scale_z = 1.0
+        if len(scale) == 3:
+            self.scale_z = scale[2]
+
+    def estimate_cost_to_goal(self, current_point: np.ndarray, goal_point: np.ndarray) -> float:
+        """Calculate the estimated cost from current point to the goal
+    
+        Parameters
+        ----------
+        current_point : numpy ndarray
+            the coordinates of the current point
+        goal_point : numpy ndarray
+            the coordinates of the goal point
+        
+        Returns
+        -------
+        float
+            the estimated cost to goal in the form of Euclidean distance
+        """
+        if current_point is None or goal_point is None:
+            raise TypeError("Points cannot be None")
+        if (len(current_point) == 0 or len(goal_point) == 0) or (len(current_point) != len(goal_point)):
+            raise ValueError("Points must have the same dimensions and cannot be empty")
+
+        # Use the simplified Numba-optimized function
+        return _fast_estimate_cost(
+            current_point, 
+            goal_point, 
+            self.scale_x, 
+            self.scale_y, 
+            self.scale_z
+        )

neuro_sam/brightest_path_lib/heuristic/heuristic.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+import numpy as np
+
+class Heuristic(ABC):
+    """Abstract class for heuristic estimates to goal
+    """
+
+    @abstractmethod
+    def estimate_cost_to_goal(self, current_point: np.ndarray, goal_point: np.ndarray) -> float:
+        """calculates the estimated cost from current point to the goal
+        (implementation depends on the heuristic function)
+
+        Parameters
+        ----------
+        current_point : numpy ndarray
+            the coordinates of the current point
+                - for 2D points, x and y coordinates
+                - for 3D points, x, y and z coordinates
+        goal_point : numpy ndarray
+            the coordinates of the current point
+                - for 2D points, x and y coordinates
+                - for 3D points, x, y and z coordinates
+        
+        Returns
+        -------
+        float
+            the estimated cost to goal
+        """
+        pass

neuro_sam/brightest_path_lib/image/__init__.py

@@ -0,0 +1 @@
+from .stats import ImageStats