Crop

Bases: SpatialTransform

Remove a border of voxels from each side of the volume.

Parameters:

Name	Type	Description	Default
`cropping`	`CroppingParam`	Tuple \((i_\text{ini}, i_\text{fin}, j_\text{ini}, j_\text{fin}, k_\text{ini}, k_\text{fin})\) defining the number of voxels cropped from the edges of each axis. If the initial shape of the image is \(I \times J \times K\), the final shape will be \((I - i_\text{ini} - i_\text{fin}) \times (J - j_\text{ini} - j_\text{fin}) \times (K - k_\text{ini} - k_\text{fin})\). If only three values \((i, j, k)\) are provided, then \(i_\text{ini} = i_\text{fin} = i\), \(j_\text{ini} = j_\text{fin} = j\) and \(k_\text{ini} = k_\text{fin} = k\). If only one value \(n\) is provided, then \(i_\text{ini} = i_\text{fin} = j_\text{ini} = j_\text{fin} = k_\text{ini} = k_\text{fin} = n\).	required
`**kwargs`	`Any`	See `Transform` for additional keyword arguments.	`{}`

Examples:

>>> import torchio as tio
>>> transform = tio.Crop(cropping=10)
>>> # Equivalent to
>>> transform = tio.Crop(cropping=(10, 10, 10))
>>> # Equivalent to
>>> transform = tio.Crop(cropping=(10, 10, 10, 10, 10, 10))

Source code in src/torchio/transforms/spatial/crop.py

class Crop(SpatialTransform):
    r"""Remove a border of voxels from each side of the volume.

    Args:
        cropping: Tuple
            $(i_\text{ini}, i_\text{fin}, j_\text{ini}, j_\text{fin},
            k_\text{ini}, k_\text{fin})$
            defining the number of voxels cropped from the edges of
            each axis. If the initial shape of the image is
            $I \times J \times K$, the final shape will be
            $(I - i_\text{ini} - i_\text{fin}) \times
            (J - j_\text{ini} - j_\text{fin}) \times
            (K - k_\text{ini} - k_\text{fin})$.
            If only three values $(i, j, k)$ are provided, then
            $i_\text{ini} = i_\text{fin} = i$,
            $j_\text{ini} = j_\text{fin} = j$ and
            $k_\text{ini} = k_\text{fin} = k$.
            If only one value $n$ is provided, then
            $i_\text{ini} = i_\text{fin} = j_\text{ini} =
            j_\text{fin} = k_\text{ini} = k_\text{fin} = n$.
        **kwargs: See [`Transform`][torchio.Transform] for additional
            keyword arguments.

    Examples:
        >>> import torchio as tio
        >>> transform = tio.Crop(cropping=10)
        >>> # Equivalent to
        >>> transform = tio.Crop(cropping=(10, 10, 10))
        >>> # Equivalent to
        >>> transform = tio.Crop(cropping=(10, 10, 10, 10, 10, 10))
    """

    def __init__(
        self,
        *,
        cropping: CroppingParam,
        **kwargs: Any,
    ) -> None:
        super().__init__(**kwargs)
        self.cropping = _parse_cropping(cropping)

    def make_params(self, batch: SubjectsBatch) -> dict[str, Any]:
        return {"cropping": self.cropping}

    def apply_transform(
        self,
        batch: SubjectsBatch,
        params: dict[str, Any],
    ) -> SubjectsBatch:
        i0, i1, j0, j1, k0, k1 = params["cropping"]
        for _name, img_batch in self._get_images(batch).items():
            data = img_batch.data
            # data shape: (B, C, I, J, K)
            si = data.shape[-3]
            sj = data.shape[-2]
            sk = data.shape[-1]
            img_batch.data = data[
                ...,
                i0 : si - i1 or None,
                j0 : sj - j1 or None,
                k0 : sk - k1 or None,
            ]
            # Update each affine's origin
            for affine in img_batch.affines:
                origin_shift = affine.data[:3, :3] @ affine.data.new_tensor(
                    [float(i0), float(j0), float(k0)],
                )
                affine._matrix[:3, 3] += origin_shift
        return batch

    @property
    def invertible(self) -> bool:
        return True

    def inverse(self, params: dict[str, Any]) -> Any:
        """Inverse of Crop is Pad."""
        from .pad import Pad

        return Pad(padding=params["cropping"], copy=False)

`forward(data)`

forward(data: Subject) -> Subject

forward(data: Image) -> Image

forward(data: Tensor) -> Tensor

forward(data: np.ndarray) -> np.ndarray

forward(data: sitk.Image) -> sitk.Image

forward(data: nib.Nifti1Image) -> nib.Nifti1Image

forward(data: dict) -> dict

forward(data: ImagesBatch) -> ImagesBatch

forward(data: SubjectsBatch) -> SubjectsBatch

Apply the transform.

The output type always matches the input type.

Parameters:

Name	Type	Description	Default
`data`	`Any`	Input data to transform.	required

Source code in src/torchio/transforms/transform.py

def forward(self, data: Any) -> Any:
    """Apply the transform.

    The output type always matches the input type.

    Args:
        data: Input data to transform.
    """
    if self.copy:
        data = _copy.deepcopy(data)
    batch, unwrap = self._wrap(data)
    if torch.rand(1).item() > self.p:
        return unwrap(batch)
    params = self.make_params(batch)
    batch = self.apply_transform(batch, params)
    # Record history on the batch
    trace = AppliedTransform(name=type(self).__name__, params=params)
    if not hasattr(batch, "applied_transforms"):
        batch.applied_transforms = []
    batch.applied_transforms.append(trace)
    result = unwrap(batch)
    # Propagate history to outputs that can carry it
    if (
        hasattr(batch, "applied_transforms")
        and not isinstance(result, (SubjectsBatch, Tensor, np.ndarray))
        and not isinstance(result, dict)
    ):
        with contextlib.suppress(AttributeError):
            result.applied_transforms = list(batch.applied_transforms)
    return result

`to_hydra()`

Export as a Hydra-compatible config dict.

Returns a dict with _target_ set to the fully qualified class name and only non-default field values included.

Returns:

Type	Description
`dict[str, Any]`	Dict suitable for `hydra.utils.instantiate()`.

Source code in src/torchio/transforms/transform.py

def to_hydra(self) -> dict[str, Any]:
    """Export as a Hydra-compatible config dict.

    Returns a dict with `_target_` set to the fully qualified
    class name and only non-default field values included.

    Returns:
        Dict suitable for `hydra.utils.instantiate()`.
    """
    from .parameter_range import _ParameterRange

    cls = type(self)
    target = f"torchio.{cls.__qualname__}"
    cfg: dict[str, Any] = {"_target_": target}

    for name, default in _collect_init_params(cls).items():
        value = getattr(self, name, default)
        if isinstance(value, _ParameterRange):
            if value._original == default:
                continue
            value = _hydra_value(value._original)
        elif value == default:
            continue
        else:
            value = _hydra_value(value)
        cfg[name] = value
    return cfg

`inverse(params)`

Inverse of Crop is Pad.

Source code in src/torchio/transforms/spatial/crop.py

def inverse(self, params: dict[str, Any]) -> Any:
    """Inverse of Crop is Pad."""
    from .pad import Pad

    return Pad(padding=params["cropping"], copy=False)