arcn 0.0.0__tar.gz

arcn-0.0.0/MANIFEST.in

@@ -0,0 +1 @@
+include src/arcn/VERSION

arcn-0.0.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: arcn
+Version: 0.0.0
+Summary: ARCANE - Anatomical ReConstruction along AligNEd paths
+Author-email: "J. Hoffman" <contact@jmh.lol>
+Project-URL: Homepage, https://gitlab.com/hoffman-lab/arcane
+Project-URL: Bug Tracker, https://gitlab.com/hoffman-lab/arcane/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: SimpleITK
+Requires-Dist: scipy
+Requires-Dist: nibabel
+Requires-Dist: pillow
+
+# ARCaNe - Anatomical ReConstruction along AligNEd paths
+

arcn-0.0.0/README.md

@@ -0,0 +1,2 @@
+# ARCaNe - Anatomical ReConstruction along AligNEd paths
+

arcn-0.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "arcn"
+authors = [
+  { name = "J. Hoffman", email = "contact@jmh.lol" },
+]
+description = "ARCANE - Anatomical ReConstruction along AligNEd paths"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+# Eventually, psycopg2/psycopg
+dependencies = ["numpy", "SimpleITK", "scipy", "nibabel", "pillow"]
+dynamic = ["version"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta:__legacy__"
+# The difference between `__legacy__` and the regular `build_meta`
+# is that `__legacy__` does the equivalent of
+# `sys.path.insert(0, os.path.dirname(__file__))`.
+# This allows you to `import` your modules from the `CWD`.
+# If you don't like using `__legacy__` you can
+# manually add `CWD` to `sys.path` inside your `setup.py`.
+
+[project.urls]
+"Homepage" = "https://gitlab.com/hoffman-lab/arcane"
+"Bug Tracker" = "https://gitlab.com/hoffman-lab/arcane/issues"
+
+

arcn-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

arcn-0.0.0/src/arcn/VERSION

@@ -0,0 +1 @@
+v0.0.1

arcn-0.0.0/src/arcn/io.py

@@ -0,0 +1,364 @@
+import os
+import json
+from PIL import Image
+import numpy as np
+import SimpleITK as sitk
+
+from .node import Node
+
+
+def load_series(dir_path: str) -> sitk.Image:
+    image_reader = sitk.ImageSeriesReader()
+    dicom_names = image_reader.GetGDCMSeriesFileNames(dir_path)
+    image_reader.SetFileNames(dicom_names)
+    study = image_reader.Execute()
+    return study
+
+
+def load_mask(seg_path: str) -> sitk.Image:
+    seg_reader = sitk.ImageFileReader()
+    seg_reader.SetImageIO("NiftiImageIO")
+    seg_reader.SetFileName(seg_path)
+    seg = seg_reader.Execute()
+    return seg
+
+
+def get_aligned_array_view(image: sitk.Image) -> np.ndarray:
+    """
+    Extracts a numpy array from a 2D SimpleITK image and corrects for memory
+    flipping and transposition based on the Direction Cosine Matrix.
+
+    Args:
+        image: A 2D SimpleITK Image.
+
+    Returns:
+        A 2D numpy array geometrically aligned to the world axes.
+    """
+    if image.GetDimension() != 2:
+        raise ValueError("This function specifically handles 2D SimpleITK images.")
+
+    # Extract the view. Remember: SimpleITK is (X, Y) but Numpy is (Y, X)
+    array_view = sitk.GetArrayViewFromImage(image)
+
+    # Get the 2x2 direction matrix as a flat 4-element tuple
+    # direction = (d00, d01, d10, d11)
+    direction = image.GetDirection()
+
+    # Determine if the image axes are swapped (e.g., a 90-degree rotation)
+    # We check if the off-diagonal X-projection is larger than the main diagonal
+    is_transposed = abs(direction[1]) > abs(direction[0])
+
+    if is_transposed:
+        # Swap axes so Numpy's rows/cols align with World Y/X
+        array_view = array_view.T
+
+        # Because we transposed, the physical Y axis (direction[1]) now drives X
+        # and the physical X axis (direction[2]) now drives Y.
+        flip_x = direction[1] < 0
+        flip_y = direction[2] < 0
+    else:
+        # Standard orientation
+        # direction[0] represents the physical X axis on the World X axis
+        # direction[3] represents the physical Y axis on the World Y axis
+        flip_x = direction[0] < 0
+        flip_y = direction[3] < 0
+
+    # Apply spatial corrections
+    if flip_y:
+        array_view = np.flipud(array_view)  # Flip vertically (along rows)
+    if flip_x:
+        array_view = np.fliplr(array_view)  # Flip horizontally (along columns)
+
+    return array_view
+
+
+def save_image(fpath: str, image: sitk.Image, wl: list[int], flipped=False):
+    # arr = sitk.GetArrayViewFromImage(image)
+    arr = get_aligned_array_view(image)
+
+    if flipped:
+        print("flipping")
+        arr = np.fliplr(arr)
+
+    wl_min = wl[0]
+    wl_max = wl[1]
+
+    img = 255 * (arr - wl_min) / (wl_max - wl_min)
+
+    png_img = np.clip(img, a_min=0, a_max=255).astype(np.uint8)
+    pil_img = Image.fromarray(png_img)
+    pil_img.save(fpath)
+
+
+def save_image_mask(
+    fpath: str,
+    image: "sitk.Image",
+    wl: list[int],
+    flipped: bool = False,
+    mask: "sitk.Image | None" = None,
+    mask_color: tuple[int, int, int] = (255, 0, 0),  # Default to Red
+    alpha: float = 0.5,  # Transparency (0.0 to 1.0)
+):
+    # Process base image
+    arr = get_aligned_array_view(image)
+
+    if flipped:
+        print("flipping")
+        arr = np.fliplr(arr)
+
+    wl_min = wl[0]
+    wl_max = wl[1]
+
+    img = 255 * (arr - wl_min) / (wl_max - wl_min)
+    png_img = np.clip(img, a_min=0, a_max=255).astype(np.uint8)
+
+    # Convert base image to RGBA for blending
+    pil_img = Image.fromarray(png_img).convert("RGBA")
+
+    # Process and composite mask if provided
+    if mask is not None:
+        mask_arr = get_aligned_array_view(mask)
+
+        if flipped:
+            mask_arr = np.fliplr(mask_arr)
+
+        # Ensure mask is boolean (assuming >0 is the region of interest)
+        mask_bool = mask_arr > 0
+
+        # Create an empty RGBA array for the overlay
+        # Shape will be (Height, Width, 4)
+        overlay_arr = np.zeros((*png_img.shape, 4), dtype=np.uint8)
+
+        # Fill the mask regions with the specified color and alpha
+        alpha_val = int(255 * alpha)
+        overlay_arr[mask_bool] = mask_color + (alpha_val,)
+
+        # Convert overlay to PIL Image and blend
+        overlay_img = Image.fromarray(overlay_arr, mode="RGBA")
+        pil_img = Image.alpha_composite(pil_img, overlay_img)
+
+    # Convert back to RGB to drop the alpha channel before saving as a standard PNG
+    final_img = pil_img.convert("RGB")
+    final_img.save(fpath)
+
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+
+def _iso_project(pt_3d, scale=3.0, offset=(75, 75)):
+    """
+    Projects a 3D point (X, Y, Z) into 2D isometric space.
+    """
+    x, y, z = pt_3d
+    # Standard isometric projection angles (30 degrees)
+    cos30 = 0.866025
+    sin30 = 0.5
+
+    # Calculate 2D coordinates
+    u = (x - y) * cos30
+    # Invert Z because PIL's Y-axis goes down
+    v = -z + (x + y) * sin30
+
+    return (u * scale + offset[0], v * scale + offset[1])
+
+
+def _generate_plane_corners(center, normal, size=20.0):
+    """Generates 3D corners of a square plane given a center and normal."""
+    normal = np.array(normal, dtype=float)
+    normal /= np.linalg.norm(normal)
+
+    if abs(normal[0]) > 0.9:
+        arbitrary_dir = np.array([0.0, 1.0, 0.0])
+    else:
+        arbitrary_dir = np.array([1.0, 0.0, 0.0])
+
+    u = np.cross(normal, arbitrary_dir)
+    u /= np.linalg.norm(u)
+    v = np.cross(normal, u)
+
+    s = size / 2.0
+    return [
+        center + s * u + s * v,
+        center - s * u + s * v,
+        center - s * u - s * v,
+        center + s * u - s * v,
+    ]
+
+
+def _render_fast_3d_inset(current_node, prev_nodes, inset_size=(150, 150)):
+    """Renders 3D axes and planes directly to a transparent PIL Image."""
+    inset = Image.new("RGBA", inset_size, (0, 0, 0, 0))  # Fully transparent
+    draw = ImageDraw.Draw(inset)
+
+    center_offset = (inset_size[0] // 2, inset_size[1] // 2)
+    c_curr = np.array(current_node.center)
+
+    primitives = []
+
+    # 1. Prepare previous planes
+    for i, p_node in enumerate(prev_nodes):
+        # Shift relative to current center
+        rel_center = np.array(p_node.center) - c_curr
+        corners = _generate_plane_corners(rel_center, p_node.normal, size=25.0)
+
+        # Calculate depth for Painter's Algorithm (smaller sum = further away)
+        depth = sum(rel_center)
+        alpha = int(max(30, 150 - i * 30))  # Fades out older planes
+
+        primitives.append(
+            {
+                "type": "poly",
+                "pts": corners,
+                "color": (30, 144, 255, alpha),  # Dodger Blue
+                "outline": (255, 255, 255, int(alpha * 1.5)),
+                "depth": depth,
+            }
+        )
+
+    # 2. Prepare current plane
+    curr_corners = _generate_plane_corners(
+        np.array([0, 0, 0]), current_node.normal, size=25.0
+    )
+    primitives.append(
+        {
+            "type": "poly",
+            "pts": curr_corners,
+            "color": (220, 20, 60, 200),  # Crimson Red
+            "outline": (255, 255, 255, 255),
+            "depth": 0.0,
+        }
+    )
+
+    # 3. Prepare Axes (Length = 20)
+    axis_len = 20.0
+    axes_data = [
+        ([0, 0, 0], [axis_len, 0, 0], (255, 50, 50, 200)),  # X: Red
+        ([0, 0, 0], [0, axis_len, 0], (50, 255, 50, 200)),  # Y: Green
+        ([0, 0, 0], [0, 0, axis_len], (50, 100, 255, 200)),  # Z: Blue
+    ]
+    for start, end, color in axes_data:
+        depth = sum(start) + sum(end) / 2.0  # Midpoint depth
+        primitives.append(
+            {"type": "line", "pts": [start, end], "color": color, "depth": depth}
+        )
+
+    # 4. Sort all primitives by depth (draw furthest first)
+    primitives.sort(key=lambda x: x["depth"])
+
+    # 5. Draw to canvas
+    for prim in primitives:
+        pts_2d = [
+            _iso_project(pt, scale=2.5, offset=center_offset) for pt in prim["pts"]
+        ]
+
+        if prim["type"] == "poly":
+            draw.polygon(pts_2d, fill=prim["color"], outline=prim["outline"])
+        elif prim["type"] == "line":
+            draw.line(pts_2d, fill=prim["color"], width=2)
+
+    return inset
+
+
+def save_node(
+    n: Node,
+    filename: str,
+    wl: tuple[int, int] = (-500, 1500),
+    mask_color: tuple[int, int, int] | None = None,
+):
+    """
+    Saves the node's image with an optimized custom 3D spatial inset.
+    wl is defined as (Window Level/Center, Window Width).
+    """
+    # level, width = wl
+    # lower = level - (width / 2.0)
+    # upper = level + (width / 2.0)
+
+    lower, upper = wl
+    width = upper - lower
+
+    img = get_aligned_array_view(n.img)
+    mask = get_aligned_array_view(n.mask)
+
+    # 1. Apply Window/Level (explicitly maps lower -> 0, upper -> 255)
+    img_float = img.astype(float)
+    img_clipped = np.clip(img_float, lower, upper)
+    img_norm = (img_clipped - lower) / width
+    img_uint8 = (img_norm * 255.0).astype(np.uint8)
+
+    # Convert to RGB by stacking the grayscale channels
+    img_rgb = np.stack((img_uint8,) * 3, axis=-1)
+    base_img = Image.fromarray(img_rgb).convert("RGBA")
+
+    # 2. Composite the mask if requested
+    if mask_color is not None:
+        overlay = np.zeros((*mask.shape, 4), dtype=np.uint8)
+        overlay[mask > 0] = (*mask_color[:3], 100)  # Ensure valid alpha
+
+        mask_img = Image.fromarray(overlay, mode="RGBA")
+        base_img = Image.alpha_composite(base_img, mask_img)
+
+    # 3. Traverse linked list to get up to 5 previous nodes
+    prev_nodes = []
+    curr = n
+    while getattr(curr, "prev", None) and len(prev_nodes) < 5:
+        p_node = curr.prev[0] if isinstance(curr.prev, list) else curr.prev
+        if p_node is None:
+            break
+        prev_nodes.append(p_node)
+        curr = p_node
+
+    # 4. Generate and paste the fast 3D inset
+    inset_img = _render_fast_3d_inset(n, prev_nodes)
+
+    # Paste in the top right corner. The mask acts as its own alpha channel.
+    paste_x = base_img.width - inset_img.width - 10
+    paste_y = 10
+    base_img.paste(inset_img, (paste_x, paste_y), inset_img)
+
+    # 5. Save to disk
+    final_img = base_img.convert("RGB")
+    final_img.save(filename)
+
+
+def _dataset_from_labels(dataset_dir: str, file_ext: str) -> dict:
+    files = os.listdir(os.path.join(dataset_dir, "labelsTr"))
+    label_files = []
+    for f in files:
+        if f.endswith(file_ext):
+            label_files.append(os.path.join(dataset_dir, "labelsTr", f))
+
+    num_files = len(label_files)
+
+    dataset = {
+        "channel_names": {"0": "CT"},
+        "labels": {"background": 0, "mask": 1},
+        "numTraining": num_files,
+        "file_ending": file_ext,
+        # "overwrite_image_reader_writer": "SimpleITKIO"
+    }
+    return dataset
+
+
+def _dataset_file(dataset_dir: str):
+    filepath = os.path.join(dataset_dir, "dataset.json")
+    dataset = _dataset_from_labels(dataset_dir, ".nii.gz")
+    with open(filepath, "w") as f:
+        json.dump(dataset, f)
+
+
+def save_node_nnunet(n: Node, dataset_dir: str, case_id: str):
+    img = n.img
+    mask = n.mask
+
+    img_dir = os.path.join(dataset_dir, "imagesTr")
+    img_path = os.path.join(img_dir, f"{case_id}_0000.nii.gz")
+
+    label_dir = os.path.join(dataset_dir, "labelsTr")
+    label_path = os.path.join(label_dir, f"{case_id}.nii.gz")
+
+    os.makedirs(img_dir, exist_ok=True)
+    os.makedirs(label_dir, exist_ok=True)
+
+    sitk.WriteImage(img, img_path)
+    sitk.WriteImage(mask, label_path)

arcn-0.0.0/src/arcn/label.py

@@ -0,0 +1,64 @@
+import os
+import argparse
+
+from . import io
+from .manifold import Manifold
+
+from .relabeling import manual_relabel
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("study_dir")
+    ap.add_argument("--seg", help="seed segmentation to intialize with")
+    ap.add_argument("--out", help="labeling output directory")
+    ap.add_argument(
+        "--debug-out", help="save preview images after relabeling", default=None
+    )
+    ap.add_argument("--fov", help="field of view in cm", default=5.0)
+    ap.add_argument(
+        "--nnunet-out",
+        help="output updated labels to nnU-Net-structured dataset dir",
+        default=5.0,
+    )
+    ap.add_argument(
+        "--nnunet-prefix", help="case prefix for nnU-Net samples", default="arcn"
+    )
+    ap.add_argument(
+        "--N",
+        help="final number of slices to produce from the volume",
+        default=128,
+    )
+
+    wmin = -1000
+    wmax = 350
+
+    args = ap.parse_args()
+
+    img = io.load_series(args.study_dir)
+    mask = io.load_mask(args.seg)
+
+    # Takes care of the initial resampling
+    m = Manifold(img, mask, 32, fov=float(args.fov))
+
+    # Take care of the relabeling
+    manual_relabel(m.nodes)
+
+    # Save PNGs to verify alignment
+    if args.debug_out is not None:
+        output_dir = args.debug_out
+        for i, node in enumerate(m.nodes):
+            path = os.path.join(output_dir, f"{str(i).zfill(3)}.png")
+            io.save_node(node, path, wl=(int(wmin), int(wmax)), mask_color=(255, 0, 0))
+
+    # Save nnU-Net output
+    if args.nnunet_out is not None:
+        output_dir = args.nnunet_out
+        for i, node in enumerate(m.nodes):
+            case_id = f"{args.nnunet_prefix}_{str(i).zfill(4)}"
+            io.save_node_nnunet(node, output_dir, case_id)
+
+        from .io import _dataset_file
+
+        # Render metadata from the updated datasets
+        _dataset_file(output_dir)

arcn-0.0.0/src/arcn/manifold.py

@@ -0,0 +1,179 @@
+import sys
+import queue
+from typing import Iterable
+import SimpleITK as sitk
+import numpy as np
+
+from . import semantics
+from .resample_image import _resample_image
+
+from .node import Node
+
+
+# Base class describes the general user-oriented interface
+# Implicitly assumes incoming mask has a single centerline
+class Manifold:
+    def __init__(
+        self,
+        img: sitk.Image,
+        mask: sitk.Image,
+        num_initial_nodes: int,
+        fov: float | None = None,
+    ):
+
+        self.nodes = []
+
+        self.img = img
+        self.seed_mask = mask
+        self.search_nodes = queue.Queue()
+
+        n_centers = num_initial_nodes
+        centers = semantics.path_seed_points(self.seed_mask, n_centers)
+        normals = semantics.reconstruction_normals(centers)
+        up_vectors = semantics.generate_up_vectors(normals)
+        fovs = semantics.estimate_fovs(centers, normals, img, mask)
+
+        prev_node = None
+        for i, data in enumerate(zip(centers, normals, up_vectors, fovs)):
+
+            c = list(data[0])
+            n = list(data[1])
+            up = list(data[2])
+            f = data[3]
+
+            curr_node = Node(c, n, prev_node)
+
+            if fov is not None:
+                f = fov
+
+            curr_node.img = _resample_image(self.img, c, n, up, 512, f)
+            curr_node.mask = _resample_image(self.seed_mask, c, n, up, 512, f)
+
+            # Add final center to search list
+            if i == n_centers - 1:
+                self.search_nodes.put(curr_node)
+                break
+
+            self.nodes.append(curr_node)
+            prev_node = curr_node
+
+    # def relabel(self, N: int | None = None):
+
+    #     # Generate the list of nodes to relabel
+    #     node_list = []
+
+    #     for i, n in enumerate(self.nodes):
+    #         if N is not None and i >= N:
+    #             break
+
+    #         node_list.append(n)
+
+    #     manual_relabel(node_list)
+
+    def reconstruct(self):
+        raise NotImplementedError
+
+    def visualize(self):
+        raise NotImplementedError
+
+
+class Airway(Manifold):
+    def visualize(self):
+        pass
+
+    def reconstruct(self, output_dir: str | None = None):
+        # WARN: this implementation is not intended to be parallel-friendly, just illustrative
+
+        # Save out already added nodes
+        for n in self.nodes:
+            n.save(output_dir)
+
+        # Begin the reconstruction search
+        daughter_nodes = []
+        while not self.search_nodes.empty():
+            curr_node = self.search_nodes.get()
+
+            # NOTE: curr_node will be returned with tube_nodes.
+            # connectivity information will be set inside of _search_to_bifurcation
+            daughter_nodes, tube_nodes = self._search_to_bifurcation(curr_node)
+
+            # Add non-search nodes into the manifold structure
+            for n in tube_nodes:
+                self.nodes.append(n)
+
+                # if output_dir is not None:
+                #     n.save(output_dir)
+
+            # Add search nodes to search queue (note: current implementation is breadth-first search)
+            [self.search_nodes.put(n) for n in daughter_nodes]
+
+    def _search_to_bifurcation(self, n: Node) -> tuple[Iterable[Node], Iterable[Node]]:
+        # TASK: given n, estimate the next tublar node
+        # n is passed as a *daughter_node* from a previous tube
+        # Search procedure is to incrementally step and detect airway
+        # util a bifurcation/trifurcation is detected.
+
+        prev_radius = n.prev[0].radius
+
+        # airway should occupy roughly 1/5 of the FOV; could be a good
+        # tuneable parameter. includes estimate of the *target* radius for which
+        # we have the scaling law: r^{k}_{parent} = r^{k}_{d1} + r^{k}_{d2} If
+        # we assume r_d1 == r_d2, then this results in r_d ~= 0.8 * r_parent
+        fov = 10 * (0.8 * prev_radius)
+
+        step_size = 0.05
+
+        daughter_nodes = []
+        tube_nodes = []
+
+        node_centers = n.cluster_centroids()
+
+        if len(node_centers) != 1:
+            print("ERROR more nodes than expected for tube root")
+            sys.exit(1)
+
+        prev_node = n
+        while len(node_centers) == 1:
+
+            # Generate the next node based on previous node/graph information
+            new_center = step_size * np.array(prev_node.normal) + np.array(
+                prev_node.center
+            )
+
+            _, normal = prev_node.predict_perpendicular_plane(
+                new_center.tolist(), u=1.00, smoothing=0.01
+            )
+
+            normal = -normal
+
+            print(normal)
+
+            new_node = Node(new_center.tolist(), normal.tolist(), prev_node)
+
+            # Instantiate node's imaging data
+            new_node.img = _resample_image(
+                self.img, new_center.tolist(), normal.tolist(), [0, 1, 0], 512, 5.0
+            )
+            # new_node.resample_image(self.img)
+            new_node.generate_mask()
+
+            # new_node.save("tmp")
+
+            # NOTE: All mask cleanup and postprocessing must be completed by this point
+
+            # Evaluate for next/new centers
+            node_centers = new_node.cluster_centroids()
+            # print(node_centers)
+
+            if len(node_centers) == 1:
+                tube_nodes.append(new_node)
+                prev_node = new_node
+
+        for curr_center in node_centers:
+            # curr_normal = prev_node.predict_normal(curr_center)
+            center, curr_normal = prev_node.predict_perpendicular_plane(curr_center)
+            # dn = Node(curr_center, curr_normal, prev_node)
+            dn = Node(center, curr_normal, prev_node)
+            daughter_nodes.append(dn)
+
+        return (daughter_nodes, tube_nodes)