Image space and World Space convert transforms

monai/transforms/utility/array.py

@@ -31,7 +31,7 @@
 from monai.config.type_definitions import NdarrayOrTensor
 from monai.data.meta_obj import get_track_meta
 from monai.data.meta_tensor import MetaTensor
-from monai.data.utils import is_no_channel, no_collation
+from monai.data.utils import is_no_channel, no_collation, orientation_ras_lps
 from monai.networks.layers.simplelayers import (
  ApplyFilter,
  EllipticalFilter,
@@ -42,7 +42,7 @@
  SharpenFilter,
  median_filter,
 )
-from monai.transforms.inverse import InvertibleTransform
+from monai.transforms.inverse import InvertibleTransform, TraceableTransform
 from monai.transforms.traits import MultiSampleTrait
 from monai.transforms.transform import Randomizable, RandomizableTrait, RandomizableTransform, Transform
 from monai.transforms.utils import (
@@ -51,7 +51,7 @@
  map_binary_to_indices,
  map_classes_to_indices,
 )
-from monai.transforms.utils_pytorch_numpy_unification import concatenate, in1d, moveaxis, unravel_indices
+from monai.transforms.utils_pytorch_numpy_unification import concatenate, in1d, moveaxis, unravel_indices, linalg_inv
 from monai.utils import (
  MetaKeys,
  TraceKeys,
@@ -64,7 +64,7 @@
  min_version,
  optional_import,
 )
-from monai.utils.enums import TransformBackends
+from monai.utils.enums import TransformBackends, CoordinateTransformMode
 from monai.utils.misc import is_module_ver_at_least
 from monai.utils.type_conversion import convert_to_dst_type, get_equivalent_dtype
 
@@ -1715,3 +1715,84 @@ def __call__(self, img: NdarrayOrTensor, meta_dict: Mapping | None = None) -> Nd
  if self._do_transform:
  img = self.filter(img)
  return img
+
+
+class CoordinateTransform(InvertibleTransform, Transform):
+ """
+ Transform points between image coordinates and world coordinates.
+
+ Args:
+ dtype: The desired data type for the output.
+ mode: Specifies the direction of transformation. This should be an instance of
+ :py:class:`CoordinateTransformMode` enum, with either 'IMAGE_TO_WORLD' or 'WORLD_TO_IMAGE' as the value.
+ affine_lps_to_ras: Defaults to ``False``. Set this to ``True`` if: 1) The image is read by ITKReader,
+ and 2) The ITKReader has `affine_lps_to_ras=True`, and 3) The data is in world coordinates.
+ This ensures that the affine transformation between LPS (left-posterior-superior) and RAS
+ (right-anterior-superior) coordinate systems is correctly applied.
+ """
+
+ def __init__(self, dtype: DtypeLike = torch.float64, mode=CoordinateTransformMode.IMAGE_TO_WORLD, affine_lps_to_ras: bool = False) -> None:
+ self.dtype = dtype
+ self.mode = mode
+ self.affine_lps_to_ras = affine_lps_to_ras
+
+ def transform_coordinates(self, data, affine, invert=False):
+ """
+ Transform coordinates using an affine transformation matrix.
+
+ Args:
+ data: The input coordinates.
+ affine: A 3x3 or 4x4 affine transformation matrix.
+ invert: Whether to invert the affine matrix.
+
+ Returns:
+ Transformed coordinates.
+ """
+ data = convert_to_tensor(data, track_meta=get_track_meta())
+ data_: torch.Tensor = convert_to_tensor(data, track_meta=False, dtype=self.dtype)
+
+ if self.affine_lps_to_ras: # RAS affine
+ affine = orientation_ras_lps(affine)
+
+ affine_t = linalg_inv(affine)
+ _affine = affine_t if invert else affine
+
+ homogeneous = concatenate((data_, torch.ones((data_.shape[0], 1))), axis=1)
+ transformed_homogeneous = torch.matmul(_affine, homogeneous.T)
+ transformed_coordinates = transformed_homogeneous[:-1].T
+ out, *_ = convert_to_dst_type(transformed_coordinates, data, dtype=self.dtype)
+
+ extra_info = {
+ "mode": self.mode,
+ "dtype": str(self.dtype)[6:], # dtype as string; remove "torch": torch.float32 -> float32
+ "affine": affine if invert else affine_t,
+ "affine_lps_to_ras": self.affine_lps_to_ras,
+ }
+ meta_info = TraceableTransform.track_transform_meta(
+ data,
+ affine=affine,
+ extra_info=extra_info,
+ transform_info=self.get_transform_info(),
+ )
+
+ return out, meta_info
+
+ def __call__(self, data: torch.Tensor, affine: torch.Tensor) -> torch.Tensor:
+ invert = (self.mode == CoordinateTransformMode.WORLD_TO_IMAGE)
+ out, meta_info = self.transform_coordinates(data, affine, invert=invert)
+ return out.copy_meta_from(meta_info) if isinstance(out, MetaTensor) else out
+
+ def inverse(self, data: torch.Tensor) -> torch.Tensor:
+ transform = self.pop_transform(data)
+ # Create inverse transform
+ affine = transform[TraceKeys.EXTRA_INFO]["affine"]
+ dtype = transform[TraceKeys.EXTRA_INFO]["dtype"]
+ mode_ = transform[TraceKeys.EXTRA_INFO]["mode"]
+ affine_lps_to_ras = not transform[TraceKeys.EXTRA_INFO]["affine_lps_to_ras"]
+ mode = CoordinateTransformMode.WORLD_TO_IMAGE if mode_ == CoordinateTransformMode.IMAGE_TO_WORLD else CoordinateTransformMode.IMAGE_TO_WORLD
+ inverse_transform = CoordinateTransform(dtype=dtype, mode=mode, affine_lps_to_ras=affine_lps_to_ras)
+ # Apply inverse
+ with inverse_transform.trace_transform(False):
+ data = inverse_transform(data, affine=affine)
+
+ return data

monai/transforms/utility/dictionary.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import re
+import warnings
 from collections.abc import Callable, Hashable, Mapping
 from copy import deepcopy
 from typing import Any, Sequence, cast
@@ -62,11 +63,12 @@
  TorchVision,
  ToTensor,
  Transpose,
+ CoordinateTransform,
 )
 from monai.transforms.utils import extreme_points_to_image, get_extreme_points
 from monai.transforms.utils_pytorch_numpy_unification import concatenate
 from monai.utils import ensure_tuple, ensure_tuple_rep
-from monai.utils.enums import PostFix, TraceKeys, TransformBackends
+from monai.utils.enums import PostFix, TraceKeys, TransformBackends, CoordinateTransformMode
 from monai.utils.type_conversion import convert_to_dst_type
 
 __all__ = [
@@ -1740,6 +1742,59 @@ def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, N
  return d
 
 
+class CoordinateTransformd(MapTransform, InvertibleTransform):
+ """
+ Dictionary-based wrapper of :py:class:`monai.transforms.CoordinateTransform`.
+
+ Args:
+ keys: keys of the corresponding items to be transformed.
+ See also: monai.transforms.MapTransform
+ refer_key: the key of the reference item used for transformation.
+ dtype: The desired data type for the output.
+ mode: Specifies the direction of transformation. This should be an instance of
+ :py:class:`CoordinateTransformMode` enum, with either 'IMAGE_TO_WORLD' or 'WORLD_TO_IMAGE' as the value.
+ affine_lps_to_ras: Defaults to ``False``. Set this to ``True`` if: 1) The image is read by ITKReader,
+ and 2) The ITKReader has `affine_lps_to_ras=True`, and 3) The data is in world coordinates.
+ This ensures that the affine transformation between LPS (left-posterior-superior) and RAS
+ (right-anterior-superior) coordinate systems is correctly applied.
+ allow_missing_keys: Don't raise exception if key is missing.
+ """
+
+ def __init__(
+ self,
+ keys: KeysCollection,
+ refer_key: str,
+ dtype: DtypeLike = torch.float64,
+ mode: str = CoordinateTransformMode.IMAGE_TO_WORLD,
+ affine_lps_to_ras: bool = False,
+ allow_missing_keys: bool = False
+ ):
+ MapTransform.__init__(self, keys, allow_missing_keys)
+ self.refer_key = refer_key
+ self.converter = CoordinateTransform(dtype=dtype, mode=mode, affine_lps_to_ras=affine_lps_to_ras)
+
+ def __call__(self, data: Mapping[Hashable, torch.Tensor]):
+ d = dict(data)
+ refer_data = d[self.refer_key]
+ if isinstance(refer_data, MetaTensor):
+ affine = refer_data.affine
+ else:
+ affine = MetaTensor.get_default_affine()
+ warnings.warn("No affine found in the reference data, use default affine.")
+ for key in self.key_iterator(d):
+ coords = d[key]
+ d[key] = self.converter(coords, affine)
+ return d
+
+ def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+ d = dict(data)
+ for key in self.key_iterator(d):
+ d[key] = self.converter.inverse(d[key])
+ return d
+
+
+
+
 RandImageFilterD = RandImageFilterDict = RandImageFilterd
 ImageFilterD = ImageFilterDict = ImageFilterd
 IdentityD = IdentityDict = Identityd

monai/utils/enums.py

@@ -771,3 +771,8 @@ class OrderingTransformations(StrEnum):
  ROTATE_90 = "rotate_90"
  TRANSPOSE = "transpose"
  REFLECT = "reflect"
+
+
+class CoordinateTransformMode(StrEnum):
+ IMAGE_TO_WORLD = "image_to_world"
+ WORLD_TO_IMAGE = "world_to_image"