Method __call__

monai/transforms/post/array.py:806–877

Args: points: landmark coordinates as ndarray/Tensor with shape (N, D), ordered as (Y, X) for 2D or (Z, Y, X) for 3D, where N is the number of landmarks and D is the spatial dimensionality. spatial_shape: spatial size as a sequence. If

(self, points: NdarrayOrTensor, spatial_shape: Sequence[int] | None = None)

        self.spatial_shape = None if spatial_shape is None else tuple(int(s) for s in spatial_shape)

    def __call__(self, points: NdarrayOrTensor, spatial_shape: Sequence[int] | None = None) -> NdarrayOrTensor:
        """
        Args:
            points: landmark coordinates as ndarray/Tensor with shape (N, D),
                ordered as (Y, X) for 2D or (Z, Y, X) for 3D, where N is the number
                of landmarks and D is the spatial dimensionality.
            spatial_shape: spatial size as a sequence. If None, uses the value provided at construction.

        Returns:
            Heatmaps with shape (N, *spatial), one channel per landmark.

        Raises:
            ValueError: if points shape/dimension or spatial_shape is invalid.
        """
        original_points = points
        points_t = convert_to_tensor(points, dtype=torch.float32, track_meta=False)

        if points_t.ndim != 2:
            raise ValueError(
                f"Argument `points` must be a 2D array with shape (num_points, spatial_dims), got shape {points_t.shape}."
            )

        if points_t.shape[-1] not in (2, 3):
            raise ValueError("GenerateHeatmap only supports 2D or 3D landmarks.")

        device = points_t.device
        num_points, spatial_dims = points_t.shape

        target_shape = self._resolve_spatial_shape(spatial_shape, spatial_dims)
        sigma = self._resolve_sigma(spatial_dims)

        # Create sparse image with impulses at landmark locations
        heatmap = torch.zeros((num_points, *target_shape), dtype=self.torch_dtype, device=device)
        bounds_t = torch.as_tensor(target_shape, device=device, dtype=points_t.dtype)

        for idx, center in enumerate(points_t):
            if not torch.isfinite(center).all():
                continue
            if not ((center >= 0).all() and (center < bounds_t).all()):
                continue
            # Round to nearest integer for impulse placement, then clamp to valid index range
            center_int = center.round().long()
            # Clamp indices to [0, size-1] to avoid out-of-bounds (e.g., 9.7 rounds to 10 in size-10 array)
            bounds_max = (bounds_t - 1).long()
            center_int = torch.minimum(torch.maximum(center_int, torch.zeros_like(center_int)), bounds_max)
            # Place impulse (use maximum in case of overlapping landmarks)
            current_val = heatmap[idx][tuple(center_int)]
            heatmap[idx][tuple(center_int)] = torch.maximum(
                current_val, torch.tensor(1.0, dtype=self.torch_dtype, device=device)
            )

        # Apply Gaussian blur using GaussianFilter
        # Reshape to (num_points, 1, *spatial) for per-channel filtering
        heatmap_input = heatmap.unsqueeze(1)  # Add channel dimension

        gaussian_filter = GaussianFilter(
            spatial_dims=spatial_dims, sigma=sigma, truncated=self.truncated, approx="erf", requires_grad=False
        ).to(device=device, dtype=self.torch_dtype)