neuro-sam 0.1.0__py3-none-any.whl

neuro_sam/brightest_path_lib/image/stats.py

@@ -0,0 +1,197 @@
+import numpy as np
+import numba as nb
+
+# Numba-optimized functions for faster image stats calculation
+@nb.njit(fastmath=True)
+def compute_image_intensity_range(image):
+    """Efficiently compute min and max intensity of an image using Numba"""
+    # Use Numba's optimized implementation rather than np.min/np.max
+    # for better performance, especially with large arrays
+    
+    # Initialize with extreme values
+    min_val = np.inf
+    max_val = -np.inf
+    
+    # For 1D arrays (unlikely but handled for completeness)
+    if image.ndim == 1:
+        for i in range(image.shape[0]):
+            val = image[i]
+            if val < min_val:
+                min_val = val
+            if val > max_val:
+                max_val = val
+    
+    # For 2D arrays (most common case)
+    elif image.ndim == 2:
+        for i in range(image.shape[0]):
+            for j in range(image.shape[1]):
+                val = image[i, j]
+                if val < min_val:
+                    min_val = val
+                if val > max_val:
+                    max_val = val
+    
+    # For 3D arrays
+    elif image.ndim == 3:
+        for i in range(image.shape[0]):
+            for j in range(image.shape[1]):
+                for k in range(image.shape[2]):
+                    val = image[i, j, k]
+                    if val < min_val:
+                        min_val = val
+                    if val > max_val:
+                        max_val = val
+    
+    return float(min_val), float(max_val)
+
+@nb.njit
+def compute_image_dimensions(image_shape):
+    """Compute image dimensions and coordinate ranges"""
+    ndim = len(image_shape)
+    
+    # Initialize with default values
+    x_min, y_min, z_min = 0, 0, 0
+    x_max, y_max, z_max = 0, 0, 0
+    
+    if ndim == 2:  # 2D image
+        y_max = image_shape[0] - 1
+        x_max = image_shape[1] - 1
+    elif ndim == 3:  # 3D image
+        z_max = image_shape[0] - 1
+        y_max = image_shape[1] - 1
+        x_max = image_shape[2] - 1
+    
+    return x_min, x_max, y_min, y_max, z_min, z_max
+
+class ImageStats:
+    """Class holding metadata about an image, optimized with Numba
+
+    Parameters
+    ----------
+    image : numpy ndarray
+        the image who's metadata is being stored
+
+    Attributes
+    ----------
+    min_intensity : float
+        the minimum intensity of a pixel/voxel in the given image
+    max_intensity : float
+        the maximum intensity of a pixel/voxel in the given image
+    x_min : int
+        the smallest x-coordinate of the given image
+    y_min : int
+        the smallest y-coordinate of the given image
+    z_min : int
+        the smallest z-coordinate of the given image
+    x_max : int
+        the largest x-coordinate of the given image
+    y_max : int
+        the largest y-coordinate of the given image
+    z_max : int
+        the largest z-coordinate of the given image
+    """
+    # Use __slots__ for memory efficiency and faster attribute access
+    __slots__ = (
+        '_min_intensity', '_max_intensity',
+        '_x_min', '_y_min', '_z_min',
+        '_x_max', '_y_max', '_z_max'
+    )
+
+    def __init__(self, image: np.ndarray):
+        # Input validation
+        if image is None:
+            raise TypeError("Image cannot be None")
+        if len(image) == 0:
+            raise ValueError("Image cannot be empty")
+            
+        # Convert image to a numpy array if it isn't already
+        if not isinstance(image, np.ndarray):
+            image = np.asarray(image)
+            
+        # Compute intensity range using Numba-optimized function
+        min_intensity, max_intensity = compute_image_intensity_range(image)
+        self._min_intensity = min_intensity
+        self._max_intensity = max_intensity
+        
+        # Compute image dimensions and coordinate ranges
+        self._x_min, self._x_max, self._y_min, self._y_max, self._z_min, self._z_max = compute_image_dimensions(image.shape)
+
+    @property
+    def min_intensity(self) -> float:
+        return self._min_intensity
+
+    @min_intensity.setter
+    def min_intensity(self, value: float):
+        if value is None:
+            raise TypeError("min_intensity cannot be None")
+        self._min_intensity = float(value)
+    
+    @property
+    def max_intensity(self) -> float:
+        return self._max_intensity
+    
+    @max_intensity.setter
+    def max_intensity(self, value: float):
+        if value is None:
+            raise TypeError("max_intensity cannot be None")
+        self._max_intensity = float(value)
+    
+    @property
+    def x_min(self) -> float:
+        return self._x_min
+    
+    @x_min.setter
+    def x_min(self, value: float):
+        if value is None:
+            raise TypeError("x_min cannot be None")
+        self._x_min = float(value)
+    
+    @property
+    def y_min(self) -> float:
+        return self._y_min
+    
+    @y_min.setter
+    def y_min(self, value: float):
+        if value is None:
+            raise TypeError("y_min cannot be None")
+        self._y_min = float(value)
+    
+    @property
+    def z_min(self) -> float:
+        return self._z_min
+    
+    @z_min.setter
+    def z_min(self, value: float):
+        if value is None:
+            raise TypeError("z_min cannot be None")
+        self._z_min = float(value)
+    
+    @property
+    def x_max(self) -> float:
+        return self._x_max
+    
+    @x_max.setter
+    def x_max(self, value: float):
+        if value is None:
+            raise TypeError("x_max cannot be None")
+        self._x_max = float(value)
+    
+    @property
+    def y_max(self) -> float:
+        return self._y_max
+    
+    @y_max.setter
+    def y_max(self, value: float):
+        if value is None:
+            raise TypeError("y_max cannot be None")
+        self._y_max = float(value)
+    
+    @property
+    def z_max(self) -> float:
+        return self._z_max
+    
+    @z_max.setter
+    def z_max(self, value: float):
+        if value is None:
+            raise TypeError("z_max cannot be None")
+        self._z_max = float(value)

neuro_sam/brightest_path_lib/input/__init__.py

@@ -0,0 +1 @@
+from .inputs import CostFunction, HeuristicFunction, SearchFunction

neuro_sam/brightest_path_lib/input/inputs.py

@@ -0,0 +1,14 @@
+"""Enums for the types of inputs for the cost, heuristic and search functions.
+"""
+
+from enum import Enum
+
+class CostFunction(Enum):
+	RECIPROCAL = "reciprocal"
+
+class HeuristicFunction(Enum):
+	EUCLIDEAN = "euclidean"
+
+class SearchFunction(Enum):
+    ASTAR = "astar"
+    NBASTAR = "nbastar"

neuro_sam/brightest_path_lib/node/__init__.py

@@ -0,0 +1,2 @@
+from .node import Node
+from .bidirectional_node import BidirectionalNode

neuro_sam/brightest_path_lib/node/bidirectional_node.py

@@ -0,0 +1,240 @@
+import numpy as np
+import numba as nb
+
+# Numba-optimized helper functions
+@nb.njit(fastmath=True)
+def compute_f_score(g_score: float, h_score: float) -> float:
+    """Compute f_score from g_score and h_score with Numba optimization"""
+    return g_score + h_score
+
+@nb.njit
+def validate_point(point):
+    """Validate point array with Numba optimization"""
+    return len(point) > 0
+
+@nb.njit
+def get_score_by_direction(from_start, start_score, goal_score):
+    """Get the appropriate score based on direction with Numba optimization"""
+    if from_start:
+        return start_score
+    return goal_score
+
+class BidirectionalNode:
+    """Class holding attributes and properties of a Bidirectional Node, optimized for performance
+
+    Parameters
+    ----------
+    point : numpy ndarray
+        the 2D/3D coordinates of the node (can be a pixel or a voxel)
+    g_score_from_start : float
+        the distance from a starting node to the current node
+    g_score_from_goal : float
+        the distance from a goal node to the current node
+    h_score_from_start : float
+        the estimated distance from the current node to a goal node
+    h_score_from_goal : float
+        the estimated distance from the current node to a start node
+    predecessor_from_start : BidirectionalNode
+        the current node's immediate predecessor, from which we
+        travelled to the current node
+        The predecessor's first ancestor is the start node
+    predecessor_from_goal : BidirectionalNode
+        the current node's immediate predecessor, from which we
+        travelled to the current node
+        The predecessor's first ancestor is the goal node
+    
+    Attributes
+    ----------
+    point : numpy ndarray
+        the 2D/3D coordinates of the node (can be a pixel or a voxel)
+    g_score_from_start : float
+        the distance from a starting node to the current node
+    g_score_from_goal : float
+        the distance from a goal node to the current node
+    h_score_from_start : float
+        the estimated distance from the current node to a goal node
+    h_score_from_goal : float
+        the estimated distance from the current node to a start node
+    f_score_from_start : float
+        the sum of g_score_from_start and h_score_from_start
+    f_score_from_goal : float
+        the sum of g_score_from_goal and h_score_from_goal
+    predecessor_from_start : BidirectionalNode
+        the current node's immediate predecessor, from which we
+        travelled to the current node
+        The predecessor's first ancestor is the start node
+    predecessor_from_goal : BidirectionalNode
+        the current node's immediate predecessor, from which we
+        travelled to the current node The predecessor's first ancestor
+        is the goal node
+    """
+    # Use __slots__ to reduce memory overhead and access time
+    __slots__ = (
+        '_point', '_g_score_from_start', '_g_score_from_goal', 
+        '_h_score_from_start', '_h_score_from_goal',
+        '_f_score_from_start', '_f_score_from_goal',
+        '_predecessor_from_start', '_predecessor_from_goal'
+    )
+    
+    def __init__(
+        self,
+        point: np.ndarray,
+        g_score_from_start: float = float('inf'),
+        g_score_from_goal: float = float('inf'),
+        h_score_from_start: float = float('inf'),
+        h_score_from_goal: float = float('inf'),
+        f_score_from_start: float = float('inf'),
+        f_score_from_goal: float = float('inf'),
+        predecessor_from_start: 'BidirectionalNode' = None,
+        predecessor_from_goal: 'BidirectionalNode' = None
+    ):
+        # Convert point to int64 for better performance with Numba
+        if isinstance(point, list):
+            point = np.array(point)
+        if not isinstance(point, np.ndarray):
+            point = np.array(point)
+        if point.dtype != np.int64:
+            point = point.astype(np.int64)
+            
+        self._point = point
+        self._g_score_from_start = float(g_score_from_start)
+        self._g_score_from_goal = float(g_score_from_goal)
+        self._h_score_from_start = float(h_score_from_start)
+        self._h_score_from_goal = float(h_score_from_goal)
+        
+        # Use Numba functions for f_score calculations if they're not provided
+        if f_score_from_start == float('inf') and g_score_from_start != float('inf') and h_score_from_start != float('inf'):
+            self._f_score_from_start = compute_f_score(g_score_from_start, h_score_from_start)
+        else:
+            self._f_score_from_start = float(f_score_from_start)
+            
+        if f_score_from_goal == float('inf') and g_score_from_goal != float('inf') and h_score_from_goal != float('inf'):
+            self._f_score_from_goal = compute_f_score(g_score_from_goal, h_score_from_goal)
+        else:
+            self._f_score_from_goal = float(f_score_from_goal)
+            
+        self._predecessor_from_start = predecessor_from_start
+        self._predecessor_from_goal = predecessor_from_goal
+    
+    @property
+    def point(self):
+        return self._point
+    
+    @point.setter
+    def point(self, value: np.ndarray):
+        if value is None:
+            raise TypeError
+        if not validate_point(value):
+            raise ValueError
+        # Ensure int64 type for better performance
+        if not isinstance(value, np.ndarray):
+            value = np.array(value, dtype=np.int64)
+        if value.dtype != np.int64:
+            value = value.astype(np.int64)
+        self._point = value
+
+    @property
+    def g_score_from_start(self):
+        return self._g_score_from_start
+    
+    @g_score_from_start.setter
+    def g_score_from_start(self, value: float):
+        self._g_score_from_start = float(value)
+        # Update f_score when g_score changes
+        if self._h_score_from_start != float('inf'):
+            self._f_score_from_start = compute_f_score(value, self._h_score_from_start)
+    
+    @property
+    def g_score_from_goal(self):
+        return self._g_score_from_goal
+    
+    @g_score_from_goal.setter
+    def g_score_from_goal(self, value: float):
+        self._g_score_from_goal = float(value)
+        # Update f_score when g_score changes
+        if self._h_score_from_goal != float('inf'):
+            self._f_score_from_goal = compute_f_score(value, self._h_score_from_goal)
+    
+    @property
+    def h_score_from_start(self):
+        return self._h_score_from_start
+    
+    @h_score_from_start.setter
+    def h_score_from_start(self, value: float):
+        self._h_score_from_start = float(value)
+        # Update f_score when h_score changes
+        if self._g_score_from_start != float('inf'):
+            self._f_score_from_start = compute_f_score(self._g_score_from_start, value)
+    
+    @property
+    def h_score_from_goal(self):
+        return self._h_score_from_goal
+    
+    @h_score_from_goal.setter
+    def h_score_from_goal(self, value: float):
+        self._h_score_from_goal = float(value)
+        # Update f_score when h_score changes
+        if self._g_score_from_goal != float('inf'):
+            self._f_score_from_goal = compute_f_score(self._g_score_from_goal, value)
+    
+    @property
+    def f_score_from_start(self):
+        return self._f_score_from_start
+    
+    @f_score_from_start.setter
+    def f_score_from_start(self, value: float):
+        self._f_score_from_start = float(value)
+    
+    @property
+    def f_score_from_goal(self):
+        return self._f_score_from_goal
+    
+    @f_score_from_goal.setter
+    def f_score_from_goal(self, value: float):
+        self._f_score_from_goal = float(value)
+    
+    @property
+    def predecessor_from_start(self):
+        return self._predecessor_from_start
+    
+    @predecessor_from_start.setter
+    def predecessor_from_start(self, value):
+        self._predecessor_from_start = value
+    
+    @property
+    def predecessor_from_goal(self):
+        return self._predecessor_from_goal
+    
+    @predecessor_from_goal.setter
+    def predecessor_from_goal(self, value):
+        self._predecessor_from_goal = value
+    
+    # Fast accessor methods optimized for performance
+    def get_g(self, from_start: bool) -> float:
+        """Get the appropriate g_score based on direction"""
+        return get_score_by_direction(from_start, self._g_score_from_start, self._g_score_from_goal)
+    
+    def get_f(self, from_start: bool) -> float:
+        """Get the appropriate f_score based on direction"""
+        return get_score_by_direction(from_start, self._f_score_from_start, self._f_score_from_goal)
+    
+    def set_g(self, g_score: float, from_start: bool):
+        """Set the appropriate g_score based on direction"""
+        if from_start:
+            self.g_score_from_start = g_score
+        else:
+            self.g_score_from_goal = g_score
+    
+    def set_f(self, f_score: float, from_start: bool):
+        """Set the appropriate f_score based on direction"""
+        if from_start:
+            self.f_score_from_start = f_score
+        else:
+            self.f_score_from_goal = f_score
+    
+    def set_predecessor(self, predecessor, from_start: bool):
+        """Set the appropriate predecessor based on direction"""
+        if from_start:
+            self.predecessor_from_start = predecessor
+        else:
+            self.predecessor_from_goal = predecessor

neuro_sam/brightest_path_lib/node/node.py

@@ -0,0 +1,125 @@
+import numpy as np
+import numba as nb
+
+# Numba-optimized helper functions for node operations
+@nb.njit(fastmath=True)
+def compute_f_score(g_score: float, h_score: float) -> float:
+    """Compute f_score from g_score and h_score with Numba optimization"""
+    return g_score + h_score
+
+@nb.njit
+def validate_point(point):
+    """Validate point array with Numba optimization"""
+    return len(point) > 0
+
+class Node:
+    """Class holding information about a node, optimized for numerical operations
+
+    Parameters
+    ----------
+    point : numpy ndarray
+        the 2D/3D coordinates of the node (can be a pixel or a voxel)
+    g_score : float
+        the distance from a starting node to the current node
+    h_score : float
+        the estimated distance from the current node to a goal_node
+    predecessor : Node
+        the current node's immediate predecessor, from which we
+        travelled to the current node
+    
+    Attributes
+    ----------
+    point : numpy ndarray
+        the 2D/3D coordinates of the node
+    g_score : float
+        the actual cost from a starting node to the current node
+    h_score : float
+        the estimated cost from the current node to a goal_node
+    f_score : float
+        the sum of the node's g_score and h_score
+    predecessor : Node
+        the current node's immediate predecessor, from which we
+        travelled to the current node
+    """
+    __slots__ = ('_point', '_g_score', '_h_score', '_f_score', '_predecessor')
+    
+    def __init__(
+        self,
+        point: np.ndarray,
+        g_score: float,
+        h_score: float,
+        predecessor: 'Node' = None
+    ):
+        # Convert point to int64 for better performance with Numba
+        if isinstance(point, list):
+            point = np.array(point)
+        if not isinstance(point, np.ndarray):
+            point = np.array(point)
+        if point.dtype != np.int64:
+            point = point.astype(np.int64)
+            
+        self._point = point
+        self._g_score = float(g_score)
+        self._h_score = float(h_score)
+        # Use Numba function for f_score calculation
+        self._f_score = compute_f_score(g_score, h_score)
+        self._predecessor = predecessor
+    
+    @property
+    def point(self):
+        return self._point
+    
+    @point.setter
+    def point(self, value: np.ndarray):
+        if value is None:
+            raise TypeError
+        if not validate_point(value):
+            raise ValueError
+        # Ensure int64 type for better performance
+        if not isinstance(value, np.ndarray):
+            value = np.array(value, dtype=np.int64)
+        if value.dtype != np.int64:
+            value = value.astype(np.int64)
+        self._point = value
+
+    @property
+    def g_score(self):
+        return self._g_score
+    
+    @g_score.setter
+    def g_score(self, value: float):
+        if value is None:
+            raise TypeError
+        self._g_score = float(value)
+        # Update f_score when g_score changes
+        self._f_score = compute_f_score(self._g_score, self._h_score)
+    
+    @property
+    def h_score(self):
+        return self._h_score
+    
+    @h_score.setter
+    def h_score(self, value: float):
+        if value is None:
+            raise TypeError
+        self._h_score = float(value)
+        # Update f_score when h_score changes
+        self._f_score = compute_f_score(self._g_score, self._h_score)
+    
+    @property
+    def f_score(self):
+        return self._f_score
+    
+    @f_score.setter
+    def f_score(self, value: float):
+        if value is None:
+            raise TypeError
+        self._f_score = float(value)
+    
+    @property
+    def predecessor(self):
+        return self._predecessor
+    
+    @predecessor.setter
+    def predecessor(self, value):
+        self._predecessor = value

neuro_sam/brightest_path_lib/visualization/__init__.py

@@ -0,0 +1,4 @@
+from .flythrough import create_path_flythrough
+from .tube_flythrough import create_tube_flythrough
+from .flythrough_all import create_integrated_flythrough
+from .tube_data import create_tube_data