Remove sanitize_keypoints, it's not clear that it's strictly needed

Author: NicolasHug

torchvision/transforms/v2/_utils.py

@@ -165,19 +165,6 @@ def get_bounding_boxes(flat_inputs: list[Any]) -> tv_tensors.BoundingBoxes:
         raise ValueError("No bounding boxes were found in the sample")
 
 
-# TODOKP this is unused and un-tested
-def get_keypoints(flat_inputs: list[Any]) -> tv_tensors.KeyPoints:
-    """Returns the KeyPoints in the input.
-
-    Assumes only one ``KeyPoints`` object is present
-    """
-    generator = (inpt for inpt in flat_inputs if isinstance(inpt, tv_tensors.KeyPoints))
-    try:
-        return next(generator)
-    except StopIteration:
-        raise ValueError("No Keypoints were found in the sample.")
-
-
 def query_chw(flat_inputs: list[Any]) -> tuple[int, int, int]:
     """Return Channel, Height, and Width."""
     chws = {

torchvision/transforms/v2/functional/_misc.py

@@ -328,82 +328,6 @@ def _to_dtype_tensor_dispatch(inpt: torch.Tensor, dtype: torch.dtype, scale: boo
     return inpt.to(dtype)
 
 
-# TODOKP This is untested. Also there's no corresponding transform class
-def sanitize_keypoints(
-    keypoints: torch.Tensor, canvas_size: Optional[tuple[int, int]] = None
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Removes degenerate/invalid keypoints and returns the corresponding indexing mask.
-
-    This removes the keypoints that are outside of their corresponing image.
-
-    It is recommended to call it at the end of a pipeline, before passing the
-    input to the models. It is critical to call this transform if
-    :class:`~torchvision.transforms.v2.RandomIoUCrop` was called.
-    If you want to be extra careful, you may call it after all transforms that
-    may modify the key points but once at the end should be enough in most
-    cases.
-
-    .. note::
-
-        Points that touch the edge of the canvas are removed, unlike for :func:`sanitize_bounding_boxes`.
-        TODOKP Is this desirable? We probably want keypoints to behave the same as bboxes?
-
-    Raises:
-        ValueError: If the keypoints are not passed as a two dimensional tensor.
-
-    Args:
-        keypoints (torch.Tensor or :class:`~torchvision.tv_tensors.KeyPoints`): The Keypoints being sanitized.
-            Should be of shape ``[N, 2]``
-        canvas_size (Optional[tuple[int, int]], optional): The canvas_size of the bounding boxes
-            (size of the corresponding image/video).
-            Must be left to none if ``bounding_boxes`` is a :class:`~torchvision.tv_tensors.KeyPoints` object.
-
-    Returns:
-        out (tuple of Tensors): The subset of valid bounding boxes, and the corresponding indexing mask.
-        The mask can then be used to subset other tensors (e.g. labels) that are associated with the bounding boxes.
-    """
-    if not keypoints.ndim == 2:
-        if keypoints.ndim < 2:
-            raise ValueError("Cannot sanitize a single Keypoint")
-        raise ValueError(
-            "Cannot sanitize KeyPoints structure that are not 2D. "
-            f"Expected shape to be (N, 2), got {keypoints.shape} ({keypoints.ndim=}, not 2)"
-        )
-    if torch.jit.is_scripting() or is_pure_tensor(keypoints):
-        if canvas_size is None:
-            raise ValueError(
-                "canvas_size cannot be None if keypoints is a pure tensor. "
-                f"Got canvas_size={canvas_size}."
-                "Set that to appropriate values or pass keypoints as a tv_tensors.KeyPoints object."
-            )
-        valid = _get_sanitize_keypoints_mask(
-            keypoints,
-            canvas_size=canvas_size,
-        )
-        return keypoints[valid], valid
-
-    if not isinstance(keypoints, tv_tensors.KeyPoints):
-        raise ValueError("keypoints must be a tv_tensors.KeyPoints instance or a pure tensor.")
-
-    valid = _get_sanitize_keypoints_mask(
-        keypoints,
-        canvas_size=keypoints.canvas_size,
-    )
-    return tv_tensors.wrap(keypoints[valid], like=keypoints), valid
-
-
-# TODOKP Untested, see above
-def _get_sanitize_keypoints_mask(
-    keypoints: torch.Tensor,
-    canvas_size: tuple[int, int],
-) -> torch.Tensor:
-    image_h, image_w = canvas_size
-    x = keypoints[:, 0]
-    y = keypoints[:, 1]
-
-    return (0 < x) & (x < image_w) & (0 < y) & (y < image_h)
-
-
 def sanitize_bounding_boxes(
     bounding_boxes: torch.Tensor,
     format: Optional[tv_tensors.BoundingBoxFormat] = None,