Changes

Author: dkuegler

CorpusCallosum/cc_visualization.py

@@ -135,16 +135,18 @@ def load_contours_from_template_dir(
             num_thickness_values = np.sum(~np.isnan(np.array(thickness_values[1:],dtype=float)))
             if fsaverage_contour is None:
                 fsaverage_contour = load_fsaverage_cc_template()
-                # create measurement points (points = 2 x levelpaths) accorindg to number of thickness values
+                # create measurement points (points = 2 x levelpaths) according to number of thickness values
                 fsaverage_contour.create_levelpaths(num_points=num_thickness_values // 2, update_data=True)
             current_contour = fsaverage_contour.copy()
             current_contour.load_thickness_values(thickness_file)
 
         else:
             # this is kinda ugly - maybe we need to overload the constructor to load the contour and thickness values?
-            current_contour = CCContour(np.empty((0, 2)), np.empty((0,)), resolution=resolution)
-            current_contour.load_contour(contour_file)
-            current_contour.load_thickness_values(thickness_file)
+            # FIXME: The z_position in from_contour is still incorrect, currently all Contours would be "registered" for
+            #        the midslice.
+            current_contour = CCContour.from_contour_file(contour_file, thickness_file, z_position=0.0)
+            # current_contour.load_contour(contour_file)
+            # current_contour.load_thickness_values(thickness_file)
 
         current_contour.fill_thickness_values()
         contours.append(current_contour)
@@ -194,6 +196,7 @@ def main(
         return 0
 
     # 3D visualization
+    # FIXME: This function would need contours[i].z_position to be properly initialized!
     cc_mesh = CCMesh.from_contours(contours, smooth=0)
 
     plot_kwargs = dict(
@@ -205,7 +208,8 @@ def main(
     cc_mesh.plot_mesh(**plot_kwargs)
     cc_mesh.plot_mesh(output_path=str(output_dir / "cc_mesh.html"), **plot_kwargs)
 
-    cc_mesh = cc_mesh.to_fs_coordinates(lr_offset=FSAVERAGE_MIDDLE / resolution)
+    #FIXME: needs to be adapted to new interface of CCMesh.to_fs_coordinates / to_vox_coordinates
+    cc_mesh = cc_mesh.to_vox_coordinates(lr_offset=FSAVERAGE_MIDDLE / resolution)
     logger.info(f"Writing vtk file to {output_dir / 'cc_mesh.vtk'}")
     cc_mesh.write_vtk(str(output_dir / "cc_mesh.vtk"))
     logger.info(f"Writing freesurfer surface file to {output_dir / 'cc_mesh.fssurf'}")

CorpusCallosum/data/fsaverage_cc_template.py

@@ -14,6 +14,7 @@
 
 import os
 from pathlib import Path
+from typing import cast
 
 import nibabel as nib
 import numpy as np
@@ -22,8 +23,12 @@
 from CorpusCallosum.data import constants
 from CorpusCallosum.shape.contour import CCContour
 from CorpusCallosum.shape.postprocessing import recon_cc_surf_measure
+from FastSurferCNN.utils import nibabelImage
 from FastSurferCNN.utils.brainvolstats import mask_in_array
 
+FSAVERAGE_PC_COORDINATE = np.array([131, 99])
+FSAVERAGE_AC_COORDINATE = np.array([135, 130])
+
 
 def smooth_contour(contour: tuple[np.ndarray, np.ndarray], window_size: int = 5) -> tuple[np.ndarray, np.ndarray]:
     """Smooth a contour using a moving average filter.
@@ -62,18 +67,16 @@ def smooth_contour(contour: tuple[np.ndarray, np.ndarray], window_size: int = 5)
     return (x_smoothed, y_smoothed)
 
 
-def load_fsaverage_cc_template() -> tuple[
-    np.ndarray, tuple[np.ndarray, np.ndarray], np.ndarray, np.ndarray, np.ndarray, tuple[int, int]
-]:
+def load_fsaverage_cc_template() -> CCContour:
     """Load and process the fsaverage corpus callosum template.
 
     This function loads the fsaverage segmentation from FreeSurfer's data directory,
     extracts the corpus callosum mask, and processes it to create a smooth template.
 
     Returns
     -------
-    tuple
-        Contains:
+    CCContour
+        Object with all the contour information including:
         - contour : tuple[np.ndarray, np.ndarray] : x and y coordinates of the contour points.
         - anterior_endpoint_idx : np.ndarray : Index of the anterior endpoint.
         - posterior_endpoint_idx : np.ndarray : Index of the posterior endpoint.
@@ -95,13 +98,9 @@ def load_fsaverage_cc_template() -> tuple[
                       f"FREESURFER_HOME environment variable") from err
 
     fsaverage_seg_path = freesurfer_home / 'subjects' / 'fsaverage' / 'mri' / 'aparc+aseg.mgz'
-    fsaverage_seg = nib.load(fsaverage_seg_path)
+    fsaverage_seg = cast(nibabelImage, nib.load(fsaverage_seg_path))
     segmentation = np.asarray(fsaverage_seg.dataobj)
 
-    PC = np.array([131, 99])
-    AC = np.array([135, 130])
-
-
     midslice = segmentation.shape[0]//2 +1
 
     cc_mask = mask_in_array(segmentation[midslice], constants.SUBSEGMENT_LABELS)
@@ -124,9 +123,9 @@ def load_fsaverage_cc_template() -> tuple[
     _, contour_with_thickness, (anterior_endpoint_idx, posterior_endpoint_idx) = recon_cc_surf_measure(
         segmentation=cc_mask[None],
         slice_idx=0,
-        ac_coords=AC,
-        pc_coords=PC,
-        affine=fsaverage_seg.affine,
+        ac_coords_vox=FSAVERAGE_AC_COORDINATE,
+        pc_coords_vox=FSAVERAGE_PC_COORDINATE,
+        slice_lia_vox2midslice_ras=fsaverage_seg.affine,
         num_thickness_points=100,
         subdivisions=[1/6, 1/2, 2/3, 3/4],
         subdivision_method="shape",
@@ -148,7 +147,7 @@ def load_fsaverage_cc_template() -> tuple[
     fsaverage_contour = CCContour(np.array(outside_contour).T, 
                                   np.zeros(len(outside_contour[0])), 
                                   endpoint_idxs=(anterior_endpoint_idx, posterior_endpoint_idx), 
-                                  resolution=1.0)
+                                  z_position=0.0)
 
 
     return fsaverage_contour

CorpusCallosum/data/read_write.py

@@ -20,17 +20,18 @@
 from numpy import typing as npt
 
 import FastSurferCNN.utils.logging as logging
-from FastSurferCNN.utils import AffineMatrix4x4, nibabelImage
+from FastSurferCNN.utils import AffineMatrix4x4, RotationMatrix3x3, Vector3d, nibabelImage
 from FastSurferCNN.utils.parallel import thread_executor
 
+logger = logging.get_logger(__name__)
 
-class FSAverageHeader(TypedDict):
-    dims: npt.NDArray[int]
-    delta: npt.NDArray[float]
-    Mdc: npt.NDArray[float]
-    Pxyz_c: npt.NDArray[float]
 
-logger = logging.get_logger(__name__)
+class MGHHeaderDict(TypedDict):
+    """A dictionary with the four required fields of a MGH Header"""
+    dims: Vector3d
+    delta: Vector3d
+    Mdc: RotationMatrix3x3
+    Pxyz_c: Vector3d
 
 
 def calc_ras_centroids_from_seg(seg_img: nibabelImage, label_ids: list[int] | None = None) \
@@ -154,7 +155,7 @@ def load_fsaverage_affine(affine_path: str | Path) -> npt.NDArray[float]:
     return affine_matrix
 
 
-def load_fsaverage_data(data_path: str | Path) -> tuple[AffineMatrix4x4, FSAverageHeader]:
+def load_fsaverage_data(data_path: str | Path) -> tuple[AffineMatrix4x4, MGHHeaderDict]:
     """Load fsaverage affine matrix and header fields from static JSON file.
 
     Parameters
@@ -206,13 +207,13 @@ def load_fsaverage_data(data_path: str | Path) -> tuple[AffineMatrix4x4, FSAvera
 
     # Convert lists back to numpy arrays
     affine_matrix = np.array(data["affine"])
-    header_data = FSAverageHeader(
+    header_data = MGHHeaderDict(
         dims=data["header"]["dims"],
         delta=data["header"]["delta"],
         Mdc=np.array(data["header"]["Mdc"]),
         Pxyz_c=np.array(data["header"]["Pxyz_c"]),
     )
-    
+
     # Validate affine matrix shape
     if affine_matrix.shape != (4, 4):
         raise ValueError(f"Expected 4x4 affine matrix, got shape {affine_matrix.shape}")