From 67172483b47ddeae287b3e93d634655ee32fd602 Mon Sep 17 00:00:00 2001 From: Stephen Aylward Date: Sun, 20 Sep 2026 23:32:27 -0400 Subject: [PATCH 1/2] ENH: registrar/segmenter factories, Tutorial 00 - tutorials/parameters_*.py: replace raw greedy-iteration fields with registration_class + registrar()/segmenter() factory methods that return a ready-tuned registrar/segmenter per anatomy - Update lung/heart tutorials (01-13) to use the new factories instead of constructing RegisterImagesGreedy/segmenters by hand - Add tutorials/tutorial_00_lung_demo.ipynb: self-contained demo that downloads Chest-CT and a pretrained PhysicsNeMo-MGN-Lung-Motion checkpoint and predicts lung motion end-to-end with no prior tutorial run - process_transforms.py/workflow_infer_movement.py: add restrict_deformation_field_to_normal_falloff_outside_mask for the cardiac/respiratory slip-interface split used by Tutorial 13 - workflow_convert_vtk_to_usd.py: fix mesh-path lookup to use the sanitized data_basename instead of the raw usd_project_name - Document Tutorial 00 in docs/index.rst, docs/tutorials.rst, and tutorials/README.md; fix Tutorial 3's stale RegisterImagesGreedy() snippet - pyproject.toml: drop two dangling tutorial_08/09_lung_all mypy override entries with no matching files --- docs/assets/tutorial_00_lung_usd.gif | 3 + docs/index.rst | 7 +- docs/tutorials.rst | 94 ++- src/monai_physio/process_transforms.py | 240 +++--- .../workflow_convert_vtk_to_usd.py | 13 +- src/monai_physio/workflow_infer_movement.py | 43 ++ tests/test_process_transforms.py | 100 ++- tests/test_workflow_convert_vtk_to_usd.py | 27 + tutorials/README.md | 5 + tutorials/parameters_duke_heart_labelmaps.py | 49 +- tutorials/parameters_heart_ct_kcl.py | 51 +- tutorials/parameters_lung_ct_dirlab.py | 53 +- tutorials/parameters_tcia_4d_lung.py | 51 +- tutorials/tutorial_00_lung_demo.ipynb | 707 ++++++++++++++++++ .../tutorial_01_heart_gated_ct_to_usd.py | 11 +- tutorials/tutorial_01_lung_gated_ct_to_usd.py | 6 +- ...utorial_01_lung_gated_ct_to_usd_tetmesh.py | 11 +- ...02_duke_heart_distancemap_finetune_icon.py | 7 +- ...orial_02_lung_distancemap_finetune_icon.py | 10 +- tutorials/tutorial_02_lung_finetune_icon.py | 7 +- ...rial_03_heart_reconstruct_highres_4d_ct.py | 17 +- ...orial_03_lung_reconstruct_highres_4d_ct.py | 8 +- tutorials/tutorial_04_heart_ct_to_vtk.py | 7 +- tutorials/tutorial_04_lung_ct_to_vtk.py | 4 +- ...torial_06_lung_create_statistical_model.py | 3 +- ..._heart_fit_statistical_model_to_patient.py | 10 +- ...7_lung_fit_statistical_model_to_patient.py | 4 +- ...torial_08_lung_fit_model_to_4d_patients.py | 7 +- .../tutorial_10_lung_infer_physicsnemo_mgn.py | 2 +- .../tutorial_12_lung_end_to_end_inference.py | 25 +- .../tutorial_13_heart_and_lung_motion.py | 174 ++--- 31 files changed, 1378 insertions(+), 378 deletions(-) create mode 100644 docs/assets/tutorial_00_lung_usd.gif create mode 100644 tutorials/tutorial_00_lung_demo.ipynb diff --git a/docs/assets/tutorial_00_lung_usd.gif b/docs/assets/tutorial_00_lung_usd.gif new file mode 100644 index 00000000..f620747a --- /dev/null +++ b/docs/assets/tutorial_00_lung_usd.gif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b79cccc6cd5ef41ee02bfde415fe3c0aa4fd721ea71083e820ea9e7712a0fbfe +size 6126144 diff --git a/docs/index.rst b/docs/index.rst index 0dacef8c..8c77c1af 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -26,10 +26,15 @@
- 00 + Setup

Install and Clone

Install the package, then clone the repository - the tutorial scripts do not ship in the wheel.

 + + 00 +

Predict Lung Motion From a Single Chest CT

+

A self-contained demo: fit the shape model and predict motion with a pretrained network, nothing else to run first.

+ 01

Gated 4D CT to Animated USD

diff --git a/docs/tutorials.rst b/docs/tutorials.rst index f6486162..6e03eab2 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -16,7 +16,9 @@ Tutorials that is being released soon. Each one drives the real workflow classes end-to-end on downloadable data, shows what it produced, and ends with the handful of constants - to change so it runs on your own scans. + to change so it runs on your own scans. New to the toolkit? Tutorial 00 + is a self-contained demo notebook that runs the whole lung pipeline + from a single clone, with no earlier tutorial required.

@@ -82,6 +84,12 @@ second run is cheap and later tutorials pick up earlier results automatically. .. raw:: html
+ + 00 +

Predict Lung Motion From a Single Chest CT

+

A self-contained demo: fit the shape model and predict motion with a pretrained network, nothing else to run first.

+ Chest-CT · PhysicsNeMo-MGN-Lung-Motion + 01

Gated 4D CT to Animated USD

@@ -200,7 +208,8 @@ Tutorials are straightforward Python scripts: run one with editor and read it top to bottom. Numbers 1, 4 and 5 are the fastest way to see the toolkit work end-to-end; 6 through 18 build the statistical-model and AI-surrogate -pipeline on top. +pipeline on top. Tutorial 00 sits outside this chain - a notebook demo that +downloads everything it needs and predicts lung motion end-to-end on its own. 1. **Tutorial 1** - after downloading Slicer-Heart-CT. 2. **Tutorial 2** - after obtaining TCIA-4DLung. It writes the finetuned ICON @@ -233,6 +242,77 @@ pipeline on top. instead of reusing the surface one from Tutorials 6 to 8. Tutorial 17 then trains against that energy and Tutorial 18 scores it and reads out stress. +Tutorial 00 (Lung Demo): Predict Lung Motion From a Single Chest CT +==================================================================== + +Script + ``tutorials/tutorial_00_lung_demo.ipynb`` + +Workflow + :class:`~monai_physio.WorkflowFitStatisticalModelToPatient` and + :class:`~monai_physio.WorkflowInferMovement` (``process_time_series``) + driving a pretrained :class:`~monai_physio.WorkflowInferPhysicsNeMo` + MeshGraphNet, with :class:`~monai_physio.SegmentChestTotalSegmentator`. + +Dataset + Chest-CT (auto-download): a single ungated chest CT, unlike the gated + series the numbered tutorials use. The pretrained + PhysicsNeMo-MGN-Lung-Motion checkpoint (auto-download) ships its own PCA + shape model, so no Tutorial 6 or Tutorial 9 run is needed first. + +Requirements + GPU, for segmentation and the MeshGraphNet forward pass. + +Preview + .. figure:: assets/tutorial_00_lung_usd.gif + :alt: Animated lung USD produced by Tutorial 00 + :width: 90% + + Predicted lung motion across the demo respiratory-stage grid. + +Inner API usage + .. code-block:: python + + fit_workflow = WorkflowFitStatisticalModelToPatient( + template_model=pca_mean_surface, + patient_models=[lung_surface], + patient_image=patient_image, + patient_labelmap=lung_labelmap, + ) + fit_workflow.set_use_pca_registration( + use_pca_registration=True, + pca_model=pca_model, + number_of_pca_components=number_of_pca_components, + use_surface=False, + ) + fit_result = fit_workflow.process() + + infer_workflow = WorkflowInferPhysicsNeMo(model_directory=model_dir) + infer_result = WorkflowInferMovement(infer_workflow).process_time_series( + shape_parameters=pca_coefficients_file, + stages=stages, + output_directory=output_dir, + fitted_reference_mesh=fitted_reference_mesh_file, + reference_image=patient_image, + anatomy_type="lung", + ) + +Run + .. code-block:: bash + + jupyter notebook tutorials/tutorial_00_lung_demo.ipynb + +Outputs + The per-stage warped CTs, predicted VTP surfaces, and one animated USD, + under ``tutorials/output/tutorial_00_lung_demo/``. + +Adapt to your data + Swap the downloaded ``Chest-CT`` volume for your own ungated chest CT, + and point ``model_dir`` at a different checkpoint - either the one + Tutorial 9 trains, or a pretrained one for another anatomy - to demo a + different cohort or organ. This is a standalone shortcut, not step one + of the numbered series: start at Tutorial 1 for the full pipeline. + Tutorial 1: Gated 4D CT to Animated USD ======================================= @@ -448,8 +528,7 @@ Preview Inner API usage .. code-block:: python - registration_method = RegisterImagesGreedy() - registration_method.set_number_of_iterations([30, 15, 7, 3]) + registration_method = HEART_CT_KCL.registrar(test_mode, log_level=log_level) workflow = WorkflowReconstructHighres4DCT( time_series_images=time_series, @@ -475,9 +554,10 @@ Adapt to your data Set ``case_glob`` and ``data_dir`` to your series and pick the reference with ``reference_time_frame``. If you have a separate breath-hold or contrast-enhanced volume, pass it as ``reference_image`` instead of one of - the phases - that is what the workflow is really designed for. Tune - ``number_of_iterations_greedy`` down for a fast smoke test. The saved - ``.hdf`` transforms are reusable: + the phases - that is what the workflow is really designed for. The + iteration schedule comes from ``HEART_CT_KCL.registrar(test_mode, ...)``, + which already shortens it for a fast smoke test when ``test_mode`` is set. + The saved ``.hdf`` transforms are reusable: :class:`~monai_physio.ProcessTransforms` applies them to meshes and labelmaps. Tutorial 4: CT Segmentation to VTK Surfaces diff --git a/src/monai_physio/process_transforms.py b/src/monai_physio/process_transforms.py index 94a6f962..eb3fe25d 100644 --- a/src/monai_physio/process_transforms.py +++ b/src/monai_physio/process_transforms.py @@ -678,9 +678,6 @@ def smooth_deformation_field_transform( field: itk.Image, sigma: float, weight_image: Optional[itk.Image] = None, - normal_image: Optional[itk.Image] = None, - interior_mask: Optional[itk.Image] = None, - exterior_sigma: Optional[float] = None, ) -> itk.DisplacementFieldTransform: """Spread a sparsely sampled deformation field into a continuous one. @@ -693,19 +690,12 @@ def smooth_deformation_field_transform( the empty voxels a plain blur would average in. Far from every sample the smoothed weight vanishes and the field decays to zero. - That spread is otherwise isotropic, and carries the whole displacement - vector outward. Giving ``normal_image`` and ``interior_mask`` splits each - sample into the component along the surface normal, which expansion and - contraction live in, and the tangential remainder, which sliding lives - in, and spreads only the normal component outside the mask. Tissue - beyond an organ is then pushed and pulled by it without being dragged - along it, which is how a slip interface such as the pleura or the - pericardium behaves. Inside the mask the full vector is spread, so the - organ's own contents still follow its surface. ``exterior_sigma`` sets - how far that outward push and pull carries, independently of the sigma - filling the organ itself. - ``exterior_normal_scale`` sets how much of that normal component the - surrounding tissue actually receives. + This spread is isotropic and carries the whole displacement vector + outward. To restrict that spread to an organ's surface normal beyond a + mask -- e.g. so a slip interface such as the pleura or the pericardium + does not drag surrounding tissue along tangentially -- smooth first with + this method, then pass the result to + :meth:`restrict_deformation_field_to_normal_falloff_outside_mask`. Args: field (itk.Image): Input vector deformation field, sampled where @@ -718,105 +708,165 @@ def smooth_deformation_field_transform( Omit to weight every voxel holding a non-zero displacement equally, which cannot tell an empty voxel from a genuinely zero-displacement one. - normal_image (Optional[itk.Image]): Per-voxel unit surface normal on - ``field``'s grid, as - :meth:`WorkflowInferMovement.create_deformation_field` returns - alongside the field. Samples whose normal is zero are spread - whole, having no direction to project onto. - interior_mask (Optional[itk.Image]): Scalar image on ``field``'s - grid, 1 where the full displacement should be spread and 0 where - only its normal component should be. Soften its edge to set the - width of the band the tangential motion dies out over; a binary - mask makes the boundary a discontinuity. - exterior_sigma (Optional[float]): Smoothing sigma (millimeters) for - the normal component spread outside ``interior_mask``, in place - of ``sigma``. This is how far the organ reaches into the tissue - around it: a smaller value confines its push and pull to a - narrower shell without weakening the displacement at the - surface, and without touching the spread inside the mask. - Defaults to ``sigma``. Ignored when no mask is given. Returns: itk.DisplacementFieldTransform: Smoothed field transform. Raises: - ValueError: If only one of ``normal_image`` and ``interior_mask`` is - given, if either does not lie on ``field``'s grid, or if the - field holds no non-zero samples to spread. + ValueError: If the field holds no non-zero samples to spread. """ - if (normal_image is None) != (interior_mask is None): - raise ValueError( - "normal_image and interior_mask must be given together: the " - "normals say what to project onto, the mask says where to." - ) - field_arr = itk.array_from_image(field).astype(np.float64) if weight_image is not None: weights = itk.array_from_image(weight_image).astype(np.float64) else: weights = (np.linalg.norm(field_arr, axis=3) > 0.0).astype(np.float64) - # Outside the mask only the normal component of each sample is spread, - # and it may be spread by a sigma of its own. Each set therefore carries - # the sigma that both its samples and the weights normalizing them are - # smoothed by, so a narrower exterior spread stays normalized against - # the weight that reached the same distance. - sample_sets = [(field_arr, sigma)] - mask: Optional[np.ndarray] = None - if normal_image is not None and interior_mask is not None: - normals = itk.array_from_image(normal_image).astype(np.float64) - mask = itk.array_from_image(interior_mask).astype(np.float64) - if normals.shape != field_arr.shape or mask.shape != field_arr.shape[:3]: - raise ValueError( - f"normal_image {normals.shape} and interior_mask " - f"{mask.shape} must lie on the field's grid " - f"{field_arr.shape}." - ) - projected = (field_arr * normals).sum(axis=3, keepdims=True) * normals - # A vertex interior to a volumetric template carries a zero normal. - # Projecting it would delete a sample the weights still count in the - # denominator, biasing the result toward zero rather than leaving the - # sample unprojected, so those keep their full displacement. - unoriented = np.linalg.norm(normals, axis=3) == 0.0 - projected[unoriented] = field_arr[unoriented] - sample_sets.append( - (projected, sigma if exterior_sigma is None else exterior_sigma) + spread = np.zeros_like(field_arr) + for dim in range(field_arr.shape[3]): + spread[:, :, :, dim] = self._smooth_scalar_array( + field_arr[:, :, :, dim] * weights, sigma, field ) - - smoothed_sets: list[np.ndarray] = [] - for samples, set_sigma in sample_sets: - spread = np.zeros_like(field_arr) - for dim in range(field_arr.shape[3]): - spread[:, :, :, dim] = self._smooth_scalar_array( - samples[:, :, :, dim] * weights, set_sigma, field - ) - smoothed_weights = self._smooth_scalar_array(weights, set_sigma, field) - - # Add a floor to the denominator rather than clamping to it. ITK's - # recursive Gaussian is an IIR approximation, so far from every - # sample both smoothed arrays ring around zero; clamping a - # denominator that small turns that ringing into displacements - # several times larger than any the samples carried, while adding to - # it lets the quotient fall off to zero there, which is what a field - # with no nearby sample should do. - weight_floor = 1.0e-3 * float(smoothed_weights.max()) - if weight_floor <= 0.0: - raise ValueError("Deformation field has no non-zero samples to spread.") - spread /= (np.maximum(smoothed_weights, 0.0) + weight_floor)[..., None] - smoothed_sets.append(spread) - - smoothed = smoothed_sets[0] - if mask is not None: - inside = np.clip(mask, 0.0, 1.0)[..., None] - smoothed = inside * smoothed_sets[0] + (1.0 - inside) * smoothed_sets[1] + smoothed_weights = self._smooth_scalar_array(weights, sigma, field) + + # Add a floor to the denominator rather than clamping to it. ITK's + # recursive Gaussian is an IIR approximation, so far from every + # sample both smoothed arrays ring around zero; clamping a + # denominator that small turns that ringing into displacements + # several times larger than any the samples carried, while adding to + # it lets the quotient fall off to zero there, which is what a field + # with no nearby sample should do. + weight_floor = 1.0e-3 * float(smoothed_weights.max()) + if weight_floor <= 0.0: + raise ValueError("Deformation field has no non-zero samples to spread.") + spread /= (np.maximum(smoothed_weights, 0.0) + weight_floor)[..., None] smoothed_field = ProcessImages().convert_array_to_image_of_vectors( - smoothed, reference_image=field, ptype=itk.D + spread, reference_image=field, ptype=itk.D ) field_transform = itk.DisplacementFieldTransform[itk.D, 3].New() field_transform.SetDisplacementField(smoothed_field) return field_transform + @staticmethod + def _smoothstep(ramp: np.ndarray) -> np.ndarray: + """Evaluate the cubic smoothstep ``3t^2 - 2t^3`` on ``ramp`` in ``[0, 1]``.""" + return cast(np.ndarray, ramp * ramp * (3.0 - 2.0 * ramp)) + + def restrict_deformation_field_to_normal_falloff_outside_mask( + self, + field: itk.Image, + normal_image: itk.Image, + mask: itk.Image, + direction_offset_mm: float = 0.0, + direction_transition_mm: float = 5.0, + falloff_distance_mm: float = 20.0, + ) -> itk.DisplacementFieldTransform: + """Restrict a dense field to its normal component and fade it outside a mask. + + Inside ``mask`` the field passes through unchanged, so an organ's own + contents still follow its surface. Beyond it, only the component of the + displacement along the surface normal is kept -- the expansion and + contraction, not the tangential sliding -- which is how a slip interface + such as the pleura or the pericardium behaves: surrounding tissue is + pushed and pulled by the organ without being dragged along it. That + normal component then fades to zero by ``falloff_distance_mm`` outside + the mask, so the push does not propagate indefinitely; a dense field + (unlike a sparsely sampled one) has no other mechanism to die out. + + Args: + field (itk.Image): Dense vector deformation field, e.g. the output + of :meth:`smooth_deformation_field_transform` + (``.GetDisplacementField()``). + normal_image (itk.Image): Per-voxel surface normal on ``field``'s + grid, dense the same way ``field`` is -- e.g. + :meth:`smooth_deformation_field_transform` applied to the raw + per-vertex normals :meth:`WorkflowInferMovement.create_deformation_field` + returns, with the same ``sigma``/``weight_image``. Renormalized + internally, so it need not be unit length; voxels where it is + near zero (no nearby surface to have spread from) keep their + full displacement, having no direction to project onto. + mask (itk.Image): Binary or label image on ``field``'s grid; any + non-zero value marks the organ's interior. + direction_offset_mm (float): Distance (millimeters) past the mask + boundary before the field starts switching to its normal + component. The fitted surface and the segmentation of the same + organ commonly disagree by about a voxel, so a small offset + keeps that disagreement from clipping tangential motion at the + boundary itself. + direction_transition_mm (float): Width (millimeters) of the band, + starting at ``direction_offset_mm``, over which the field blends + from its full vector to its normal component. Zero would make + the switch a discontinuity that shears neighboring voxels in + opposite directions and tears a warped volume. + falloff_distance_mm (float): Distance (millimeters) outside the + mask boundary over which the (by then normal-only) displacement + fades to zero. This is how far the organ's push and pull reaches + into the tissue around it. + + Returns: + itk.DisplacementFieldTransform: The restricted field transform. + + Raises: + ValueError: If ``normal_image`` or ``mask`` does not lie on + ``field``'s grid. + """ + field_arr = itk.array_from_image(field).astype(np.float64) + normals = itk.array_from_image(normal_image).astype(np.float64) + mask_arr = itk.array_from_image(mask).astype(np.float64) + if normals.shape != field_arr.shape or mask_arr.shape != field_arr.shape[:3]: + raise ValueError( + f"normal_image {normals.shape} and mask {mask_arr.shape} must " + f"lie on the field's grid {field_arr.shape}." + ) + + interior = itk.image_from_array((mask_arr > 0.5).astype(np.uint8)) + interior.CopyInformation(mask) + distance_mm = itk.array_from_image( + itk.signed_maurer_distance_map_image_filter( + interior, + InsideIsPositive=False, + SquaredDistance=False, + UseImageSpacing=True, + ) + ) + + # A voxel with no nearby surface to have spread a normal from -- an + # interior point of a volumetric template, or simply outside the reach + # of however normal_image was spread -- carries a near-zero normal. + # Projecting onto it would erase displacement no falloff should have + # touched, so those voxels keep their full vector instead. + normal_norm = np.linalg.norm(normals, axis=3) + unoriented = normal_norm < 1.0e-8 + unit_normals = normals / np.where(unoriented, 1.0, normal_norm)[..., None] + projected = (field_arr * unit_normals).sum(axis=3, keepdims=True) * unit_normals + projected[unoriented] = field_arr[unoriented] + + direction_ramp = np.clip( + (distance_mm - direction_offset_mm) / direction_transition_mm, 0.0, 1.0 + ) + direction_weight = 1.0 - self._smoothstep(direction_ramp) + direction_blended = ( + direction_weight[..., None] * field_arr + + (1.0 - direction_weight[..., None]) * projected + ) + + # Starts fading right at the mask boundary, independently of + # direction_offset_mm/direction_transition_mm: the direction switch and + # the reach of the push are different physical scales. + falloff_ramp = np.clip(distance_mm / falloff_distance_mm, 0.0, 1.0) + falloff_weight = np.where( + distance_mm <= 0.0, 1.0, 1.0 - self._smoothstep(falloff_ramp) + ) + + restricted = falloff_weight[..., None] * direction_blended + + restricted_field = ProcessImages().convert_array_to_image_of_vectors( + restricted, reference_image=field, ptype=itk.D + ) + field_transform = itk.DisplacementFieldTransform[itk.D, 3].New() + field_transform.SetDisplacementField(restricted_field) + return field_transform + @staticmethod def _smooth_scalar_array( array: np.ndarray, sigma: float, reference_image: itk.Image diff --git a/src/monai_physio/workflow_convert_vtk_to_usd.py b/src/monai_physio/workflow_convert_vtk_to_usd.py index 248a6284..7572b56d 100644 --- a/src/monai_physio/workflow_convert_vtk_to_usd.py +++ b/src/monai_physio/workflow_convert_vtk_to_usd.py @@ -365,15 +365,18 @@ def process(self) -> dict[str, Any]: ) stage = converter.convert(str(output_usd)) - # Post-process: apply chosen appearance to all meshes under /World/{usd_project_name} + # Post-process: apply chosen appearance to all meshes under + # /World/{root_prim_name}. ConvertVTKToUSD sanitizes usd_project_name + # into a valid USD identifier (e.g. "-" -> "_") for the actual prim + # path it writes, so that sanitized name -- not usd_project_name + # itself -- is what the lookup below must use. + root_prim_name = converter.data_basename usd_tools = ProcessUSD(log_level=self.log_level) mesh_paths = usd_tools.list_mesh_paths_under( - str(output_usd), parent_path=f"/World/{self.usd_project_name}" + str(output_usd), parent_path=f"/World/{root_prim_name}" ) if not mesh_paths: - self.log_warning( - "No mesh prims found under /World/%s", self.usd_project_name - ) + self.log_warning("No mesh prims found under /World/%s", root_prim_name) return {"usd_file": str(output_usd)} # Static merge has no time samples; pass None so only default time is used diff --git a/src/monai_physio/workflow_infer_movement.py b/src/monai_physio/workflow_infer_movement.py index abef88d4..88806c37 100644 --- a/src/monai_physio/workflow_infer_movement.py +++ b/src/monai_physio/workflow_infer_movement.py @@ -201,6 +201,10 @@ def process_time_series( usd_project_name: Optional[str] = None, anatomy_type: Optional[str] = None, separate_by_connectivity: bool = False, + exterior_mask: Optional[itk.Image] = None, + exterior_direction_offset_mm: float = 0.0, + exterior_direction_transition_mm: float = 5.0, + exterior_falloff_distance_mm: float = 20.0, ) -> dict[str, Any]: """Predict one subject across a whole time series and write its geometry. @@ -237,6 +241,23 @@ def process_time_series( anatomy_type: Anatomy whose materials color that USD. separate_by_connectivity: Whether that USD splits each frame into separate objects by connectivity. + exterior_mask: Binary or label image on ``reference_image``'s grid + marking the anatomy the surface belongs to (e.g. a lung + labelmap). When given, the deformation used to warp + ``reference_image`` is restricted outside this mask to its + component along the surface normal, fading to zero, via + :meth:`ProcessTransforms.restrict_deformation_field_to_normal_falloff_outside_mask`, + so tissue beyond the organ is pushed and pulled by it without + being dragged along tangentially. Omit for the plain isotropic + spread every stage otherwise gets. + exterior_direction_offset_mm: Passed through as ``direction_offset_mm``. + Ignored when ``exterior_mask`` is omitted. + exterior_direction_transition_mm: Passed through as + ``direction_transition_mm``. Ignored when ``exterior_mask`` is + omitted. + exterior_falloff_distance_mm: Passed through as ``falloff_distance_mm`` + -- how far outside ``exterior_mask`` the push and pull reaches. + Ignored when ``exterior_mask`` is omitted. Returns: Dict with ``stages``, ``predicted_surfaces``, ``warped_images``, @@ -300,6 +321,28 @@ def process_time_series( sigma=smoothing_sigma_mm, weight_image=field["weight_image"], ) + if exterior_mask is not None: + # The inverse field is indexed in the stage's own frame, so + # the reference-frame mask is resampled into it first + # through the unrestricted transform, exactly as the + # normal image (also on the reference grid) needs to be + # spread the same way the deformation field itself was. + stage_mask = transform_tools.transform_image( + exterior_mask, transform, reference_image + ) + stage_normals = transform_tools.smooth_deformation_field_transform( + field["normal_image"], + sigma=smoothing_sigma_mm, + weight_image=field["weight_image"], + ) + transform = transform_tools.restrict_deformation_field_to_normal_falloff_outside_mask( + transform.GetDisplacementField(), + stage_normals.GetDisplacementField(), + stage_mask, + exterior_direction_offset_mm, + exterior_direction_transition_mm, + exterior_falloff_distance_mm, + ) transforms.append(transform) warped = transform_tools.transform_image( reference_image, diff --git a/tests/test_process_transforms.py b/tests/test_process_transforms.py index edc520f6..e6c38a5c 100644 --- a/tests/test_process_transforms.py +++ b/tests/test_process_transforms.py @@ -59,7 +59,9 @@ def _as_field(array: Any) -> Any: ) -def test_smooth_deformation_field_transform_stops_sliding_outside_the_mask() -> None: +def test_restrict_deformation_field_to_normal_falloff_outside_mask_stops_sliding() -> ( + None +): """Outside the mask only motion along the surface normal is propagated. A radial field is entirely normal, so restricting it changes nothing. A @@ -68,22 +70,33 @@ def test_smooth_deformation_field_transform_stops_sliding_outside_the_mask() -> """ radius_mm, sigma_mm = 12.0, 4.0 normals, radial, tangential, weights, interior = _sphere_shell_samples(radius_mm) - normal_image = _as_field(normals) weight_image = itk.image_from_array(weights) mask_image = itk.image_from_array(interior) - tools = ProcessTransforms() + # normal_image must be dense over the same reach as field, exactly like + # field itself is: the raw per-vertex normals live only on the one-voxel + # shell, same as the raw displacement samples do. + normal_image = tools.smooth_deformation_field_transform( + _as_field(normals), sigma_mm, weight_image + ).GetDisplacementField() + def spread(samples: Any, restrict: bool) -> Any: - field = _as_field(samples) - transform = tools.smooth_deformation_field_transform( - field, - sigma_mm, - weight_image, - normal_image if restrict else None, - mask_image if restrict else None, - ) - return itk.array_from_image(transform.GetDisplacementField()) + field = tools.smooth_deformation_field_transform( + _as_field(samples), sigma_mm, weight_image + ).GetDisplacementField() + if restrict: + field = tools.restrict_deformation_field_to_normal_falloff_outside_mask( + field, + normal_image, + mask_image, + direction_offset_mm=0.0, + direction_transition_mm=0.5, + # Effectively disables the falloff, so this test isolates the + # normal/tangential split; the decay itself is covered below. + falloff_distance_mm=1.0e6, + ).GetDisplacementField() + return itk.array_from_image(field) # Well outside the shell but still within reach of the smoothing, and well # inside it. Sampling on the shell itself would straddle the mask edge. @@ -94,41 +107,64 @@ def spread(samples: Any, restrict: bool) -> Any: outside = (distance > radius_mm + 2.0) & (distance < radius_mm + 5.0) inside = distance < radius_mm - 2.0 - # Tolerances are set by the float32 the samples are rasterized in: the - # projection reconstructs a purely normal vector, and annihilates a purely - # tangential one, to about 1e-7 of the 3 mm they carry. + # A radial field already equals its own normal projection everywhere the + # (also spread) normal field is defined, so restricting it should barely + # move it; the small residual is the spread normal direction mixing in + # neighboring points of the curved surface. radial_free, radial_held = spread(radial, False), spread(radial, True) - np.testing.assert_allclose(radial_held, radial_free, atol=1e-5) + np.testing.assert_allclose(radial_held[inside], radial_free[inside], atol=1e-5) + np.testing.assert_allclose(radial_held[outside], radial_free[outside], atol=0.05) tangential_free, tangential_held = ( spread(tangential, False), spread(tangential, True), ) # The unrestricted spread really does drag the surroundings around, so the - # assertion below is not passing on an already-zero field. + # assertion below is not passing on an already-zero field. It is not + # bit-exact zero either: the spread normal field is only approximately + # perpendicular to a pure rotation once curvature mixes in neighboring + # points, unlike the exact per-sample normals a mesh vertex carries. assert np.abs(tangential_free[outside]).max() > 0.1 - assert np.abs(tangential_held[outside]).max() < 1e-4 + assert np.abs(tangential_held[outside]).max() < 0.01 np.testing.assert_allclose( tangential_held[inside], tangential_free[inside], atol=1e-5 ) -def test_smooth_deformation_field_transform_rejects_a_lone_normal_or_mask() -> None: - """The normals say what to project onto, the mask says where to.""" - normals, radial, _, weights, interior = _sphere_shell_samples() +def test_restrict_deformation_field_to_normal_falloff_outside_mask_decays_to_zero() -> ( + None +): + """The normal-only displacement outside the mask fades to zero with distance.""" + radius_mm, sigma_mm, falloff_distance_mm = 12.0, 4.0, 6.0 + normals, radial, _, weights, interior = _sphere_shell_samples(radius_mm) + weight_image = itk.image_from_array(weights) tools = ProcessTransforms() - with pytest.raises(ValueError, match="must be given together"): - tools.smooth_deformation_field_transform( - _as_field(radial), 4.0, itk.image_from_array(weights), _as_field(normals) - ) - with pytest.raises(ValueError, match="must be given together"): - tools.smooth_deformation_field_transform( - _as_field(radial), - 4.0, - itk.image_from_array(weights), - interior_mask=itk.image_from_array(interior), - ) + smoothed = tools.smooth_deformation_field_transform( + _as_field(radial), sigma_mm, weight_image + ) + normal_image = tools.smooth_deformation_field_transform( + _as_field(normals), sigma_mm, weight_image + ).GetDisplacementField() + restricted = tools.restrict_deformation_field_to_normal_falloff_outside_mask( + smoothed.GetDisplacementField(), + normal_image, + itk.image_from_array(interior), + direction_offset_mm=0.0, + direction_transition_mm=0.5, + falloff_distance_mm=falloff_distance_mm, + ) + restricted_arr = itk.array_from_image(restricted.GetDisplacementField()) + + distance = np.linalg.norm( + np.stack(np.meshgrid(*(3 * [np.arange(40.0) - 19.5]), indexing="ij"), axis=3), + axis=3, + ) + near = (distance > radius_mm + 1.0) & (distance < radius_mm + 2.0) + far = distance > radius_mm + falloff_distance_mm + 3.0 + + assert np.abs(restricted_arr[near]).max() > 0.5 + assert np.abs(restricted_arr[far]).max() < 1e-3 def test_generate_grid_image_clamps_boundary_lines() -> None: diff --git a/tests/test_workflow_convert_vtk_to_usd.py b/tests/test_workflow_convert_vtk_to_usd.py index aec2e265..657dc03f 100644 --- a/tests/test_workflow_convert_vtk_to_usd.py +++ b/tests/test_workflow_convert_vtk_to_usd.py @@ -87,6 +87,33 @@ def test_label_names_drive_prim_names_and_materials(self, tmp_path: Path) -> Non assert myocardium.endswith("OmniSurface_Myocardium") assert ventricle.endswith("OmniSurface_Ventricle_Left") + def test_hyphenated_project_name_still_gets_post_processed( + self, tmp_path: Path + ) -> None: + """usd_project_name may sanitize to a different USD identifier. + + ConvertVTKToUSD turns a "-" into "_" for the actual root prim path it + writes; the post-process step that finds mesh prims to apply + appearance to must look under that same sanitized name, not the raw + usd_project_name, or it finds nothing and silently skips appearance. + """ + mesh = _labeled_sphere((0.0, 0.0, 0.0), "highres_myocardium") + + workflow = WorkflowConvertVTKToUSD( + input_meshes=[mesh], + usd_project_name="Chest-CT_pred", + output_directory=tmp_path, + appearance="anatomy", + static_merge=True, + ) + result = workflow.process() + + stage = Usd.Stage.Open(result["usd_file"]) + material = _bound_material_path( + stage, "/World/Chest_CT_pred/highres_myocardium_object1" + ) + assert material.endswith("OmniSurface_Myocardium") + def test_explicit_anatomy_type_overrides_names(self, tmp_path: Path) -> None: """A caller-supplied anatomy_type still paints every object the same.""" meshes = [ diff --git a/tutorials/README.md b/tutorials/README.md index 05221ed4..1a65411d 100644 --- a/tutorials/README.md +++ b/tutorials/README.md @@ -25,6 +25,7 @@ current working directory. | # | Script | Primary API | Dataset | |---|--------|-------------|---------| +| 00 | [tutorial_00_lung_demo.ipynb](tutorial_00_lung_demo.ipynb) | `WorkflowFitStatisticalModelToPatient`, `WorkflowInferMovement` | Chest-CT plus pretrained PhysicsNeMo-MGN-Lung-Motion (both auto-download) | | 1 | [tutorial_01_heart_gated_ct_to_usd.py](tutorial_01_heart_gated_ct_to_usd.py) | `WorkflowConvertImageToUSD` | Slicer-Heart-CT (prepare first) | | 1 | [tutorial_01_lung_gated_ct_to_usd.py](tutorial_01_lung_gated_ct_to_usd.py) | `WorkflowConvertImageToUSD` | Lung gated 4D CT (prepare first) | | 2 | [tutorial_02_lung_finetune_icon.py](tutorial_02_lung_finetune_icon.py) | `WorkflowFinetuneICONRegistration` | TCIA-4DLung (manual) | @@ -110,6 +111,10 @@ pytest tests/test_tutorials.py::TestTutorial01HeartGatedCTToUSD --run-tutorials ## Recommended Order +**Tutorial 00** is an optional, self-contained demo notebook - it downloads +its own data and a pretrained network, then predicts lung motion end-to-end +with nothing from the numbered chain below required first. + Each numbered step has a heart variant, a lung variant, or both. Follow the variants for the anatomy you care about: every tutorial consumes the output of its own anatomy's earlier tutorials, never the other's. diff --git a/tutorials/parameters_duke_heart_labelmaps.py b/tutorials/parameters_duke_heart_labelmaps.py index 5e90fa70..51325df2 100644 --- a/tutorials/parameters_duke_heart_labelmaps.py +++ b/tutorials/parameters_duke_heart_labelmaps.py @@ -15,12 +15,19 @@ from __future__ import annotations +import logging from dataclasses import dataclass, field from pathlib import Path +from typing import cast from parameters_base import ParametersBase -from monai_physio import SegmentAnatomyBase, SegmentHeartSimplewareTrimmedBranches +from monai_physio import ( + RegisterImagesBase, + RegisterImagesGreedy, + SegmentAnatomyBase, + SegmentHeartSimplewareTrimmedBranches, +) @dataclass(frozen=True) @@ -57,11 +64,11 @@ class ParametersDukeHeartLabelmaps(ParametersBase): number_of_pca_components: PCA components retained when building the heart statistical model, and used when fitting it to a patient. number_of_pca_components_test: Same, under ``ProcessTests.running_as_test``. - number_of_iterations_greedy: Greedy coarse-to-fine iteration schedule. - number_of_iterations_greedy_test: Same, under - ``ProcessTests.running_as_test``. segmenter_class: Segmenter that produced these labelmaps, so the tutorials name their labels the way it does. + registration_class: Registration method every heart tutorial + instantiates, so the phase-to-phase transforms they produce and + compare share one definition of "registered". anatomy_group: Anatomy group name that segmenter registers for the heart. interior_object_ids: Labels left out of the whole-heart structure, and therefore never measured to by a distance map. The four chambers @@ -89,12 +96,8 @@ class ParametersDukeHeartLabelmaps(ParametersBase): number_of_pca_components: int = 10 number_of_pca_components_test: int = 5 - number_of_iterations_greedy: list[int] = field( - default_factory=lambda: [30, 15, 7, 3] - ) - number_of_iterations_greedy_test: list[int] = field(default_factory=lambda: [1, 0]) - segmenter_class: type[SegmentAnatomyBase] = SegmentHeartSimplewareTrimmedBranches + registration_class: type[RegisterImagesBase] = RegisterImagesGreedy anatomy_group: str = "heart" interior_object_ids: list[int] = field( default_factory=lambda: [1, 2, 3, 4, 7, 8, 9, 10] @@ -148,13 +151,29 @@ def pca_components(self, test_mode: bool) -> int: else self.number_of_pca_components ) - def greedy_iterations(self, test_mode: bool) -> list[int]: - """Return the Greedy iteration schedule for this run mode.""" - return list( - self.number_of_iterations_greedy_test - if test_mode - else self.number_of_iterations_greedy + def segmenter( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> SegmentAnatomyBase: + """Return the shared heart segmenter, fast mode enabled. + + Args: + test_mode: Unused today (fast mode is always on); kept for + symmetry with :meth:`registrar`. + """ + segmenter = self.segmenter_class(log_level=log_level) + segmenter.set_fast_mode(True) + return segmenter + + def registrar( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> RegisterImagesBase: + """Return the shared heart registrar, tuned for this run mode.""" + registrar = cast( + RegisterImagesGreedy, self.registration_class(log_level=log_level) ) + registrar.set_number_of_iterations([1, 0] if test_mode else [30, 15, 7, 3]) + registrar.set_metric("CC") + return registrar #: The single instance every Duke heart tutorial imports. diff --git a/tutorials/parameters_heart_ct_kcl.py b/tutorials/parameters_heart_ct_kcl.py index d8ff5650..0138f699 100644 --- a/tutorials/parameters_heart_ct_kcl.py +++ b/tutorials/parameters_heart_ct_kcl.py @@ -15,12 +15,19 @@ from __future__ import annotations +import logging from dataclasses import dataclass, field from pathlib import Path +from typing import cast from parameters_base import ParametersBase -from monai_physio import SegmentAnatomyBase, SegmentChestTotalSegmentator +from monai_physio import ( + RegisterImagesBase, + RegisterImagesGreedy, + SegmentAnatomyBase, + SegmentChestTotalSegmentatorWithContrast, +) @dataclass(frozen=True) @@ -55,11 +62,11 @@ class ParametersHeartCTKCL(ParametersBase): number_of_pca_components: PCA components retained when building the heart statistical model, and used when fitting it to a patient. number_of_pca_components_test: Same, under ``ProcessTests.running_as_test``. - number_of_iterations_greedy: Greedy coarse-to-fine iteration schedule. - number_of_iterations_greedy_test: Same, under - ``ProcessTests.running_as_test``. segmenter_class: Segmenter every heart tutorial instantiates, so the surfaces they compare share a definition of "heart". + registration_class: Registration method every heart tutorial + instantiates, so the phase-to-phase transforms they produce and + compare share one definition of "registered". anatomy_group: Anatomy group name that segmenter registers for the heart. interior_object_ids_totalsegmentator: Chamber labels in a TotalSegmentator labelmap. The chambers are interior to the @@ -97,12 +104,8 @@ class ParametersHeartCTKCL(ParametersBase): number_of_pca_components: int = 10 number_of_pca_components_test: int = 5 - number_of_iterations_greedy: list[int] = field( - default_factory=lambda: [30, 15, 7, 3] - ) - number_of_iterations_greedy_test: list[int] = field(default_factory=lambda: [1, 0]) - - segmenter_class: type[SegmentAnatomyBase] = SegmentChestTotalSegmentator + segmenter_class: type[SegmentAnatomyBase] = SegmentChestTotalSegmentatorWithContrast + registration_class: type[RegisterImagesBase] = RegisterImagesGreedy anatomy_group: str = "heart" interior_object_ids_totalsegmentator: list[int] = field( default_factory=lambda: [141, 142, 143, 144] @@ -146,13 +149,29 @@ def points_per_model(self, test_mode: bool) -> int: """Return the per-surface point budget for this run mode.""" return self.model_points_test if test_mode else self.model_points - def greedy_iterations(self, test_mode: bool) -> list[int]: - """Return the Greedy iteration schedule for this run mode.""" - return list( - self.number_of_iterations_greedy_test - if test_mode - else self.number_of_iterations_greedy + def segmenter( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> SegmentAnatomyBase: + """Return the shared heart segmenter, fast mode enabled. + + Args: + test_mode: Unused today (fast mode is always on); kept for + symmetry with :meth:`registrar`. + """ + segmenter = self.segmenter_class(log_level=log_level) + segmenter.set_fast_mode(True) + return segmenter + + def registrar( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> RegisterImagesBase: + """Return the shared heart registrar, tuned for this run mode.""" + registrar = cast( + RegisterImagesGreedy, self.registration_class(log_level=log_level) ) + registrar.set_number_of_iterations([1, 0] if test_mode else [30, 15, 7, 3]) + registrar.set_metric("CC") + return registrar #: The single instance every heart tutorial imports. diff --git a/tutorials/parameters_lung_ct_dirlab.py b/tutorials/parameters_lung_ct_dirlab.py index 2d0cfb20..9a6d21ce 100644 --- a/tutorials/parameters_lung_ct_dirlab.py +++ b/tutorials/parameters_lung_ct_dirlab.py @@ -15,12 +15,19 @@ from __future__ import annotations -from dataclasses import dataclass, field +import logging +from dataclasses import dataclass from pathlib import Path +from typing import cast from parameters_base import ParametersBase -from monai_physio import SegmentAnatomyBase, SegmentNVSegmentCTMRI +from monai_physio import ( + RegisterImagesBase, + RegisterImagesGreedy, + SegmentAnatomyBase, + SegmentChestTotalSegmentator, +) @dataclass(frozen=True) @@ -52,11 +59,11 @@ class ParametersLungCTDirLab(ParametersBase): number_of_pca_components: PCA components retained when building the lung statistical model, and used when fitting it to a patient. number_of_pca_components_test: Same, under ``ProcessTests.running_as_test``. - number_of_iterations_greedy: Greedy coarse-to-fine iteration schedule. - number_of_iterations_greedy_test: Same, under - ``ProcessTests.running_as_test``. segmenter_class: Segmenter every lung tutorial instantiates, so the surfaces they compare share a definition of "lung". + registration_class: Registration method every lung tutorial + instantiates, so the phase-to-phase transforms they produce and + compare share one definition of "registered". anatomy_group: Anatomy group name that segmenter registers for lungs. hold_out_case: Image fitted by Tutorial 7 and therefore kept out of the population Tutorial 6 builds the model from, so that the fit @@ -93,12 +100,8 @@ class ParametersLungCTDirLab(ParametersBase): number_of_pca_components: int = 6 number_of_pca_components_test: int = 5 - number_of_iterations_greedy: list[int] = field( - default_factory=lambda: [30, 15, 7, 3] - ) - number_of_iterations_greedy_test: list[int] = field(default_factory=lambda: [1, 0]) - - segmenter_class: type[SegmentAnatomyBase] = SegmentNVSegmentCTMRI + segmenter_class: type[SegmentAnatomyBase] = SegmentChestTotalSegmentator + registration_class: type[RegisterImagesBase] = RegisterImagesGreedy anatomy_group: str = "lung" hold_out_case: str = "Chest-CT.mha" @@ -146,13 +149,29 @@ def points_per_model(self, test_mode: bool) -> int: """Return the per-surface point budget for this run mode.""" return self.model_points_test if test_mode else self.model_points - def greedy_iterations(self, test_mode: bool) -> list[int]: - """Return the Greedy iteration schedule for this run mode.""" - return list( - self.number_of_iterations_greedy_test - if test_mode - else self.number_of_iterations_greedy + def segmenter( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> SegmentAnatomyBase: + """Return the shared lung segmenter, fast mode enabled. + + Args: + test_mode: Unused today (fast mode is always on); kept for + symmetry with :meth:`registrar`. + """ + segmenter = self.segmenter_class(log_level=log_level) + segmenter.set_fast_mode(True) + return segmenter + + def registrar( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> RegisterImagesBase: + """Return the shared lung registrar, tuned for this run mode.""" + registrar = cast( + RegisterImagesGreedy, self.registration_class(log_level=log_level) ) + registrar.set_number_of_iterations([1, 0] if test_mode else [30, 15, 7, 3]) + registrar.set_metric("CC") + return registrar #: The single instance every lung tutorial imports. diff --git a/tutorials/parameters_tcia_4d_lung.py b/tutorials/parameters_tcia_4d_lung.py index f8348732..c4fd5d8d 100644 --- a/tutorials/parameters_tcia_4d_lung.py +++ b/tutorials/parameters_tcia_4d_lung.py @@ -12,12 +12,19 @@ from __future__ import annotations -from dataclasses import dataclass, field +import logging +from dataclasses import dataclass from pathlib import Path +from typing import cast from parameters_base import ParametersBase -from monai_physio import SegmentAnatomyBase, SegmentChestTotalSegmentator +from monai_physio import ( + RegisterImagesBase, + RegisterImagesGreedy, + SegmentAnatomyBase, + SegmentChestTotalSegmentator, +) @dataclass(frozen=True) @@ -49,10 +56,11 @@ class ParametersTCIA4DLung(ParametersBase): number_of_pca_components: PCA components retained when building the lung statistical model, and used when fitting it to a patient. number_of_pca_components_test: Same, under ``ProcessTests.running_as_test``. - number_of_iterations_greedy_test: Greedy coarse-to-fine iteration - schedule, under ``ProcessTests.running_as_test``. segmenter_class: Segmenter every lung tutorial instantiates, so the surfaces they compare share a definition of "lung". + registration_class: Registration method every lung tutorial + instantiates, so the phase-to-phase transforms they produce and + compare share one definition of "registered". anatomy_group: Anatomy group name that segmenter registers for lungs. hold_out_case: Image Tutorial 7 fits and Tutorial 6 excludes from the population it builds the model from. Unrelated to TCIA-4DLung: it @@ -68,12 +76,6 @@ class ParametersTCIA4DLung(ParametersBase): mesh_element_size_mm: float = 3.0 number_of_iterations_icon: int = 20 - number_of_iterations_greedy: list[int] = field( - default_factory=lambda: [100, 100, 10, 5] # with CC - # default_factory=lambda: [100, 100, 200, 50] # with mean squares - ) - number_of_iterations_greedy_test: list[int] = field(default_factory=lambda: [1, 0]) - greedy_metric: str = "CC" icp_transform_type: str = "Affine" @@ -87,6 +89,7 @@ class ParametersTCIA4DLung(ParametersBase): number_of_pca_components_test: int = 5 segmenter_class: type[SegmentAnatomyBase] = SegmentChestTotalSegmentator + registration_class: type[RegisterImagesBase] = RegisterImagesGreedy anatomy_group: str = "lung" hold_out_case: str = "Chest-CT.mha" @@ -132,13 +135,29 @@ def points_per_model(self, test_mode: bool) -> int: """Return the per-surface point budget for this run mode.""" return self.model_points_test if test_mode else self.model_points - def greedy_iterations(self, test_mode: bool) -> list[int]: - """Return the Greedy iteration schedule for this run mode.""" - return list( - self.number_of_iterations_greedy_test - if test_mode - else self.number_of_iterations_greedy + def segmenter( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> SegmentAnatomyBase: + """Return the shared lung segmenter, fast mode enabled. + + Args: + test_mode: Unused today (fast mode is always on); kept for + symmetry with :meth:`registrar`. + """ + segmenter = self.segmenter_class(log_level=log_level) + segmenter.set_fast_mode(True) + return segmenter + + def registrar( + self, test_mode: bool, log_level: int | str = logging.INFO + ) -> RegisterImagesBase: + """Return the shared lung registrar, tuned for this run mode.""" + registrar = cast( + RegisterImagesGreedy, self.registration_class(log_level=log_level) ) + registrar.set_number_of_iterations([1, 0] if test_mode else [100, 100, 10, 5]) + registrar.set_metric("CC") + return registrar #: The single instance every TCIA 4D-Lung tutorial imports. diff --git a/tutorials/tutorial_00_lung_demo.ipynb b/tutorials/tutorial_00_lung_demo.ipynb new file mode 100644 index 00000000..19b1043d --- /dev/null +++ b/tutorials/tutorial_00_lung_demo.ipynb @@ -0,0 +1,707 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c10ef3d3", + "metadata": {}, + "source": [ + "# Tutorial 00 (Lung, Demo): Predict Lung Motion From a Single Chest CT\n", + "\n", + "## Purpose\n", + "\n", + "A self-contained demo of the lung motion-prediction pipeline that fetches\n", + "every input it needs, so it runs with nothing more than a clone of the\n", + "repository:\n", + "\n", + "1. Download the ``Chest-CT`` sample volume (an ungated 3-D chest CT) and the\n", + " pretrained ``physicsnemo_mgn_lung_motion`` MeshGraphNet checkpoint with\n", + " ``monai_physio.DownloadData``. The checkpoint directory also carries the\n", + " lung PCA shape model (``pca_model.json``, ``pca_mean_surface.vtp``) that\n", + " network was trained against, so no separate Tutorial 6 run is needed.\n", + "2. Segment the lungs with ``SegmentChestTotalSegmentator`` and extract their\n", + " surface.\n", + "3. Fit that PCA shape model to the surface with\n", + " ``WorkflowFitStatisticalModelToPatient``, giving this patient's PCA\n", + " coefficients and fitted SSM surface.\n", + "4. Predict lung motion across a demo respiratory-stage grid with the\n", + " pretrained MeshGraphNet, carry the CT through each stage's deformation,\n", + " and write the series as VTP surfaces and one animated USD --\n", + " ``WorkflowInferMovement.process_time_series``.\n", + "\n", + "``Chest-CT`` is a single, ungated volume -- unlike ``TCIA-4DLung``'s gated\n", + "sequences, it has no ``g{PPP}`` respiratory phases to parse a stage grid\n", + "from. This demo instead predicts motion across an illustrative grid of\n", + "normalized stages, so the same pretrained network that predicts a real\n", + "respiratory cycle in ``tutorial_12_lung_end_to_end_inference.py`` can be\n", + "shown working on any chest CT.\n", + "\n", + "## Data Required\n", + "\n", + "Nothing -- the ``Chest-CT`` volume, the pretrained MeshGraphNet weights and\n", + "the PCA shape model they were trained against are all downloaded by this\n", + "notebook.\n", + "\n", + "## Outputs (under ``output/tutorial_00_lung_demo/``)\n", + "\n", + " * ``Chest-CT_lung_surface.vtp``, ``Chest-CT_lung_labelmap.nii.gz`` -- segmentation\n", + " * ``Chest-CT_surface.json`` -- this patient's shape parameters\n", + " * ``Chest-CT_ssm_surface.vtp`` -- the model fitted to the patient\n", + " * ``Chest-CT_surface_s{TTT}_pred.vtp`` -- predicted surface per stage\n", + " * ``Chest-CT_s{TTT}_pred.mha`` -- CT carried to that stage\n", + " * ``Chest-CT_pred.usd`` -- animated predicted motion" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4847edf4", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "import json\n", + "import logging\n", + "from typing import cast\n", + "\n", + "import itk\n", + "import numpy as np\n", + "import pyvista as pv\n", + "from parameters_tcia_4d_lung import TCIA_4D_LUNG\n", + "\n", + "from monai_physio import (\n", + " DownloadData,\n", + " ProcessContours,\n", + " SegmentChestTotalSegmentator,\n", + " WorkflowConvertImageToVTK,\n", + " WorkflowFitStatisticalModelToPatient,\n", + " WorkflowInferMovement,\n", + " WorkflowInferPhysicsNeMo,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5a3aaafb", + "metadata": {}, + "outputs": [], + "source": [ + "# Data directory specification\n", + "test_mode = False\n", + "\n", + "case_id = \"Chest-CT\"\n", + "\n", + "data_dir = TCIA_4D_LUNG.hold_out_directory(test_mode)\n", + "weights_dir = TCIA_4D_LUNG.weights_directory(test_mode)\n", + "output_dir = TCIA_4D_LUNG.output_directory(test_mode) / \"tutorial_00_lung_demo\"\n", + "\n", + "# Weights Tutorial 9 trains; this demo downloads a pretrained copy instead.\n", + "# The PCA model and mean surface it was trained against ship in the same\n", + "# checkpoint directory.\n", + "model_dir = TCIA_4D_LUNG.mgn_weights_directory(test_mode)\n", + "epoch = None # None uses the final weights\n", + "pca_model_file = model_dir / \"pca_model.json\"\n", + "pca_mean_file = model_dir / \"pca_mean_surface.vtp\"\n", + "\n", + "number_of_pca_components = TCIA_4D_LUNG.pca_components(test_mode)\n", + "\n", + "# time points to reconstruct\n", + "stages = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "\n", + "# Gaussian sigma, in mm, that spreads the predicted surface displacements\n", + "# into the continuous field the CT is resampled through.\n", + "smoothing_sigma_mm = 10.0\n", + "\n", + "log_level = logging.INFO\n", + "logging.basicConfig(level=log_level)\n", + "logger = logging.getLogger(\"tutorial_00_lung_demo\")\n", + "\n", + "output_dir.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "id": "c9bec602", + "metadata": {}, + "source": [ + "## Step 1: Download the Chest-CT volume and the pretrained MeshGraphNet weights" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6b7f9be3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tutorial_00_lung_demo:Loaded C:\\src\\Projects\\MONAI-Physio\\monai-physio\\data\\Chest-CT\\Chest-CT.mha\n" + ] + } + ], + "source": [ + "patient_image_file = DownloadData.DownloadChestCTData(data_dir)\n", + "DownloadData.DownloadPhysicsNeMoMGNLungMotionData(weights_dir)\n", + "\n", + "if not (model_dir / \"mgn_stage_model.pt\").exists():\n", + " raise FileNotFoundError(\n", + " f\"Pretrained MeshGraphNet checkpoint not found: {model_dir}\"\n", + " )\n", + "if not (pca_model_file.exists() and pca_mean_file.exists()):\n", + " raise FileNotFoundError(\n", + " f\"PCA shape model not found alongside checkpoint: {model_dir}\"\n", + " )\n", + "\n", + "pca_mean_surface = cast(pv.DataSet, pv.read(str(pca_mean_file)))\n", + "with pca_model_file.open(encoding=\"utf-8\") as f:\n", + " pca_model = json.load(f)\n", + "\n", + "patient_image = itk.imread(str(patient_image_file))\n", + "logger.info(\"Loaded %s\", patient_image_file)" + ] + }, + { + "cell_type": "markdown", + "id": "dacbb80f", + "metadata": {}, + "source": [ + "## Step 2: Segment the lungs with TotalSegmentator" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "14953c63", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK STARTING IMAGE TO VTK WORKFLOW\n", + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK Running segmenter: SegmentChestTotalSegmentator\n", + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK Running segmentation\n", + "2026-09-20 14:06:13 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:06:13 WARNING SegmentChestTotalSegmentator The input image should have isotropic spacing\n", + "2026-09-20 14:06:13 INFO SegmentChestTotalSegmentator Input image has spacing: itkVectorD3 ([0.814453, 0.814453, 2])\n", + "2026-09-20 14:06:13 INFO SegmentChestTotalSegmentator Resampling to isotropic: 1.000\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "If you use this tool please cite: https://pubs.rsna.org/doi/10.1148/ryai.230024\n", + "\n", + "Using 'fast' option: resampling to lower resolution (3mm)\n", + "Resampling...\n", + " Resampled in 1.52s\n", + "Predicting...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`torch.jit.interface` is deprecated. Please use `torch.compile` instead.\n", + "100%|██████████| 4/4 [00:00<00:00, 4.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Predicted in 11.09s\n", + "Resampling...\n", + " Resampled in 2.14s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-20 14:06:36 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:06:36 INFO WorkflowConvertImageToVTK Extracting VTK objects\n", + "2026-09-20 14:06:36 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:06:36 INFO WorkflowConvertImageToVTK Processing anatomy group: lung\n", + "2026-09-20 14:06:36 INFO WorkflowConvertImageToVTK Extracting surface for: lung\n", + "2026-09-20 14:06:36 INFO ProcessContours Contouring on a 0.814 mm isotropic grid rather than the labelmap's 0.814 x 0.814 x 2 mm one\n", + "2026-09-20 14:06:50 INFO WorkflowConvertImageToVTK Extracting label surfaces for: lung\n", + "2026-09-20 14:06:50 INFO ProcessContours Contouring on a 0.814 mm isotropic grid rather than the labelmap's 0.814 x 0.814 x 2 mm one\n", + "2026-09-20 14:07:02 INFO ProcessContours Contouring on a 0.814 mm isotropic grid rather than the labelmap's 0.814 x 0.814 x 2 mm one\n", + "2026-09-20 14:07:14 INFO ProcessContours Contouring on a 0.814 mm isotropic grid rather than the labelmap's 0.814 x 0.814 x 2 mm one\n", + "2026-09-20 14:07:26 INFO ProcessContours Contouring on a 0.814 mm isotropic grid rather than the labelmap's 0.814 x 0.814 x 2 mm one\n", + "2026-09-20 14:07:37 INFO ProcessContours Contouring on a 0.814 mm isotropic grid rather than the labelmap's 0.814 x 0.814 x 2 mm one\n", + "2026-09-20 14:07:49 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:07:49 INFO WorkflowConvertImageToVTK IMAGE TO VTK WORKFLOW COMPLETE\n", + "2026-09-20 14:07:49 INFO WorkflowConvertImageToVTK ======================================================================\n", + "2026-09-20 14:07:49 INFO WorkflowConvertImageToVTK Surfaces extracted: 1\n", + "2026-09-20 14:07:49 INFO WorkflowConvertImageToVTK Label surfaces extracted: 5\n", + "INFO:tutorial_00_lung_demo:Segmented lungs in Chest-CT.mha\n" + ] + } + ], + "source": [ + "lung_surface_file = output_dir / f\"{case_id}_lung_surface.vtp\"\n", + "lung_labelmap_file = output_dir / f\"{case_id}_lung_labelmap.nii.gz\"\n", + "\n", + "contour_tools = ProcessContours(log_level=log_level)\n", + "segmentation_method = SegmentChestTotalSegmentator(log_level=log_level)\n", + "segmentation_method.fast_mode = True\n", + "segmentation_result = WorkflowConvertImageToVTK(\n", + " segmentation_method=segmentation_method,\n", + " log_level=log_level,\n", + ").process(\n", + " input_image=patient_image,\n", + " anatomy_groups=[TCIA_4D_LUNG.anatomy_group],\n", + " surface_reduction_rate=TCIA_4D_LUNG.surface_reduction_rate,\n", + " extract_label_surfaces=True,\n", + ")\n", + "contour_tools.save_combined_surfaces(\n", + " segmentation_result[\"label_surfaces\"], str(lung_surface_file)\n", + ")\n", + "# anatomy_groups only selects which structures are contoured into\n", + "# label_surfaces above; the labelmap itself is the segmenter's full,\n", + "# unfiltered whole-body output (ribs, spine, heart, etc. included).\n", + "lung_labelmap = segmentation_result[\"labelmap\"]\n", + "itk.imwrite(lung_labelmap, str(lung_labelmap_file), compression=True)\n", + "# Read back rather than combining in memory: save_combined_surfaces is what\n", + "# merges the per-label surfaces into the one surface the fit is given.\n", + "lung_surface = cast(pv.PolyData, pv.read(str(lung_surface_file)))\n", + "logger.info(\"Segmented lungs in %s\", patient_image_file.name)\n", + "\n", + "# Isolate just the lung labels into a binary mask, the same way\n", + "# tutorial_13_heart_and_lung_motion.py's binary_mask_on_grid does: this (not\n", + "# the whole-body lung_labelmap above) is what exterior_mask must be, or\n", + "# nearly every voxel in the torso reads as \"interior\" and gets the full,\n", + "# unrestricted deformation instead of only the lung's push and pull.\n", + "lung_label_ids = list(segmentation_method.taxonomy.labels_in_group(\"lung\"))\n", + "lung_only_mask_arr = np.isin(\n", + " itk.array_from_image(lung_labelmap), lung_label_ids\n", + ").astype(np.uint8)\n", + "lung_only_mask = itk.image_from_array(lung_only_mask_arr)\n", + "lung_only_mask.CopyInformation(lung_labelmap)" + ] + }, + { + "cell_type": "markdown", + "id": "5eea2d7f", + "metadata": {}, + "source": [ + "## Step 3: Fit the lung shape model to the patient\n", + "\n", + "The PCA coefficients are what the network is conditioned on; the fitted\n", + "surface is what its displacements are added to." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5831ca69", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-20 14:07:50 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:07:50 INFO WorkflowFitStatisticalModelToPatient STARTING COMPLETE MODEL REGISTRATION WORKFLOW\n", + "2026-09-20 14:07:50 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:07:50 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:07:50 INFO WorkflowFitStatisticalModelToPatient Stage 1: ICP Alignment (RegisterModelsICP)\n", + "2026-09-20 14:07:50 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:07:50 INFO RegisterModelsICP ======================================================================\n", + "2026-09-20 14:07:50 INFO RegisterModelsICP AFFINE ICP Alignment\n", + "2026-09-20 14:07:50 INFO RegisterModelsICP ======================================================================\n", + "2026-09-20 14:07:50 INFO RegisterModelsICP Translating by [-132.56650341 -135.38410365 -9.24775311] to align centroids...\n", + "2026-09-20 14:07:52 INFO RegisterModelsICP Scaling by 0.9902 about the fixed centroid to match bounding boxes...\n", + "2026-09-20 14:07:53 INFO RegisterModelsICP Performing similarity ICP (max iterations: 2000)...\n", + "2026-09-20 14:08:07 INFO RegisterModelsICP Performing affine ICP (max iterations: 2000)...\n", + "2026-09-20 14:08:18 INFO RegisterModelsICP AFFINE ICP registration complete!\n", + "2026-09-20 14:08:20 INFO WorkflowFitStatisticalModelToPatient Stage 1 complete: ICP alignment finished.\n", + "2026-09-20 14:08:20 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:08:20 INFO WorkflowFitStatisticalModelToPatient Stage 2: PCA-Based Registration (RegisterModelsPCA)\n", + "2026-09-20 14:08:20 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:08:20 WARNING RegisterModelsPCA A distance map was provided, so the reference image is ignored; the fixed model is retained only for the symmetric metric term.\n", + "2026-09-20 14:08:20 INFO RegisterModelsPCA ======================================================================\n", + "2026-09-20 14:08:20 INFO RegisterModelsPCA PCA-BASED MODEL-TO-MODEL REGISTRATION\n", + "2026-09-20 14:08:20 INFO RegisterModelsPCA ======================================================================\n", + "2026-09-20 14:08:20 INFO RegisterModelsPCA Number of points: 282782\n", + "2026-09-20 14:08:20 INFO RegisterModelsPCA Modes to use: 6\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Number of PCA modes: 6\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA PCA coefficient bounds: ±3.5 std deviations\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Optimization method: L-BFGS-B\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Max iterations: 100\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Shape prior weight: 0.0\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Symmetric weight: 0.5\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Running optimization...\n", + "2026-09-20 14:08:21 INFO RegisterModelsPCA Metric 1: 2.1744 mm (model->target 0.0778, target->model 4.2709, prior 0.0000, outside 0)\n", + "2026-09-20 14:08:23 INFO RegisterModelsPCA Optimization completed!\n", + "2026-09-20 14:08:23 INFO RegisterModelsPCA Optimized PCA coefficients: [-1.01157236 0.25616213 -0.3048195 -0.6271181 -0.15026667 -0.2286214 ]\n", + "2026-09-20 14:08:23 INFO RegisterModelsPCA Metric evaluations: 16\n", + "2026-09-20 14:08:23 INFO RegisterModelsPCA Final mean distance: 1.8094 mm\n", + "2026-09-20 14:08:23 INFO RegisterModelsPCA Creating final registered model...\n", + "2026-09-20 14:08:23 INFO RegisterModelsPCA Registered model created with 282782 points\n", + "2026-09-20 14:08:50 INFO RegisterModelsPCA Deformation field RMS error: 0.0985 mm (approximation of the per-point deformation)\n", + "2026-09-20 14:08:50 INFO RegisterModelsPCA Forward/inverse round-trip RMS error: 1.5806 mm\n", + "2026-09-20 14:08:50 INFO WorkflowFitStatisticalModelToPatient Stage 2 complete: PCA registration finished.\n", + "2026-09-20 14:08:50 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:08:50 INFO WorkflowFitStatisticalModelToPatient Stage 3: Labelmap-to-Labelmap Deformable Registration\n", + "2026-09-20 14:08:50 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:08:50 INFO ProcessImages Padding by [62, 62, 62] voxels per side; size [512, 512, 418] -> [636, 636, 542]\n", + "2026-09-20 14:08:50 INFO RegisterModelsDistanceMaps ======================================================================\n", + "2026-09-20 14:08:50 INFO RegisterModelsDistanceMaps DEFORMABLE Distance-Map-based Registration\n", + "2026-09-20 14:08:50 INFO RegisterModelsDistanceMaps ======================================================================\n", + "2026-09-20 14:08:50 INFO RegisterModelsDistanceMaps Generating distance maps and registration masks from models...\n", + "2026-09-20 14:08:50 INFO ProcessContours Computing signed distance map...\n", + "2026-09-20 14:08:52 INFO ProcessContours Distance map: 9855431/9855431 surface samples within reference image\n", + "2026-09-20 14:08:54 INFO RegisterModelsDistanceMaps Dilating fixed mask by 20.0mm for registration mask...\n", + "`n_faces_strict` is deprecated. Use `n_faces` instead, which now returns the number of polygonal faces.\n", + "`n_faces_strict` is deprecated. Use `n_faces` instead, which now returns the number of polygonal faces.\n", + "`n_faces_strict` is deprecated. Use `n_faces` instead, which now returns the number of polygonal faces.\n", + "2026-09-20 14:09:28 INFO ProcessContours Computing signed distance map...\n", + "2026-09-20 14:09:29 INFO ProcessContours Distance map: 7136144/7136144 surface samples within reference image\n", + "2026-09-20 14:09:32 INFO RegisterModelsDistanceMaps Dilating moving mask by 20.0mm for registration mask...\n", + "2026-09-20 14:09:56 INFO RegisterModelsDistanceMaps Distance map and mask generation complete\n", + "2026-09-20 14:09:56 INFO RegisterModelsDistanceMaps Performing Greedy Affine registration...\n", + "2026-09-20 14:10:02 INFO RegisterImagesGreedy Greedy labelmap metric: downsampling 219236832-voxel fixed grid by 0.743/axis to stay under the 90000000-voxel picsl_greedy crash threshold.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial optimizer parameters -0.382393 119.257 -0.0819714 -0.232237 0.0774079 0.134809 119.234 -0.162708 0.280448 -0.0612102 0.328657 100.923\n", + "Initial optimizer parameters 3.21966 238.522 1.60357 6.12603 0.225662 -4.27735 234.453 0.47884 -1.43414 -11.1174 3.00694 196.594\n", + "Initial optimizer parameters 2.5075 475.011 2.90369 9.54114 0.518151 -8.1374 469.417 1.76692 -1.60669 -18.2456 7.30883 392.883\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-20 14:11:29 INFO RegisterImagesGreedy Greedy affine/rigid registration loss: -6020.821464534253\n", + "2026-09-20 14:11:29 INFO RegisterModelsDistanceMaps Performing ICON deformable registration...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ICONLoss(all_loss=tensor(0.1363, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0244, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0996, device='cuda:0', grad_fn=), transform_magnitude=tensor(0.0001, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1136, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0103, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0981, device='cuda:0', grad_fn=), transform_magnitude=tensor(2.9999e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1093, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0076, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0979, device='cuda:0', grad_fn=), transform_magnitude=tensor(2.0893e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1076, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0066, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0978, device='cuda:0', grad_fn=), transform_magnitude=tensor(2.1454e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1072, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0066, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0973, device='cuda:0', grad_fn=), transform_magnitude=tensor(2.2777e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1061, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0060, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0970, device='cuda:0', grad_fn=), transform_magnitude=tensor(2.0147e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1051, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0055, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0969, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.8669e-05, device='cuda:0', grad_fn=), flips=tensor(1., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1040, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0047, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0969, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.8587e-05, device='cuda:0', grad_fn=), flips=tensor(2., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1032, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0043, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0968, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.9425e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1027, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0040, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0967, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.8686e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1023, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0038, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0967, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.6280e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1018, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0035, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0966, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.4484e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1015, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0033, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0965, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.4492e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1012, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0033, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0963, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.4885e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1010, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0032, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0962, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.4698e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1007, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0031, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0961, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.3648e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1005, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0030, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0960, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.2727e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.1002, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0029, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0959, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.2229e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0999, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0027, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0958, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.2055e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0996, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0025, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0958, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1909e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0993, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0024, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0957, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1721e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0992, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0024, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0956, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1476e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0990, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0023, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0956, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1217e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0989, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0023, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0955, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0974e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0988, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0022, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0954, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0874e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0986, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0021, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0954, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0882e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0985, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0021, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0954, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1027e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0983, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0020, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0953, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1160e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0982, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0020, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0953, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1193e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0981, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0019, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0953, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.1128e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0980, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0019, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0952, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0988e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0979, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0018, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0952, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0778e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0979, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0018, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0952, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0594e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0978, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0018, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0951, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0431e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0977, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0017, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0951, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0343e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0976, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0017, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0951, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0247e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0976, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0017, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0951, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0143e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0975, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0016, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0951, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0029e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0974, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0016, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0950, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.9316e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0974, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0016, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0950, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.9126e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0973, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0015, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0950, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.9231e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0973, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0015, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0950, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0051e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0972, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0015, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(1.0006e-05, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0971, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0015, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.8432e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0971, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0015, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.8831e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0971, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0014, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.8627e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0970, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0014, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.8586e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0970, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0014, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.8646e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0969, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0014, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.8736e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n", + "ICONLoss(all_loss=tensor(0.0969, device='cuda:0', grad_fn=), inverse_consistency_loss=tensor(0.0014, device='cuda:0', grad_fn=), similarity_loss=tensor(0.0949, device='cuda:0', grad_fn=), transform_magnitude=tensor(9.7930e-06, device='cuda:0', grad_fn=), flips=tensor(0., device='cuda:0'))\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-20 14:12:03 INFO RegisterModelsDistanceMaps Transforming moving model...\n", + "2026-09-20 14:12:05 INFO RegisterModelsDistanceMaps DEFORMABLE distance-map-based registration complete.\n", + "2026-09-20 14:12:05 INFO WorkflowFitStatisticalModelToPatient Stage 3 complete: Labelmap-to-labelmap registration finished.\n", + "2026-09-20 14:12:05 INFO WorkflowFitStatisticalModelToPatient Applying transforms to model...\n", + "2026-09-20 14:12:05 INFO WorkflowFitStatisticalModelToPatient Applying PCA: 1/3 (33.3%)\n", + "2026-09-20 14:12:07 INFO WorkflowFitStatisticalModelToPatient Applying PCA post-transform: 2/3 (66.7%)\n", + "2026-09-20 14:12:09 INFO WorkflowFitStatisticalModelToPatient Applying Labelmap-to-labelmap: 3/3 (100.0%)\n", + "2026-09-20 14:12:10 INFO WorkflowFitStatisticalModelToPatient Transform application complete.\n", + "2026-09-20 14:12:10 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:12:10 INFO WorkflowFitStatisticalModelToPatient REGISTRATION WORKFLOW COMPLETE\n", + "2026-09-20 14:12:10 INFO WorkflowFitStatisticalModelToPatient ======================================================================\n", + "2026-09-20 14:12:10 INFO WorkflowFitStatisticalModelToPatient Final registered patient model surface: 282782 points.\n", + "INFO:tutorial_00_lung_demo:Fitted the lung model to Chest-CT.mha\n" + ] + } + ], + "source": [ + "fit_workflow = WorkflowFitStatisticalModelToPatient(\n", + " template_model=pca_mean_surface,\n", + " patient_models=[lung_surface],\n", + " patient_image=patient_image,\n", + " patient_labelmap=lung_labelmap,\n", + " log_level=log_level,\n", + ")\n", + "fit_workflow.set_use_pca_registration(\n", + " use_pca_registration=True,\n", + " pca_model=pca_model,\n", + " number_of_pca_components=number_of_pca_components,\n", + " use_surface=False,\n", + ")\n", + "fit_workflow.set_icp_transform_type(TCIA_4D_LUNG.icp_transform_type)\n", + "fit_workflow.set_mask_dilation_mm(TCIA_4D_LUNG.mask_dilation_mm)\n", + "fit_workflow.set_distancemap_squared_max(TCIA_4D_LUNG.distancemap_squared_max)\n", + "fit_result = fit_workflow.process()\n", + "\n", + "pca_coefficients = fit_workflow.pca_coefficients\n", + "assert pca_coefficients is not None\n", + "# WorkflowInferMovement.process_time_series names every predicted surface\n", + "# after this file's stem, so naming it \"{case_id}_surface\" is what gives the\n", + "# predicted surfaces their \"{case_id}_surface_s{TTT}_pred.vtp\" names below.\n", + "pca_coefficients_file = output_dir / f\"{case_id}_surface.json\"\n", + "with pca_coefficients_file.open(mode=\"w\", encoding=\"utf-8\") as f:\n", + " json.dump(pca_coefficients.tolist(), f)\n", + "\n", + "# The lung PCA model is built from surfaces only, so the model *is* a\n", + "# surface here: only the .vtp is written.\n", + "fitted_reference_mesh_file = output_dir / f\"{case_id}_ssm_surface.vtp\"\n", + "fit_result[\"fitted_reference_mesh\"].save(str(fitted_reference_mesh_file))\n", + "logger.info(\"Fitted the lung model to %s\", patient_image_file.name)" + ] + }, + { + "cell_type": "markdown", + "id": "d312720c", + "metadata": {}, + "source": [ + "## Step 4: Predict lung motion with the pretrained MeshGraphNet\n", + "\n", + "Predict every demo stage, warp the reference CT through each stage's\n", + "deformation, and write the animated USD. -1000 HU is air, the value a CT\n", + "grid samples outside itself. `exterior_mask=lung_labelmap` restricts the warp\n", + "outside the lungs to the surface-normal component, fading to zero by\n", + "`exterior_falloff_distance_mm`, so the chest wall and mediastinum are pushed\n", + "and pulled by the breathing lung rather than dragged along with it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f0890ce", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-20 14:29:23 INFO WorkflowInferPhysicsNeMo Loading MGN model from C:\\src\\Projects\\MONAI-Physio\\monai-physio\\tutorials\\network_weights\\physicsnemo_mgn_lung_motion\\mgn_stage_model.pt\n", + "2026-09-20 14:29:23 INFO WorkflowInferMovement ======================================================================\n", + "2026-09-20 14:29:23 INFO WorkflowInferMovement INFER MOVEMENT TIME SERIES [Chest-CT_surface]\n", + "2026-09-20 14:29:23 INFO WorkflowInferMovement ======================================================================\n", + "2026-09-20 14:29:27 INFO WorkflowInferMovement Deformation field: 177434/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:29:45 INFO WorkflowInferMovement stage 0.000 -> Chest-CT_surface_s000_pred.vtp\n", + "2026-09-20 14:29:49 INFO WorkflowInferMovement Deformation field: 176256/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:30:07 INFO WorkflowInferMovement stage 0.100 -> Chest-CT_surface_s010_pred.vtp\n", + "2026-09-20 14:30:10 INFO WorkflowInferMovement Deformation field: 175092/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:30:29 INFO WorkflowInferMovement stage 0.200 -> Chest-CT_surface_s020_pred.vtp\n", + "2026-09-20 14:30:32 INFO WorkflowInferMovement Deformation field: 173981/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:30:51 INFO WorkflowInferMovement stage 0.300 -> Chest-CT_surface_s030_pred.vtp\n", + "2026-09-20 14:30:54 INFO WorkflowInferMovement Deformation field: 173581/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:31:13 INFO WorkflowInferMovement stage 0.400 -> Chest-CT_surface_s040_pred.vtp\n", + "2026-09-20 14:31:16 INFO WorkflowInferMovement Deformation field: 173870/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:31:34 INFO WorkflowInferMovement stage 0.500 -> Chest-CT_surface_s050_pred.vtp\n", + "2026-09-20 14:31:37 INFO WorkflowInferMovement Deformation field: 174913/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:31:55 INFO WorkflowInferMovement stage 0.600 -> Chest-CT_surface_s060_pred.vtp\n", + "2026-09-20 14:31:58 INFO WorkflowInferMovement Deformation field: 175999/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:32:15 INFO WorkflowInferMovement stage 0.700 -> Chest-CT_surface_s070_pred.vtp\n", + "2026-09-20 14:32:19 INFO WorkflowInferMovement Deformation field: 177271/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:32:36 INFO WorkflowInferMovement stage 0.800 -> Chest-CT_surface_s080_pred.vtp\n", + "2026-09-20 14:32:40 INFO WorkflowInferMovement Deformation field: 177870/44564480 voxels populated by 282782 vertices\n", + "2026-09-20 14:32:58 INFO WorkflowInferMovement stage 0.900 -> Chest-CT_surface_s090_pred.vtp\n", + "2026-09-20 14:32:58 INFO WorkflowConvertVTKToUSD ======================================================================\n", + "2026-09-20 14:32:58 INFO WorkflowConvertVTKToUSD VTK to USD conversion workflow\n", + "2026-09-20 14:32:58 INFO WorkflowConvertVTKToUSD ======================================================================\n", + "2026-09-20 14:32:58 INFO WorkflowConvertVTKToUSD Input: 10 mesh(es)\n", + "2026-09-20 14:32:58 INFO WorkflowConvertVTKToUSD Output: C:\\src\\Projects\\MONAI-Physio\\monai-physio\\tutorials\\output\\tutorial_00_lung_demo\\Chest-CT_pred.usd\n", + "2026-09-20 14:32:58 INFO WorkflowConvertVTKToUSD Splitting on the per-cell label array: lung_upper_lobe_left, label_29, label_30, label_31, label_32\n", + "2026-09-20 14:32:58 INFO Initialized converter with 10 time steps, mask_ids=enabled, separate_by='connectivity'\n", + "2026-09-20 14:32:58 INFO Converting 10 meshes to C:\\src\\Projects\\MONAI-Physio\\monai-physio\\tutorials\\output\\tutorial_00_lung_demo\\Chest-CT_pred.usd\n", + "INFO:monai_physio.vtk_to_usd.material_manager:Creating material: Anatomy/label_29_material\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating time-varying mesh at: /World/Chest_CT_pred/Anatomy/label_29 with 10 time steps\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating USD mesh at: /World/Chest_CT_pred/Anatomy/label_29\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created mesh with 61627 points, 123256 faces\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created time-varying mesh with 10 time samples\n", + "INFO:monai_physio.vtk_to_usd.material_manager:Creating material: Anatomy/label_30_material\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating time-varying mesh at: /World/Chest_CT_pred/Anatomy/label_30 with 10 time steps\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating USD mesh at: /World/Chest_CT_pred/Anatomy/label_30\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created mesh with 59014 points, 118028 faces\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created time-varying mesh with 10 time samples\n", + "INFO:monai_physio.vtk_to_usd.material_manager:Creating material: Anatomy/label_31_material\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating time-varying mesh at: /World/Chest_CT_pred/Anatomy/label_31 with 10 time steps\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating USD mesh at: /World/Chest_CT_pred/Anatomy/label_31\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created mesh with 32577 points, 65152 faces\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created time-varying mesh with 10 time samples\n", + "INFO:monai_physio.vtk_to_usd.material_manager:Creating material: Anatomy/label_32_material\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating time-varying mesh at: /World/Chest_CT_pred/Anatomy/label_32 with 10 time steps\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating USD mesh at: /World/Chest_CT_pred/Anatomy/label_32\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created mesh with 65481 points, 130960 faces\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created time-varying mesh with 10 time samples\n", + "INFO:monai_physio.vtk_to_usd.material_manager:Creating material: Anatomy/lung_upper_lobe_left_material\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating time-varying mesh at: /World/Chest_CT_pred/Anatomy/lung_upper_lobe_left with 10 time steps\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Creating USD mesh at: /World/Chest_CT_pred/Anatomy/lung_upper_lobe_left\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created mesh with 64083 points, 128164 faces\n", + "INFO:monai_physio.vtk_to_usd.usd_mesh_converter:Created time-varying mesh with 10 time samples\n", + "2026-09-20 14:33:03 INFO Saved USD file: C:\\src\\Projects\\MONAI-Physio\\monai-physio\\tutorials\\output\\tutorial_00_lung_demo\\Chest-CT_pred.usd\n", + "2026-09-20 14:33:03 INFO WorkflowConvertVTKToUSD Applying appearance 'anatomy' to 5 mesh(es)\n", + "2026-09-20 14:33:03 INFO WorkflowConvertVTKToUSD Workflow complete: C:\\src\\Projects\\MONAI-Physio\\monai-physio\\tutorials\\output\\tutorial_00_lung_demo\\Chest-CT_pred.usd\n", + "INFO:tutorial_00_lung_demo:USD: C:\\src\\Projects\\MONAI-Physio\\monai-physio\\tutorials\\output\\tutorial_00_lung_demo\\Chest-CT_pred.usd\n" + ] + } + ], + "source": [ + "infer_workflow = WorkflowInferPhysicsNeMo(\n", + " model_directory=model_dir, epoch=epoch, log_level=log_level\n", + ")\n", + "infer_result = WorkflowInferMovement(\n", + " infer_workflow, log_level=log_level\n", + ").process_time_series(\n", + " shape_parameters=pca_coefficients_file,\n", + " stages=stages,\n", + " output_directory=output_dir,\n", + " fitted_reference_mesh=fitted_reference_mesh_file,\n", + " reference_image=patient_image,\n", + " warp_interpolation=\"linear\",\n", + " warp_background_value=-1000.0,\n", + " smoothing_sigma_mm=smoothing_sigma_mm,\n", + " usd_project_name=f\"{case_id}_pred\",\n", + " anatomy_type=\"lung\",\n", + " separate_by_connectivity=True,\n", + " exterior_mask=lung_only_mask,\n", + " exterior_falloff_distance_mm=10.0,\n", + ")\n", + "\n", + "# process_time_series names the warped CT \"{stem}_s{TTT}_warped.mha\"; rename\n", + "# each to this notebook's \"{case_id}_s{TTT}_pred.mha\" convention.\n", + "warped_images = []\n", + "for stage, warped_file in zip(stages, infer_result[\"warped_images\"]):\n", + " tag = f\"s{int(stage * 100):03d}\"\n", + " renamed_file = output_dir / f\"{case_id}_{tag}_pred.mha\"\n", + " warped_file.replace(renamed_file)\n", + " warped_images.append(renamed_file)\n", + "infer_result[\"warped_images\"] = warped_images\n", + "\n", + "logger.info(\"USD: %s\", infer_result[\"usd_file\"])" + ] + }, + { + "cell_type": "markdown", + "id": "bbe04426", + "metadata": {}, + "source": [ + "## Step 5: Look at the fitted and predicted surfaces" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7163bb0a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pv.set_jupyter_backend(\"static\")\n", + "\n", + "plotter = pv.Plotter(shape=(1, 2), window_size=[1000, 500])\n", + "plotter.subplot(0, 0)\n", + "plotter.add_mesh(\n", + " cast(pv.DataSet, pv.read(str(fitted_reference_mesh_file))),\n", + " color=\"steelblue\",\n", + ")\n", + "plotter.add_text(\"Fitted reference surface\", font_size=10)\n", + "plotter.camera_position = \"iso\"\n", + "\n", + "plotter.subplot(0, 1)\n", + "plotter.add_mesh(\n", + " cast(pv.DataSet, pv.read(str(infer_result[\"predicted_surfaces\"][0]))),\n", + " color=\"limegreen\",\n", + ")\n", + "plotter.add_text(f\"Predicted surface, stage {stages[0]}\", font_size=10)\n", + "plotter.camera_position = \"iso\"\n", + "\n", + "plotter.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eff0425a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/tutorial_01_heart_gated_ct_to_usd.py b/tutorials/tutorial_01_heart_gated_ct_to_usd.py index d3026f25..58d2d959 100644 --- a/tutorials/tutorial_01_heart_gated_ct_to_usd.py +++ b/tutorials/tutorial_01_heart_gated_ct_to_usd.py @@ -75,8 +75,6 @@ from monai_physio import ( ProcessTests, - RegisterImagesGreedy, - SegmentChestTotalSegmentatorWithContrast, WorkflowConvertImageToUSD, ) @@ -98,20 +96,15 @@ if test_mode: data_dir = HEART_CT_KCL.data_directory(test_mode) / "slicer_heart_small" - number_of_iterations_greedy = [1, 0] frame_files = sorted(data_dir.glob("slice_???.mha"))[0:2] else: data_dir = HEART_CT_KCL.data_directory(test_mode) / "Slicer-Heart-CT" - number_of_iterations_greedy = [30, 15, 7, 3] frame_files = sorted(data_dir.glob("slice_???.mha")) log_level = logging.INFO - registration_method = RegisterImagesGreedy(log_level=log_level) - registration_method.set_number_of_iterations(number_of_iterations_greedy) - - segmentation_method = SegmentChestTotalSegmentatorWithContrast(log_level=log_level) - segmentation_method.set_has_academic_license(True) + registration_method = HEART_CT_KCL.registrar(test_mode, log_level=log_level) + segmentation_method = HEART_CT_KCL.segmenter(test_mode, log_level=log_level) # Directory setup and data reading diff --git a/tutorials/tutorial_01_lung_gated_ct_to_usd.py b/tutorials/tutorial_01_lung_gated_ct_to_usd.py index 55a3c4c1..3fc07bb5 100644 --- a/tutorials/tutorial_01_lung_gated_ct_to_usd.py +++ b/tutorials/tutorial_01_lung_gated_ct_to_usd.py @@ -95,17 +95,17 @@ data_dir = TCIA_4D_LUNG.input_directory(test_mode) if test_mode: - number_of_iterations_greedy = TCIA_4D_LUNG.number_of_iterations_greedy_test + number_of_iterations_greedy = [1, 0] frame_files = sorted(data_dir.glob("100_HM10395_g0??.nii.gz"))[0:2] else: - number_of_iterations_greedy = TCIA_4D_LUNG.number_of_iterations_greedy + number_of_iterations_greedy = [100, 100, 10, 5] frame_files = sorted(data_dir.glob("100_HM10395_g0??.nii.gz")) log_level = logging.INFO registration_method = RegisterImagesGreedy(log_level=log_level) registration_method.set_number_of_iterations(number_of_iterations_greedy) - registration_method.set_metric(TCIA_4D_LUNG.greedy_metric) + registration_method.set_metric("CC") segmentation_method = SegmentNVSegmentCTMRI(log_level=log_level) diff --git a/tutorials/tutorial_01_lung_gated_ct_to_usd_tetmesh.py b/tutorials/tutorial_01_lung_gated_ct_to_usd_tetmesh.py index d6f8d900..f54a643a 100644 --- a/tutorials/tutorial_01_lung_gated_ct_to_usd_tetmesh.py +++ b/tutorials/tutorial_01_lung_gated_ct_to_usd_tetmesh.py @@ -73,8 +73,6 @@ MONAIPhysioBase, ProcessContours, ProcessTests, - RegisterImagesGreedy, - SegmentChestTotalSegmentator, ) # Only run if this script is not imported as a module @@ -96,20 +94,15 @@ data_dir = TCIA_4D_LUNG.input_directory(test_mode) if test_mode: - number_of_iterations_greedy = [1, 0] frame_files = sorted(data_dir.glob("100_HM10395_g0??.nii.gz"))[0:2] else: - number_of_iterations_greedy = [30, 15, 7, 3] frame_files = sorted(data_dir.glob("100_HM10395_g0??.nii.gz")) log_level = logging.INFO reporter = MONAIPhysioBase(class_name=class_name, log_level=log_level) - registration_method = RegisterImagesGreedy(log_level=log_level) - registration_method.set_number_of_iterations(number_of_iterations_greedy) - - segmentation_method = SegmentChestTotalSegmentator(log_level=log_level) - segmentation_method.set_has_academic_license(True) + registration_method = TCIA_4D_LUNG.registrar(test_mode, log_level=log_level) + segmentation_method = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) contour_tools = ProcessContours(log_level=log_level) diff --git a/tutorials/tutorial_02_duke_heart_distancemap_finetune_icon.py b/tutorials/tutorial_02_duke_heart_distancemap_finetune_icon.py index 80190766..848d9082 100644 --- a/tutorials/tutorial_02_duke_heart_distancemap_finetune_icon.py +++ b/tutorials/tutorial_02_duke_heart_distancemap_finetune_icon.py @@ -50,7 +50,7 @@ import shutil import time from pathlib import Path -from typing import Any, Optional +from typing import Any, Optional, cast import itk import numpy as np @@ -109,11 +109,14 @@ else: number_of_iterations_icon = 10 epochs = 100 - number_of_iterations_greedy = DUKE_HEART.greedy_iterations(test_mode) log_level = logging.INFO reporter = MONAIPhysioBase(class_name=class_name, log_level=log_level) + number_of_iterations_greedy = cast( + RegisterImagesGreedy, DUKE_HEART.registrar(test_mode, log_level=log_level) + ).number_of_iterations + derived_dir.mkdir(parents=True, exist_ok=True) contour_tools = ProcessContours(log_level=log_level) diff --git a/tutorials/tutorial_02_lung_distancemap_finetune_icon.py b/tutorials/tutorial_02_lung_distancemap_finetune_icon.py index 8cf0c900..5c128ce9 100644 --- a/tutorials/tutorial_02_lung_distancemap_finetune_icon.py +++ b/tutorials/tutorial_02_lung_distancemap_finetune_icon.py @@ -16,7 +16,7 @@ within each case only every other respiratory phase (``g000``, ``g020``, ``g040``, ``g060``, ``g080``) -- half the time points, spanning the full breathing cycle at half the segmentation cost. Each selected phase is -segmented once with ``SegmentNVSegmentCTMRI``; the lung labelmap is kept for +segmented once with ``TCIA_4D_LUNG.segmenter_class``; the lung labelmap is kept for uniGradICON's Dice loss and the lung surfaces are combined and rasterized into the distance map that serves as the training "image". Segmentation outputs are cached on disk, so a second run of this tutorial only re-runs the @@ -90,7 +90,6 @@ RegisterImagesGreedy, RegisterImagesGreedyICON, RegisterImagesICON, - SegmentNVSegmentCTMRI, WorkflowConvertImageToVTK, WorkflowFinetuneICONRegistration, ) @@ -142,11 +141,14 @@ cases_dir = TCIA_4D_LUNG.cases_directory(test_mode) number_of_iterations_icon = 10 epochs = 200 - number_of_iterations_greedy = TCIA_4D_LUNG.greedy_iterations(test_mode) log_level = logging.INFO reporter = MONAIPhysioBase(class_name=class_name, log_level=log_level) + number_of_iterations_greedy = cast( + RegisterImagesGreedy, TCIA_4D_LUNG.registrar(test_mode, log_level=log_level) + ).number_of_iterations + derived_dir.mkdir(parents=True, exist_ok=True) # Held-out evaluation pair (100_HM10395 is excluded from finetuning). @@ -163,7 +165,7 @@ ) # Segmentation and distance-map generation - segmenter = SegmentNVSegmentCTMRI(log_level=log_level) + segmenter = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) segmentation_workflow = WorkflowConvertImageToVTK( segmentation_method=segmenter, log_level=log_level, diff --git a/tutorials/tutorial_02_lung_finetune_icon.py b/tutorials/tutorial_02_lung_finetune_icon.py index bafe7a91..3258bb62 100644 --- a/tutorials/tutorial_02_lung_finetune_icon.py +++ b/tutorials/tutorial_02_lung_finetune_icon.py @@ -19,8 +19,8 @@ warped image is compared to the fixed image directly -- normalized cross-correlation (1.0 is a perfect match) and RMSE in HU, both restricted to the fixed image's segmented foreground. The secondary metric is label -overlap: ``SegmentNVSegmentCTMRI`` segments the fixed and moving images once -each, and the moving labelmap is warped onto the fixed grid by every +overlap: ``TCIA_4D_LUNG.segmenter_class`` segments the fixed and moving images +once each, and the moving labelmap is warped onto the fixed grid by every transform, so the Dice scores reflect the transform rather than segmentation variability on re-segmented warped volumes. The moving image and labelmap resampled onto the fixed grid without registration supply the "before @@ -98,7 +98,6 @@ RegisterImagesGreedy, RegisterImagesGreedyICON, RegisterImagesICON, - SegmentNVSegmentCTMRI, WorkflowFinetuneICONRegistration, ) @@ -238,7 +237,7 @@ # Each image is segmented once and the moving labelmap is warped by every # transform, so Dice reflects the transform rather than what the segmenter # does differently on each interpolated volume. - segmenter = SegmentNVSegmentCTMRI(log_level=log_level) + segmenter = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) def segment_phase(image_file: Path, image: itk.Image) -> itk.Image: """Segment one phase, caching the labelmap under ``labelmaps_dir``. diff --git a/tutorials/tutorial_03_heart_reconstruct_highres_4d_ct.py b/tutorials/tutorial_03_heart_reconstruct_highres_4d_ct.py index dbd2dc7d..d563c483 100644 --- a/tutorials/tutorial_03_heart_reconstruct_highres_4d_ct.py +++ b/tutorials/tutorial_03_heart_reconstruct_highres_4d_ct.py @@ -21,11 +21,10 @@ from pathlib import Path import itk -from parameters_base import ParametersBase +from parameters_heart_ct_kcl import HEART_CT_KCL from monai_physio import ( ProcessTests, - RegisterImagesGreedy, WorkflowReconstructHighres4DCT, ) @@ -42,27 +41,21 @@ class_name = "tutorial_03_heart_reconstruct_highres_4d_ct" - # Only the shared directory roots are needed here; no dataset-specific - # parameters module applies to this tutorial. - tutorial_paths = ParametersBase() test_mode = ProcessTests.running_as_test() - output_dir = tutorial_paths.output_directory(test_mode) / "tutorial_03_heart" + output_dir = HEART_CT_KCL.output_directory(test_mode) / "tutorial_03_heart" baselines_dir = repo_root / "tests" / "baselines" case_glob = "slice_???.mha" if test_mode: - data_dir = tutorial_paths.data_directory(test_mode) / "slicer_heart_small" - number_of_iterations_greedy = [1, 0] + data_dir = HEART_CT_KCL.data_directory(test_mode) / "slicer_heart_small" else: - data_dir = tutorial_paths.data_directory(test_mode) / "Slicer-Heart-CT" - number_of_iterations_greedy = [30, 15, 7, 3] + data_dir = HEART_CT_KCL.data_directory(test_mode) / "Slicer-Heart-CT" log_level = logging.INFO - registration_method = RegisterImagesGreedy(log_level=log_level) - registration_method.set_number_of_iterations(number_of_iterations_greedy) + registration_method = HEART_CT_KCL.registrar(test_mode, log_level=log_level) # Directory setup and data reading diff --git a/tutorials/tutorial_03_lung_reconstruct_highres_4d_ct.py b/tutorials/tutorial_03_lung_reconstruct_highres_4d_ct.py index 76b15114..88076890 100644 --- a/tutorials/tutorial_03_lung_reconstruct_highres_4d_ct.py +++ b/tutorials/tutorial_03_lung_reconstruct_highres_4d_ct.py @@ -31,7 +31,6 @@ from monai_physio import ( ProcessTests, - RegisterImagesGreedy, WorkflowReconstructHighres4DCT, ) @@ -56,10 +55,6 @@ case_glob = "100_HM10395_g0??.nii.gz" data_dir = TCIA_4D_LUNG.input_directory(test_mode) - if test_mode: - number_of_iterations_greedy = [1, 0] - else: - number_of_iterations_greedy = [30, 15, 7, 3] log_level = logging.INFO @@ -67,8 +62,7 @@ output_dir.mkdir(parents=True, exist_ok=True) - registration_method = RegisterImagesGreedy(log_level=log_level) - registration_method.set_number_of_iterations(number_of_iterations_greedy) + registration_method = TCIA_4D_LUNG.registrar(test_mode, log_level=log_level) phase_files = sorted(data_dir.glob(case_glob)) if not phase_files: diff --git a/tutorials/tutorial_04_heart_ct_to_vtk.py b/tutorials/tutorial_04_heart_ct_to_vtk.py index 3f5ee814..460edac4 100644 --- a/tutorials/tutorial_04_heart_ct_to_vtk.py +++ b/tutorials/tutorial_04_heart_ct_to_vtk.py @@ -55,7 +55,6 @@ save_label_surfaces = True use_simpleware = False - use_totalsegmentator_academic_license = True if test_mode: data_dir = HEART_CT_KCL.data_directory(test_mode) / "slicer_heart_small" @@ -71,13 +70,9 @@ log_level=log_level ) else: - total_segmentation_method = SegmentChestTotalSegmentatorWithContrast( + segmentation_method = SegmentChestTotalSegmentatorWithContrast( log_level=log_level ) - total_segmentation_method.set_has_academic_license( - use_totalsegmentator_academic_license - ) - segmentation_method = total_segmentation_method # Directory setup and data reading diff --git a/tutorials/tutorial_04_lung_ct_to_vtk.py b/tutorials/tutorial_04_lung_ct_to_vtk.py index ec86e160..ff9b9043 100644 --- a/tutorials/tutorial_04_lung_ct_to_vtk.py +++ b/tutorials/tutorial_04_lung_ct_to_vtk.py @@ -26,7 +26,6 @@ from monai_physio import ( ProcessContours, ProcessTests, - SegmentChestTotalSegmentator, WorkflowConvertImageToVTK, ) @@ -58,8 +57,7 @@ log_level = logging.INFO - segmentation_method = SegmentChestTotalSegmentator(log_level=log_level) - segmentation_method.set_has_academic_license(True) + segmentation_method = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) # Directory setup and data reading output_dir.mkdir(parents=True, exist_ok=True) diff --git a/tutorials/tutorial_06_lung_create_statistical_model.py b/tutorials/tutorial_06_lung_create_statistical_model.py index 8f7c1c18..36d47f21 100644 --- a/tutorials/tutorial_06_lung_create_statistical_model.py +++ b/tutorials/tutorial_06_lung_create_statistical_model.py @@ -104,8 +104,7 @@ output_dir.mkdir(parents=True, exist_ok=True) # Create lung surface files - segmentation_method = TCIA_4D_LUNG.segmenter_class(log_level=log_level) - segmentation_method.set_fast_mode(True) + segmentation_method = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) workflow_method = WorkflowConvertImageToVTK( segmentation_method=segmentation_method, log_level=log_level ) diff --git a/tutorials/tutorial_07_heart_fit_statistical_model_to_patient.py b/tutorials/tutorial_07_heart_fit_statistical_model_to_patient.py index 967e440c..3420ac57 100644 --- a/tutorials/tutorial_07_heart_fit_statistical_model_to_patient.py +++ b/tutorials/tutorial_07_heart_fit_statistical_model_to_patient.py @@ -27,10 +27,7 @@ from monai_physio import ( ProcessContours, - # SegmentHeartSimplewareTrimmedBranches, - # SegmentChestTotalSegmentatorWithContrast, ProcessTests, - SegmentChestTotalSegmentator, WorkflowFitStatisticalModelToPatient, ) @@ -77,12 +74,7 @@ log_level = logging.INFO - segmentation_method = SegmentChestTotalSegmentator() - segmentation_method.set_has_academic_license(True) - # segmentation_method = SegmentHeartSimplewareTrimmedBranches() # Use when available - # and images are contrast-enhanced. - # segmentation_method = SegmentChestTotalSegmentatorWithContrast() # Use when - # contrast-enhanced images and Simpleware is not available. + segmentation_method = HEART_CT_KCL.segmenter(test_mode, log_level=log_level) # Directory setup and data reading diff --git a/tutorials/tutorial_07_lung_fit_statistical_model_to_patient.py b/tutorials/tutorial_07_lung_fit_statistical_model_to_patient.py index 3c781836..d763d08a 100644 --- a/tutorials/tutorial_07_lung_fit_statistical_model_to_patient.py +++ b/tutorials/tutorial_07_lung_fit_statistical_model_to_patient.py @@ -36,7 +36,6 @@ from monai_physio import ( ProcessContours, ProcessTests, - SegmentChestTotalSegmentator, WorkflowConvertImageToVTK, WorkflowFitStatisticalModelToPatient, ) @@ -87,8 +86,7 @@ # The same segmenter and surface-extraction workflow used by Tutorial 6, so # the patient surface matches the topology the PCA model was built from. - segmentation_method = SegmentChestTotalSegmentator(log_level=log_level) - segmentation_method.fast_mode = True + segmentation_method = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) segmentation_workflow = WorkflowConvertImageToVTK( segmentation_method=segmentation_method, log_level=log_level ) diff --git a/tutorials/tutorial_08_lung_fit_model_to_4d_patients.py b/tutorials/tutorial_08_lung_fit_model_to_4d_patients.py index 915a15a8..f828bf6d 100644 --- a/tutorials/tutorial_08_lung_fit_model_to_4d_patients.py +++ b/tutorials/tutorial_08_lung_fit_model_to_4d_patients.py @@ -60,8 +60,6 @@ ProcessContours, ProcessTests, ProcessTransforms, - RegisterImagesGreedy, - SegmentChestTotalSegmentator, WorkflowConvertImageToVTK, WorkflowFitStatisticalModelToPatient, WorkflowReconstructHighres4DCT, @@ -157,8 +155,7 @@ "See data/TCIA-4DLung/README.md for download instructions." ) - segmentation_method = SegmentChestTotalSegmentator(log_level=log_level) - segmentation_method.fast_mode = True + segmentation_method = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) segmentation_workflow = WorkflowConvertImageToVTK( segmentation_method=segmentation_method, log_level=log_level ) @@ -264,7 +261,7 @@ ] time_series = [itk.imread(str(path)) for path in phase_files] - registration_method = RegisterImagesGreedy(log_level=log_level) + registration_method = TCIA_4D_LUNG.registrar(test_mode, log_level=log_level) reg_workflow = WorkflowReconstructHighres4DCT( time_series_images=time_series, diff --git a/tutorials/tutorial_10_lung_infer_physicsnemo_mgn.py b/tutorials/tutorial_10_lung_infer_physicsnemo_mgn.py index aee53ff2..b3eaf4a5 100644 --- a/tutorials/tutorial_10_lung_infer_physicsnemo_mgn.py +++ b/tutorials/tutorial_10_lung_infer_physicsnemo_mgn.py @@ -169,7 +169,7 @@ def _respiratory_stage_from_filename(surface_file: Path) -> float: warp_interpolation="linear", warp_background_value=-1000.0, smoothing_sigma_mm=smoothing_sigma_mm, - usd_project_name=f"{case_id}_mgn_motion", + usd_project_name=f"lung_{case_id}_mgn_motion", anatomy_type="lung", separate_by_connectivity=True, ) diff --git a/tutorials/tutorial_12_lung_end_to_end_inference.py b/tutorials/tutorial_12_lung_end_to_end_inference.py index 8080f79e..393f15bd 100644 --- a/tutorials/tutorial_12_lung_end_to_end_inference.py +++ b/tutorials/tutorial_12_lung_end_to_end_inference.py @@ -16,8 +16,9 @@ 1. Read the case's gated CT sequence. The respiratory stages come from the ``g{PPP}`` filenames, so the acquisition itself says what is predicted. -2. Segment the reference phase (``g070``) with ``SegmentNVSegmentCTMRI``, the - segmenter the lung shape model was built with, and extract its lung surface. +2. Segment the reference phase (``g070``) with ``TCIA_4D_LUNG.segmenter_class``, + the segmenter the lung shape model was built with, and extract its lung + surface. 3. Fit the lung PCA model to that phase with :class:`monai_physio.WorkflowFitStatisticalModelToPatient` and PCA-based @@ -36,8 +37,9 @@ Data Required ------------- * ``data/TCIA-4DLung//_g0??.nii.gz`` - the gated CT sequence - * ``output/tutorial_06_lung/`` - lung PCA model + mean surface - * ``network_weights/physicsnemo_mgn_lung_motion/`` - Tutorial 9 checkpoint + * ``network_weights/physicsnemo_mgn_lung_motion/`` - Tutorial 9 checkpoint, + which also carries the lung PCA model + mean surface it was trained + against (``pca_model.json``, ``pca_mean_surface.vtp``) * ``network_weights/icon_tcia_4dlung_distancemap/`` - Tutorial 2 weights, optional; the stock uniGradICON weights are used without them @@ -73,7 +75,6 @@ from monai_physio import ( ProcessContours, ProcessTests, - SegmentNVSegmentCTMRI, WorkflowConvertImageToVTK, WorkflowFitStatisticalModelToPatient, WorkflowInferMovement, @@ -123,13 +124,14 @@ def _record_step(times_s: dict[str, float], step: str, started: float) -> float: # Keep a test run out of the directories a full run reads and writes. weights_dir = TCIA_4D_LUNG.weights_directory(test_mode) - # PCA model + mean surface produced by Tutorial 6 (lung). - pca_model_file = TCIA_4D_LUNG.pca_model_file(test_mode) - pca_mean_file = TCIA_4D_LUNG.pca_mean_surface_file(test_mode) # Weights Tutorial 9 trained, and the checkpoint epoch to infer with; None # uses the final weights. model_dir = TCIA_4D_LUNG.mgn_weights_directory(test_mode) epoch: Optional[int] = None + # PCA model + mean surface Tutorial 9 trained against, shipped alongside + # the checkpoint. + pca_model_file = model_dir / "pca_model.json" + pca_mean_file = model_dir / "pca_mean_surface.vtp" # Distance-map weights finetuned on TCIA-4DLung by # tutorial_02_lung_distancemap_finetune_icon.py, used by the @@ -168,8 +170,8 @@ def _record_step(times_s: dict[str, float], step: str, started: float) -> float: output_dir.mkdir(parents=True) for required_file, hint in ( - (pca_model_file, "tutorial_06_lung_create_statistical_model.py"), - (pca_mean_file, "tutorial_06_lung_create_statistical_model.py"), + (pca_model_file, "tutorial_09_lung_train_physicsnemo_mgn.py"), + (pca_mean_file, "tutorial_09_lung_train_physicsnemo_mgn.py"), (model_dir / "mgn_stage_model.pt", "tutorial_09_lung_train_physicsnemo_mgn.py"), ): if not required_file.exists(): @@ -223,8 +225,9 @@ def _record_step(times_s: dict[str, float], step: str, started: float) -> float: lung_labelmap_file = output_dir / f"{reference_stem}_labelmap.nii.gz" logger.info("Segmenting the reference phase %s", reference_file.name) contour_tools = ProcessContours(log_level=log_level) + segmentation_method = TCIA_4D_LUNG.segmenter(test_mode, log_level=log_level) segmentation_result = WorkflowConvertImageToVTK( - segmentation_method=SegmentNVSegmentCTMRI(log_level=log_level), + segmentation_method=segmentation_method, log_level=log_level, ).process( input_image=reference_image, diff --git a/tutorials/tutorial_13_heart_and_lung_motion.py b/tutorials/tutorial_13_heart_and_lung_motion.py index 91cb231d..1a9626d1 100644 --- a/tutorials/tutorial_13_heart_and_lung_motion.py +++ b/tutorials/tutorial_13_heart_and_lung_motion.py @@ -56,12 +56,18 @@ that is sliding past them. A real thorax slips there instead: the visceral pleura slides against the parietal pleura, the epicardium against the pericardium, and only the motion *along the surface normal* -- the organ filling -and emptying -- is transmitted outward. Each stage's samples are therefore split -into their normal and tangential components, and outside the organ only the -normal component is spread. Inside it both are, so the parenchyma and the -myocardium still follow their own surfaces. The organ masks that select between -the two are softened by ``slip_transition_mm``, so the sliding stops over a band -rather than at a step that would tear the warped volumes. +and emptying -- is transmitted outward, fading out with distance rather than +reaching indefinitely into the surrounding tissue. Each stage's field is +therefore smoothed once with +``ProcessTransforms.smooth_deformation_field_transform``, then restricted with +``ProcessTransforms.restrict_deformation_field_to_normal_falloff_outside_mask``, +which splits it into its normal and tangential components -- outside the organ +only the normal component survives -- and fades that component to zero by +``falloff_distance_mm``. Inside the organ mask the whole field passes through +unchanged, so the parenchyma and the myocardium still follow their own +surfaces. The direction switch itself is softened by +``direction_transition_mm``, so the sliding stops over a band rather than at a +step that would tear the warped volumes. Reference stage --------------- @@ -116,8 +122,8 @@ - ``deformation_field__s.mha`` / ``surface_normal_field__s.mha`` / ``deformed__surface_s.vtp`` - per-stage inferred motion. -- ``interior_mask_.mha`` - the softened organ mask each rhythm's sliding - is confined to. +- ``interior_mask_.mha`` - the binary organ mask each rhythm's normal + restriction and falloff are computed against. - ``breathing_lungs.usd`` / ``beating_heart.usd`` - each rhythm on its own. - ``combined_frame_.vtp`` (``000..099``) + ``heart_and_lung_motion.usd`` - the combined respiratory + cardiac 4D motion, painted with anatomy materials. @@ -146,7 +152,6 @@ ProcessTests, ProcessTransforms, ProcessUSDAnatomy, - SegmentHeartSimplewareTrimmedBranches, SegmentNVSegmentCTMRI, WorkflowConvertVTKToUSD, WorkflowFitStatisticalModelToPatient, @@ -224,25 +229,27 @@ # to the thorax it has to fill, so it is spread further than the heart. respiratory_sigma_mm = 15.0 cardiac_sigma_mm = 10.0 - # How far each rhythm's push and pull carries *beyond* its own organ, as a - # separate sigma for the normal component spread outside the interior mask. - # The lungs drive the whole thorax, so they keep their full reach. The heart - # sits in tissue that barely moves with it, so its influence is confined to - # a quarter of that distance: the pericardial neighborhood still follows the - # myocardium at full strength, while the mediastinum and chest wall further - # out stop being pumped by it. Only the reach changes -- the displacement at - # the heart surface, and everything inside it, is untouched. - cardiac_exterior_sigma_mm = 0.25 * cardiac_sigma_mm + # How far each rhythm's push and pull carries *beyond* its own organ, as the + # distance its normal-only displacement fades to zero over, outside the + # interior mask. The lungs drive the whole thorax, so they keep their full + # reach. The heart sits in tissue that barely moves with it, so its + # influence is confined to a quarter of that distance: the pericardial + # neighborhood still follows the myocardium at full strength, while the + # mediastinum and chest wall further out stop being pumped by it. Only the + # reach changes -- the displacement at the heart surface, and everything + # inside it, is untouched. + respiratory_falloff_distance_mm = respiratory_sigma_mm + cardiac_falloff_distance_mm = 0.25 * cardiac_sigma_mm # How wide a band (mm) the sliding motion dies out over at the pleura and # the pericardium. Zero would make each slip boundary a step, and shear the # voxels either side of it in opposite directions. - slip_transition_mm = 5.0 + direction_transition_mm = 5.0 # How far past the labels that band starts. The fitted shape-model surface # and the segmentation of the same organ disagree by about a # deformation-grid voxel (3 mm here), so a fall-off that begins at the label # edge catches the surface the network predicted on: it costs a quarter of # the lung's tangential motion and a third of the heart's. - slip_offset_mm = 3.0 + direction_offset_mm = 3.0 # Grid every deformation field is sampled on, as a fraction of the CT's own # voxel pitch per axis. The fields are Gaussian-smoothed by the sigmas above, # so they carry no detail a sub-millimeter grid could resolve, while a @@ -339,7 +346,7 @@ # labelmap above. heart_labelmap_file = output_dir / "chest_ct_heart_labelmap.mha" if not heart_labelmap_file.exists(): - heart_segmenter = SegmentHeartSimplewareTrimmedBranches(log_level=log_level) + heart_segmenter = DUKE_HEART.segmenter(test_mode, log_level=log_level) itk.imwrite( heart_segmenter.segment(patient_image)["labelmap"], str(heart_labelmap_file), @@ -479,24 +486,13 @@ logger.info("Fitted the Duke heart model to %s", patient_image_file.name) # ======================================================================== - # Interior masks: where sliding propagates, and where only expansion does. + # Interior masks: where the whole field propagates, vs. only its normal + # component (which restrict_deformation_field_to_normal_falloff_outside_mask + # then ramps and fades outside of, by direction_offset_mm/ + # direction_transition_mm/falloff_distance_mm). # ======================================================================== - def interior_mask_on_grid(labelmap: itk.Image, label_ids: list[int]) -> itk.Image: - """Ramp an organ's labels into the blend weight the spreading uses. - - 1 inside the organ, where a stage's full displacement is propagated, - falling to 0 outside it, where only the component along the surface - normal is. The fall-off is what keeps a slip boundary from shearing - neighboring voxels in opposite directions and tearing the warped CT. - - It is placed by distance rather than by blurring the labels, because a - symmetric blur would put the half-way point of that fall-off *on* the - organ boundary -- which is where the network's displacements were - predicted, and where the animated surface sits. Those samples would - then lose a third of their tangential motion to a band meant for the - tissue beyond them. The mask instead stays 1 until ``slip_offset_mm`` - past the labels and decays over the ``slip_transition_mm`` after that. - """ + def binary_mask_on_grid(labelmap: itk.Image, label_ids: list[int]) -> itk.Image: + """Rasterize an organ's labels onto the deformation grid as a 0/1 mask.""" labels = itk.GetArrayViewFromImage(labelmap) binary = itk.GetImageFromArray(np.isin(labels, label_ids).astype(np.float32)) binary.CopyInformation(labelmap) @@ -505,31 +501,16 @@ def interior_mask_on_grid(labelmap: itk.Image, label_ids: list[int]) -> itk.Imag itk.IdentityTransform[itk.D, 3].New(), deformation_grid, ) - interior = itk.GetImageFromArray( - (itk.array_from_image(on_grid) > 0.5).astype(np.uint8) - ) - interior.CopyInformation(on_grid) - distance_mm = itk.array_from_image( - itk.signed_maurer_distance_map_image_filter( - interior, - InsideIsPositive=False, - SquaredDistance=False, - UseImageSpacing=True, - ) - ) - # Smoothstep rather than a straight ramp, so the mask has no kink at - # either end for the warped volumes to crease along. - ramp = np.clip((distance_mm - slip_offset_mm) / slip_transition_mm, 0.0, 1.0) mask = itk.GetImageFromArray( - (1.0 - ramp * ramp * (3.0 - 2.0 * ramp)).astype(np.float32) + (itk.array_from_image(on_grid) > 0.5).astype(np.uint8) ) mask.CopyInformation(on_grid) return mask - lung_interior_mask = interior_mask_on_grid( + lung_interior_mask = binary_mask_on_grid( chest_labelmap, list(segmenter.taxonomy.labels_in_group("lung")) ) - heart_interior_mask = interior_mask_on_grid( + heart_interior_mask = binary_mask_on_grid( heart_labelmap, [ int(value) @@ -556,27 +537,33 @@ def stage_transforms( sigma_mm: float, tag: str, interior_mask: itk.Image, - exterior_sigma_mm: Optional[float] = None, + falloff_distance_mm: Optional[float] = None, ) -> tuple[list[itk.Transform], list[itk.Transform], list[pv.DataSet]]: - """Infer one rhythm across ``stages`` as smoothed deformations. + """Infer one rhythm across ``stages`` as smoothed, normal-restricted fields. Each stage is rasterized twice: the forward field, which moves mesh vertices from the reference frame to the stage, and the inverse field, which is what resampling an image into that stage's frame needs. Both - are spread into continuous transforms by the vertex counts the - rasterization reports, so the smoothing keeps the displacement - magnitude the network predicted. - - The spreading is given ``interior_mask`` and the surface normals the - rasterization reports, so beyond the organ it carries only the motion - along those normals: surrounding tissue is pushed and pulled by the - organ without being dragged along it. ``exterior_sigma_mm`` spreads that - outward motion by its own sigma, which is how far into the surrounding - tissue the organ reaches; it defaults to ``sigma_mm``. The mask arrives - in the reference frame, which is the frame the forward field is indexed - in; the inverse field is indexed in the stage's own frame, so the mask is - resampled into it first through the unrestricted inverse deformation. + are spread into continuous fields by the vertex counts the rasterization + reports (:meth:`ProcessTransforms.smooth_deformation_field_transform`), + which keeps the displacement magnitude the network predicted, and the + per-vertex surface normals are spread the same way to give a dense + normal field on the same grid. + + Both are then restricted with + :meth:`ProcessTransforms.restrict_deformation_field_to_normal_falloff_outside_mask` + against ``interior_mask``, so beyond the organ only the motion along + those normals survives: surrounding tissue is pushed and pulled by the + organ without being dragged along it, fading to zero by + ``falloff_distance_mm`` -- how far into the surrounding tissue the organ + reaches; it defaults to ``sigma_mm``. The mask arrives in the reference + frame, which is the frame the forward field is indexed in; the inverse + field is indexed in the stage's own frame, so the mask is resampled into + it first through the unrestricted inverse deformation. """ + exterior_reach_mm = ( + sigma_mm if falloff_distance_mm is None else falloff_distance_mm + ) infer = WorkflowInferMovement( WorkflowInferPhysicsNeMo( model_directory=model_directory, epoch=None, log_level=log_level @@ -617,14 +604,27 @@ def stage_transforms( ) deformed_surfaces.append(fields["forward"]["deformed_surface"]) + smoothed_forward = transform_tools.smooth_deformation_field_transform( + fields["forward"]["deformation_field"], + sigma_mm, + fields["forward"]["weight_image"], + ) + # The raw per-vertex normals live only where a vertex was binned, + # same as the raw displacements; spreading them the same way makes + # them dense over the same reach the restriction needs them on. + forward_normals = transform_tools.smooth_deformation_field_transform( + fields["forward"]["normal_image"], + sigma_mm, + fields["forward"]["weight_image"], + ) forward_transforms.append( - transform_tools.smooth_deformation_field_transform( - fields["forward"]["deformation_field"], - sigma_mm, - fields["forward"]["weight_image"], - fields["forward"]["normal_image"], + transform_tools.restrict_deformation_field_to_normal_falloff_outside_mask( + smoothed_forward.GetDisplacementField(), + forward_normals.GetDisplacementField(), interior_mask, - exterior_sigma_mm, + direction_offset_mm, + direction_transition_mm, + exterior_reach_mm, ) ) @@ -637,16 +637,21 @@ def stage_transforms( sigma_mm, fields["inverse"]["weight_image"], ) + inverse_normals = transform_tools.smooth_deformation_field_transform( + fields["inverse"]["normal_image"], + sigma_mm, + fields["inverse"]["weight_image"], + ) inverse_transforms.append( - transform_tools.smooth_deformation_field_transform( - fields["inverse"]["deformation_field"], - sigma_mm, - fields["inverse"]["weight_image"], - fields["inverse"]["normal_image"], + transform_tools.restrict_deformation_field_to_normal_falloff_outside_mask( + unrestricted_inverse.GetDisplacementField(), + inverse_normals.GetDisplacementField(), transform_tools.transform_image( interior_mask, unrestricted_inverse, deformation_grid ), - exterior_sigma_mm, + direction_offset_mm, + direction_transition_mm, + exterior_reach_mm, ) ) @@ -678,6 +683,7 @@ def stage_transforms( respiratory_sigma_mm, "respiratory", lung_interior_mask, + respiratory_falloff_distance_mm, ) cardiac_forward, cardiac_inverse, heart_surfaces = stage_transforms( heart_model_dir, @@ -687,7 +693,7 @@ def stage_transforms( cardiac_sigma_mm, "cardiac", heart_interior_mask, - cardiac_exterior_sigma_mm, + cardiac_falloff_distance_mm, ) # Each rhythm on its own, as a reference for the combined animation below. From c9c4a62b5ea25230c50f48f79c2b3398e83b05a6 Mon Sep 17 00:00:00 2001 From: Stephen Aylward Date: Mon, 21 Sep 2026 00:21:22 -0400 Subject: [PATCH 2/2] ENH: Coderabbit --- docs/tutorials.rst | 13 +++++--- src/monai_physio/process_transforms.py | 33 ++++++++++++++++++- tutorials/README.md | 10 ++++-- ...orial_02_lung_distancemap_finetune_icon.py | 11 +++++-- tutorials/tutorial_02_lung_finetune_icon.py | 6 +++- 5 files changed, 61 insertions(+), 12 deletions(-) diff --git a/docs/tutorials.rst b/docs/tutorials.rst index 6e03eab2..5587f2bd 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -308,10 +308,15 @@ Outputs Adapt to your data Swap the downloaded ``Chest-CT`` volume for your own ungated chest CT, - and point ``model_dir`` at a different checkpoint - either the one - Tutorial 9 trains, or a pretrained one for another anatomy - to demo a - different cohort or organ. This is a standalone shortcut, not step one - of the numbered series: start at Tutorial 1 for the full pipeline. + and point ``model_dir`` at a different lung-motion checkpoint - either + the one Tutorial 9 trains, or another pretrained lung checkpoint whose + directory also carries a matching ``pca_model.json`` and + ``pca_mean_surface.vtp`` - to demo a different cohort. Demoing another + anatomy needs more than swapping ``model_dir``: the segmenter + (``SegmentChestTotalSegmentator``) and ``anatomy_type="lung"`` passed to + ``process_time_series`` are hardcoded to lung and must change too. This + is a standalone shortcut, not step one of the numbered series: start at + Tutorial 1 for the full pipeline. Tutorial 1: Gated 4D CT to Animated USD ======================================= diff --git a/src/monai_physio/process_transforms.py b/src/monai_physio/process_transforms.py index eb3fe25d..111cbee1 100644 --- a/src/monai_physio/process_transforms.py +++ b/src/monai_physio/process_transforms.py @@ -808,8 +808,39 @@ def restrict_deformation_field_to_normal_falloff_outside_mask( Raises: ValueError: If ``normal_image`` or ``mask`` does not lie on - ``field``'s grid. + ``field``'s grid (size, spacing, origin, direction), or if + ``direction_offset_mm`` is not finite, or + ``direction_transition_mm``/``falloff_distance_mm`` is not a + finite value greater than zero. """ + if not np.isfinite(direction_offset_mm): + raise ValueError( + f"direction_offset_mm must be finite, got {direction_offset_mm}." + ) + if not (np.isfinite(direction_transition_mm) and direction_transition_mm > 0.0): + raise ValueError( + "direction_transition_mm must be finite and > 0, got " + f"{direction_transition_mm}." + ) + if not (np.isfinite(falloff_distance_mm) and falloff_distance_mm > 0.0): + raise ValueError( + "falloff_distance_mm must be finite and > 0, got " + f"{falloff_distance_mm}." + ) + + field_size = field.GetLargestPossibleRegion().GetSize() + for name, grid_image in (("normal_image", normal_image), ("mask", mask)): + if ( + grid_image.GetLargestPossibleRegion().GetSize() != field_size + or grid_image.GetSpacing() != field.GetSpacing() + or grid_image.GetOrigin() != field.GetOrigin() + or grid_image.GetDirection() != field.GetDirection() + ): + raise ValueError( + f"{name} must lie on the field's grid (same size, spacing, " + "origin and direction)." + ) + field_arr = itk.array_from_image(field).astype(np.float64) normals = itk.array_from_image(normal_image).astype(np.float64) mask_arr = itk.array_from_image(mask).astype(np.float64) diff --git a/tutorials/README.md b/tutorials/README.md index 1a65411d..cc2aebf5 100644 --- a/tutorials/README.md +++ b/tutorials/README.md @@ -69,14 +69,18 @@ notes on running them against your own data. ## Running a Tutorial -Each tutorial is a standalone, straightforward Python script, executed -end-to-end. Paths are defined near the top of each script. By default, data -is read from the repository `data/` directory and outputs are written under +Each numbered tutorial is a standalone, straightforward Python script, +executed end-to-end - except Tutorial 00, which is a Jupyter notebook. Paths +are defined near the top of each script. By default, data is read from the +repository `data/` directory and outputs are written under `tutorials/output//`. ```bash # Run the whole tutorial from the command line python tutorials/tutorial_01_heart_gated_ct_to_usd.py + +# Tutorial 00 is a notebook - run it from Jupyter instead +jupyter notebook tutorials/tutorial_00_lung_demo.ipynb ``` In VS Code or Cursor, open the tutorial and use **Run Python File** (or run diff --git a/tutorials/tutorial_02_lung_distancemap_finetune_icon.py b/tutorials/tutorial_02_lung_distancemap_finetune_icon.py index 5c128ce9..1d2e31b3 100644 --- a/tutorials/tutorial_02_lung_distancemap_finetune_icon.py +++ b/tutorials/tutorial_02_lung_distancemap_finetune_icon.py @@ -191,10 +191,15 @@ def segment_phase(image_file: Path) -> tuple[Path, Path]: """ # ``.stem`` only strips ``.gz``, leaving a stray ``.nii`` in the name, # since these are ``.nii.gz`` (TCIA) rather than ``.mha`` (DIR-Lab). + # Cache files carry the segmenter class name so switching + # segmenter_class regenerates rather than silently reusing labelmaps + # and distance maps from a different segmenter. image_stem = image_file.name.removesuffix(".nii.gz") - distance_map_file = derived_dir / f"{image_stem}_distance_map.mha" - labelmap_file = derived_dir / f"{image_stem}_lung_labelmap.nii.gz" - surface_file = derived_dir / f"{image_stem}_lung_surface.vtp" + segmenter_name = type(segmenter).__name__ + cache_stem = f"{image_stem}_{segmenter_name}" + distance_map_file = derived_dir / f"{cache_stem}_distance_map.mha" + labelmap_file = derived_dir / f"{cache_stem}_lung_labelmap.nii.gz" + surface_file = derived_dir / f"{cache_stem}_lung_surface.vtp" if distance_map_file.exists() and labelmap_file.exists(): return distance_map_file, labelmap_file diff --git a/tutorials/tutorial_02_lung_finetune_icon.py b/tutorials/tutorial_02_lung_finetune_icon.py index 3258bb62..f5dc6392 100644 --- a/tutorials/tutorial_02_lung_finetune_icon.py +++ b/tutorials/tutorial_02_lung_finetune_icon.py @@ -247,8 +247,12 @@ def segment_phase(image_file: Path, image: itk.Image) -> itk.Image: """ # ``.stem`` only strips ``.gz``, leaving a stray ``.nii`` in the name, # since these are ``.nii.gz`` (TCIA) rather than ``.mha`` (DIR-Lab). + # The cache file carries the segmenter class name so switching + # segmenter_class regenerates rather than silently reusing a + # labelmap from a different segmenter. image_stem = image_file.name.removesuffix(".nii.gz") - labelmap_file = labelmaps_dir / f"{image_stem}_labelmap.mha" + segmenter_name = type(segmenter).__name__ + labelmap_file = labelmaps_dir / f"{image_stem}_{segmenter_name}_labelmap.mha" if labelmap_file.exists(): reporter.log_info("Reusing cached labelmap: %s", labelmap_file.name) return itk.imread(str(labelmap_file))