Remove orphan v3 refactor code

Author: Donglai Wei

connectomics/data/datasets/sampling.py

@@ -89,80 +89,7 @@ def compute_total_samples(
     return total_samples, samples_per_volume
 
 
-def calculate_inference_grid(
-    volume_shape: Tuple[int, int, int],
-    patch_size: Tuple[int, int, int],
-    stride: Tuple[int, int, int],
-) -> Tuple[np.ndarray, Tuple[int, int, int]]:
-    """
-    Calculate grid of patch positions for sliding-window inference.
-
-    This function generates all patch positions needed to cover a volume
-    with overlapping patches, using the specified stride.
-
-    Args:
-        volume_shape: Shape of the input volume (D, H, W)
-        patch_size: Size of each patch (D, H, W)
-        stride: Stride between patch centers (D, H, W)
-
-    Returns:
-        positions: Array of shape (N, 3) containing (z, y, x) start positions
-        grid_shape: Tuple (num_z, num_y, num_x) indicating grid dimensions
-
-    Examples:
-        >>> volume_shape = (256, 256, 256)
-        >>> patch_size = (128, 128, 128)
-        >>> stride = (64, 64, 64)
-        >>> positions, grid = calculate_inference_grid(volume_shape, patch_size, stride)
-        >>> print(f"Grid shape: {grid}")
-        >>> # Grid shape: (3, 3, 3)
-        >>> print(f"Total patches: {len(positions)}")
-        >>> # Total patches: 27
-
-    Note:
-        The last patch in each dimension is "tucked in" to ensure it fits
-        within the volume boundaries, matching the legacy v1 behavior.
-    """
-    volume_shape = np.array(volume_shape)
-    patch_size = np.array(patch_size)
-    stride = np.array(stride)
-
-    # Calculate grid dimensions
-    grid_shape = count_volume(volume_shape, patch_size, stride)
-    grid_shape = tuple(grid_shape)
-
-    positions = []
-
-    # Generate all grid positions
-    for z_idx in range(grid_shape[0]):
-        for y_idx in range(grid_shape[1]):
-            for x_idx in range(grid_shape[2]):
-                # Calculate position with boundary handling
-                # Normal case: multiply by stride
-                # Boundary case: tuck in to ensure patch fits
-                z = (
-                    z_idx * stride[0]
-                    if z_idx < grid_shape[0] - 1
-                    else volume_shape[0] - patch_size[0]
-                )
-                y = (
-                    y_idx * stride[1]
-                    if y_idx < grid_shape[1] - 1
-                    else volume_shape[1] - patch_size[1]
-                )
-                x = (
-                    x_idx * stride[2]
-                    if x_idx < grid_shape[2] - 1
-                    else volume_shape[2] - patch_size[2]
-                )
-
-                positions.append([z, y, x])
-
-    return np.array(positions, dtype=np.int32), grid_shape
-
-
 __all__ = [
     "count_volume",
     "compute_total_samples",
-    "calculate_inference_grid",
 ]

connectomics/data/processing/bbox.py

@@ -1,19 +1,15 @@
 from __future__ import annotations
 
 import itertools
-from collections import OrderedDict
 from typing import Optional, Tuple, Union
 
 import numpy as np
 
 __all__ = [
     "bbox_ND",
     "bbox_relax",
-    "adjust_bbox",
-    "index2bbox",
     "crop_ND",
     "replace_ND",
-    "rand_window",
     "compute_bbox_all",
 ]
 
@@ -53,27 +49,6 @@ def bbox_relax(coord: Union[tuple, list], shape: tuple, relax: int = 0) -> tuple
     return tuple(coord)
 
 
-def adjust_bbox(low, high, sz):
-    if high < low:
-        raise ValueError(f"high ({high}) must be >= low ({low})")
-    bbox_sz = high - low
-    diff = abs(sz - bbox_sz) // 2
-    if bbox_sz >= sz:
-        return low + diff, low + diff + sz
-
-    return low - diff, low - diff + sz
-
-
-def index2bbox(seg: np.ndarray, indices: list, relax: int = 0, iterative: bool = True) -> dict:
-    """Calculate the bounding boxes associated with the given mask indices."""
-    bbox_dict = OrderedDict()
-    for idx in indices:
-        temp = seg == idx
-        bbox = bbox_ND(temp, relax=relax)
-        bbox_dict[idx] = bbox
-    return bbox_dict
-
-
 def _coord2slice(coord: Tuple[int], ndim: int, end_included: bool = False):
     if len(coord) != ndim * 2:
         raise ValueError(f"Expected {ndim * 2} coordinates for {ndim}D array, got {len(coord)}")
@@ -116,28 +91,6 @@ def replace_ND(
     return img.copy()
 
 
-def rand_window(w0, w1, sz, rand_shift: int = 0):
-    if w1 < w0:
-        raise ValueError(f"w1 ({w1}) must be >= w0 ({w0})")
-    diff = np.abs((w1 - w0) - sz)
-    if (w1 - w0) <= sz:
-        if rand_shift > 0:  # random shift augmentation
-            start_l = max(w0 - diff // 2 - rand_shift, w1 - sz)
-            start_r = min(w0, w0 - diff // 2 + rand_shift)
-            low = np.random.randint(start_l, start_r)
-        else:
-            low = w0 - diff // 2
-    else:
-        if rand_shift > 0:  # random shift augmentation
-            start_l = max(w0, w0 + diff // 2 - rand_shift)
-            start_r = min(w0 + diff // 2 + rand_shift, w1 - sz)
-            low = np.random.randint(start_l, start_r)
-        else:
-            low = w0 + diff // 2
-    high = low + sz
-    return low, high
-
-
 def compute_bbox_all(
     seg: np.ndarray, do_count: bool = False, uid: Optional[np.ndarray] = None
 ) -> Optional[np.ndarray]:

connectomics/data/processing/blend.py

@@ -6,30 +6,16 @@
     tuning/      - Hyperparameter tuning for decoding parameters
 """
 
+from importlib import import_module
+
 # --- Framework / Infrastructure ---
 from .base import DecodeStep
-
-# --- Segmentation Decoders ---
-from .decoders import (
-    branch_merge,
-    decode_abiss,
-    decode_affinity_cc,
-    decode_distance_watershed,
-    decode_instance_binary_contour_distance,
-    decode_waterz,
-    polarity2instance,
-)
 from .pipeline import (
     apply_decode_mode,
     apply_decode_pipeline,
     normalize_decode_modes,
     resolve_decode_modes_from_cfg,
 )
-from .stage import (
-    DecodingStageResult,
-    apply_decoding_postprocessing,
-    run_decoding_stage,
-)
 
 # --- Post-processing & Utilities ---
 from .postprocessing import (
@@ -49,15 +35,38 @@
     register_builtin_decoders,
     register_decoder,
 )
-
+from .stage import (
+    DecodingStageResult,
+    apply_decoding_postprocessing,
+    run_decoding_stage,
+)
 from .utils import (
     cast2dtype,
     merge_small_objects,
     remove_large_instances,
     remove_small_instances,
 )
 
-register_builtin_decoders()
+_LAZY_DECODER_EXPORTS = {
+    "branch_merge": "connectomics.decoding.decoders.branch_merge",
+    "decode_abiss": "connectomics.decoding.decoders.abiss",
+    "decode_affinity_cc": "connectomics.decoding.decoders.segmentation",
+    "decode_distance_watershed": "connectomics.decoding.decoders.segmentation",
+    "decode_instance_binary_contour_distance": "connectomics.decoding.decoders.segmentation",
+    "decode_waterz": "connectomics.decoding.decoders.waterz",
+    "polarity2instance": "connectomics.decoding.decoders.synapse",
+}
+
+
+def __getattr__(name: str):
+    module_name = _LAZY_DECODER_EXPORTS.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    value = getattr(import_module(module_name), name)
+    globals()[name] = value
+    return value
+
 
 __all__ = [
     # Registry / pipeline

connectomics/decoding/__init__.py

@@ -1,14 +1,27 @@
 """Segmentation decoder implementations."""
 
-from .abiss import decode_abiss
-from .branch_merge import branch_merge
-from .segmentation import (
-    decode_affinity_cc,
-    decode_distance_watershed,
-    decode_instance_binary_contour_distance,
-)
-from .synapse import polarity2instance
-from .waterz import decode_waterz
+from importlib import import_module
+
+_LAZY_DECODERS = {
+    "branch_merge": "connectomics.decoding.decoders.branch_merge",
+    "decode_abiss": "connectomics.decoding.decoders.abiss",
+    "decode_affinity_cc": "connectomics.decoding.decoders.segmentation",
+    "decode_distance_watershed": "connectomics.decoding.decoders.segmentation",
+    "decode_instance_binary_contour_distance": "connectomics.decoding.decoders.segmentation",
+    "decode_waterz": "connectomics.decoding.decoders.waterz",
+    "polarity2instance": "connectomics.decoding.decoders.synapse",
+}
+
+
+def __getattr__(name: str):
+    module_name = _LAZY_DECODERS.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    value = getattr(import_module(module_name), name)
+    globals()[name] = value
+    return value
+
 
 __all__ = [
     "decode_instance_binary_contour_distance",

connectomics/decoding/decoders/__init__.py

@@ -9,7 +9,7 @@
 
 from ..utils.channel_slices import resolve_channel_indices
 from .base import DecodeStep
-from .registry import DEFAULT_DECODER_REGISTRY, DecoderRegistry
+from .registry import DEFAULT_DECODER_REGISTRY, DecoderRegistry, ensure_builtin_decoders_registered
 
 logger = logging.getLogger(__name__)
 
@@ -87,7 +87,9 @@ def apply_decode_pipeline(
     if not decode_modes:
         return data
 
-    registry = registry or DEFAULT_DECODER_REGISTRY
+    if registry is None:
+        ensure_builtin_decoders_registered()
+        registry = DEFAULT_DECODER_REGISTRY
     steps = [s for s in normalize_decode_modes(decode_modes) if s.enabled]
     if not steps:
         return data

connectomics/decoding/pipeline.py

@@ -41,6 +41,7 @@ def available(self) -> List[str]:
 
 
 DEFAULT_DECODER_REGISTRY = DecoderRegistry()
+_BUILTINS_REGISTERED = False
 
 
 def register_decoder(name: str, fn: DecodeFunction, *, overwrite: bool = False) -> None:
@@ -50,16 +51,27 @@ def register_decoder(name: str, fn: DecodeFunction, *, overwrite: bool = False)
 
 def get_decoder(name: str) -> DecodeFunction:
     """Get decoder from the default registry."""
+    ensure_builtin_decoders_registered()
     return DEFAULT_DECODER_REGISTRY.get(name)
 
 
 def list_decoders() -> List[str]:
     """List names in the default registry."""
+    ensure_builtin_decoders_registered()
     return DEFAULT_DECODER_REGISTRY.available()
 
 
+def ensure_builtin_decoders_registered() -> None:
+    """Register built-in decoders on first use."""
+    register_builtin_decoders()
+
+
 def register_builtin_decoders() -> None:
     """Populate registry with built-in decoders."""
+    global _BUILTINS_REGISTERED
+    if _BUILTINS_REGISTERED:
+        return
+
     from .decoders.abiss import decode_abiss
     from .decoders.segmentation import (
         decode_affinity_cc,
@@ -79,3 +91,4 @@ def register_builtin_decoders() -> None:
     register_decoder("decode_waterz", decode_waterz, overwrite=True)
     register_decoder("decode_abiss", decode_abiss, overwrite=True)
     register_decoder("polarity2instance", polarity2instance, overwrite=True)
+    _BUILTINS_REGISTERED = True