⚡️ Speed up function convert_sv_detections_coordinates by 15%

[codeflash-ai]

📄 15% (0.15x) speedup for convert_sv_detections_coordinates in inference/core/workflows/execution_engine/v1/executor/output_constructor.py

⏱️ Runtime : 689 microseconds → 599 microseconds (best of 49 runs)

📝 Explanation and details

The optimization achieves a 15% speedup by replacing an inefficient mask creation pattern with a more performant NumPy allocation strategy.

Key Optimization:
The critical change is in the mask processing section where the original code used:

new_anchored_masks = np.array([origin_mask_base.copy() for _ in detections_copy])

This was replaced with:

new_anchored_masks = np.zeros((len(detections_copy), origin_height, origin_width), dtype=bool)
for idx, original_mask in enumerate(detections_copy.mask):
    # Direct indexing instead of copying base masks
    new_anchored_masks[idx, shift_y : shift_y + mask_h, shift_x : shift_x + mask_w] = original_mask

Why This is Faster:

1. Eliminates Python-level iteration: The original list comprehension [origin_mask_base.copy() for _ in detections_copy] creates multiple Python objects and calls copy() repeatedly
2. Direct NumPy allocation: np.zeros() creates the entire array in one efficient C-level operation
3. Removes redundant copying: Instead of copying a base mask template for each detection, we directly assign to the target positions

Performance Context:
Based on the function references, convert_sv_detections_coordinates is called in workflow output construction loops that process batches of detection data. This optimization is particularly beneficial when:

• Processing multiple detections with masks (as shown in test cases with 100-1000 detections)
• Handling nested structures containing detection objects
• Working in batch processing pipelines where the function may be called repeatedly

The line profiler shows the mask creation section dropped from 11.3% to effectively eliminated as a bottleneck, with the time redistributed across other operations. Test results confirm the optimization works well across various scales, from single detections to large batches of 1000+ detections.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 25 Passed
🌀 Generated Regression Tests	✅ 32 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_convert_sv_detections_coordinates_when_sv_detections_provided_directly	123μs	102μs	20.5%✅
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_convert_sv_detections_coordinates_when_sv_detections_provided_in_dict	129μs	110μs	17.2%✅
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_convert_sv_detections_coordinates_when_sv_detections_provided_in_list	133μs	115μs	15.3%✅
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_convert_sv_detections_coordinates_when_sv_detections_provided_in_nested_dict	125μs	108μs	16.0%✅
workflows/unit_tests/execution_engine/executor/test_output_constructor.py::test_convert_sv_detections_coordinates_when_sv_detections_provided_in_nested_list	129μs	110μs	17.0%✅

🌀 Generated Regression Tests and Runtime

from copy import deepcopy

import numpy as np

# imports
import pytest  # used for our unit tests
from inference.core.workflows.execution_engine.v1.executor.output_constructor import (
    convert_sv_detections_coordinates,
)


# Minimal sv.Detections mock
class Detections:
    def __init__(self, xyxy=None, mask=None, data=None):
        self.xyxy = xyxy if xyxy is not None else np.zeros((0, 4))
        self.mask = mask
        self.data = data if data is not None else {}

    def __len__(self):
        return len(self.xyxy)

    def __getitem__(self, key):
        return self.data[key]

    def __setitem__(self, key, value):
        self.data[key] = value

    def copy(self):
        # Deep copy for test isolation
        new = Detections(
            xyxy=self.xyxy.copy(),
            mask=self.mask.copy() if self.mask is not None else None,
            data={
                k: v.copy() if hasattr(v, "copy") else v for k, v in self.data.items()
            },
        )
        return new


# --- Constants used in the function ---
IMAGE_DIMENSIONS_KEY = "image_dimensions"
KEYPOINTS_XY_KEY_IN_SV_DETECTIONS = "keypoints_xy"
PARENT_COORDINATES_KEY = "parent_coordinates"
PARENT_DIMENSIONS_KEY = "parent_dimensions"
PARENT_ID_KEY = "parent_id"
ROOT_PARENT_COORDINATES_KEY = "root_parent_coordinates"
ROOT_PARENT_DIMENSIONS_KEY = "root_parent_dimensions"
ROOT_PARENT_ID_KEY = "root_parent_id"
SCALING_RELATIVE_TO_PARENT_KEY = "scaling_relative_to_parent"
SCALING_RELATIVE_TO_ROOT_PARENT_KEY = "scaling_relative_to_root_parent"
from inference.core.workflows.execution_engine.v1.executor.output_constructor import (
    convert_sv_detections_coordinates,
)

# --- Unit tests ---

# ----------- BASIC TEST CASES -----------


def make_basic_detections():
    # Create a simple Detections object with required keys
    xyxy = np.array([[10, 20, 30, 40]])
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[5, 7]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[100, 200]]),
        ROOT_PARENT_ID_KEY: np.array([42]),
    }
    return Detections(xyxy=xyxy, data=data)


def test_basic_single_detection_shift():
    # Test that coordinates are shifted correctly
    det = make_basic_detections()
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 1.12μs -> 1.23μs (8.80% slower)
    # The xyxy should be shifted by [5,7,5,7]
    expected = np.array([[10 + 5, 20 + 7, 30 + 5, 40 + 7]])
    # Parent and root parent keys should be present
    for k in [
        PARENT_ID_KEY,
        PARENT_COORDINATES_KEY,
        PARENT_DIMENSIONS_KEY,
        ROOT_PARENT_ID_KEY,
        ROOT_PARENT_COORDINATES_KEY,
        ROOT_PARENT_DIMENSIONS_KEY,
    ]:
        pass


def test_basic_dict_input():
    # Test that dicts containing Detections are handled recursively
    det = make_basic_detections()
    input_dict = {"a": det, "b": 123}
    codeflash_output = convert_sv_detections_coordinates(input_dict)
    result = codeflash_output  # 2.37μs -> 2.54μs (6.84% slower)
    # Check shifting
    expected = np.array([[15, 27, 35, 47]])


def test_basic_list_input():
    # Test that lists containing Detections are handled recursively
    det1 = make_basic_detections()
    det2 = make_basic_detections()
    det2.xyxy = np.array([[1, 2, 3, 4]])
    codeflash_output = convert_sv_detections_coordinates([det1, det2, "x"])
    result = codeflash_output  # 2.14μs -> 2.33μs (8.27% slower)


def test_basic_non_detection_input():
    # Test that non-detection, non-list, non-dict input is returned unchanged
    codeflash_output = convert_sv_detections_coordinates(
        42
    )  # 674ns -> 717ns (6.00% slower)
    codeflash_output = convert_sv_detections_coordinates(
        "hello"
    )  # 349ns -> 354ns (1.41% slower)


# ----------- EDGE TEST CASES -----------


def test_empty_detections():
    # Detections with no elements should be returned unchanged
    det = Detections()
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 648ns -> 699ns (7.30% slower)


def test_missing_required_keys():
    # If required keys are missing, detections should be returned unchanged
    xyxy = np.array([[1, 2, 3, 4]])
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[1, 2]]),
        # ROOT_PARENT_DIMENSIONS_KEY missing
        ROOT_PARENT_ID_KEY: np.array([99]),
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 678ns -> 724ns (6.35% slower)
    # Should not add parent keys
    for k in [PARENT_ID_KEY, PARENT_COORDINATES_KEY, PARENT_DIMENSIONS_KEY]:
        pass


def test_scaling_applied():
    # If SCALING_RELATIVE_TO_ROOT_PARENT_KEY is present, scale should be applied
    xyxy = np.array([[10, 20, 30, 40]])
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[0, 0]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[50, 100]]),
        ROOT_PARENT_ID_KEY: np.array([1]),
        SCALING_RELATIVE_TO_ROOT_PARENT_KEY: np.array([2.0]),
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 662ns -> 696ns (4.89% slower)
    # Coordinates should be divided by scale then shifted (shift is zero here)
    expected = np.array([[5, 10, 15, 20]])


def test_keypoints_shifted():
    # Test that keypoints are shifted
    xyxy = np.array([[1, 2, 3, 4]])
    keypoints = [np.array([10, 20])]
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[2, 3]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[10, 20]]),
        ROOT_PARENT_ID_KEY: np.array([7]),
        KEYPOINTS_XY_KEY_IN_SV_DETECTIONS: keypoints,
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 633ns -> 751ns (15.7% slower)


def test_nested_dict_and_list():
    # Test recursive handling of dicts and lists
    det = make_basic_detections()
    nested = {"x": [det, {"y": det}], "z": 5}
    codeflash_output = convert_sv_detections_coordinates(nested)
    result = codeflash_output  # 3.73μs -> 4.11μs (9.16% slower)


def test_multiple_detections():
    # Test that multiple detections are all shifted correctly
    xyxy = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[2, 3]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[10, 20]]),
        ROOT_PARENT_ID_KEY: np.array([7]),
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 662ns -> 747ns (11.4% slower)
    expected = np.array([[1 + 2, 2 + 3, 3 + 2, 4 + 3], [5 + 2, 6 + 3, 7 + 2, 8 + 3]])


# ----------- LARGE SCALE TEST CASES -----------


def test_large_scale_detections():
    # Test performance and correctness with a large number of detections
    n = 500
    xyxy = np.ones((n, 4)) * 10
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[3, 4]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[100, 200]]),
        ROOT_PARENT_ID_KEY: np.array([101]),
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 690ns -> 756ns (8.73% slower)
    expected = np.ones((n, 4)) * 10 + np.array([3, 4, 3, 4])
    # Check that all parent keys are present and correct length
    for k in [
        PARENT_ID_KEY,
        PARENT_COORDINATES_KEY,
        PARENT_DIMENSIONS_KEY,
        ROOT_PARENT_ID_KEY,
        ROOT_PARENT_COORDINATES_KEY,
        ROOT_PARENT_DIMENSIONS_KEY,
    ]:
        pass


def test_large_scale_nested_structure():
    # Test large nested dict/list structure
    n = 200
    xyxy = np.ones((n, 4)) * 5
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[1, 2]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[50, 60]]),
        ROOT_PARENT_ID_KEY: np.array([11]),
    }
    det = Detections(xyxy=xyxy, data=data)
    input_data = [{"a": det} for _ in range(10)]
    codeflash_output = convert_sv_detections_coordinates(input_data)
    result = codeflash_output  # 6.71μs -> 7.21μs (6.92% slower)
    for item in result:
        expected = np.ones((n, 4)) * 5 + np.array([1, 2, 1, 2])


def test_large_scale_keypoints():
    # Test large number of keypoints
    n = 300
    xyxy = np.ones((n, 4)) * 2
    keypoints = [np.array([5, 6]) for _ in range(n)]
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[2, 3]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[10, 20]]),
        ROOT_PARENT_ID_KEY: np.array([7]),
        KEYPOINTS_XY_KEY_IN_SV_DETECTIONS: keypoints,
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 716ns -> 810ns (11.6% slower)
    for kp in result[KEYPOINTS_XY_KEY_IN_SV_DETECTIONS]:
        pass


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import logging

# Patch supervision module in function scope
import types
from copy import deepcopy

import numpy as np

# imports
import pytest
from inference.core.workflows.execution_engine.v1.executor.output_constructor import (
    convert_sv_detections_coordinates,
)

# Constants used in the code
IMAGE_DIMENSIONS_KEY = "image_dimensions"
KEYPOINTS_XY_KEY_IN_SV_DETECTIONS = "keypoints_xy"
PARENT_COORDINATES_KEY = "parent_coordinates"
PARENT_DIMENSIONS_KEY = "parent_dimensions"
PARENT_ID_KEY = "parent_id"
POLYGON_KEY_IN_SV_DETECTIONS = "polygon"
ROOT_PARENT_COORDINATES_KEY = "root_parent_coordinates"
ROOT_PARENT_DIMENSIONS_KEY = "root_parent_dimensions"
ROOT_PARENT_ID_KEY = "root_parent_id"
SCALING_RELATIVE_TO_ROOT_PARENT_KEY = "scaling_relative_to_root_parent"


# Minimal mock for sv.Detections
class Detections:
    def __init__(
        self,
        xyxy=None,
        mask=None,
        data=None,
    ):
        self.xyxy = np.array(xyxy) if xyxy is not None else np.zeros((0, 4))
        self.mask = mask
        self.data = data if data is not None else {}
        self._len = self.xyxy.shape[0]
        # For convenience, allow dict-like access for data fields

    def __getitem__(self, key):
        return self.data[key]

    def __setitem__(self, key, value):
        self.data[key] = value

    def __len__(self):
        return self.xyxy.shape[0]

    # For deepcopy
    def __deepcopy__(self, memo):
        import copy

        return Detections(
            xyxy=copy.deepcopy(self.xyxy, memo),
            mask=copy.deepcopy(self.mask, memo),
            data=copy.deepcopy(self.data, memo),
        )


from inference.core.workflows.execution_engine.v1.executor.output_constructor import (
    convert_sv_detections_coordinates,
)

# --- Unit tests ---

# 1. BASIC TEST CASES


def make_basic_detections():
    # A single detection, with all required root fields
    xyxy = [[10, 20, 30, 40]]
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[5, 7]]),  # shift_x=5, shift_y=7
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[100, 200]]),
        ROOT_PARENT_ID_KEY: np.array([123]),
    }
    return Detections(xyxy=xyxy, data=data)


def test_basic_single_detection_shift():
    # Test that coordinates are shifted correctly
    det = make_basic_detections()
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 1.10μs -> 1.09μs (1.10% faster)
    # The xyxy should be shifted by (5,7,5,7)
    expected = np.array([[15, 27, 35, 47]])
    # The output should still have the required root keys
    for key in [
        ROOT_PARENT_COORDINATES_KEY,
        ROOT_PARENT_DIMENSIONS_KEY,
        ROOT_PARENT_ID_KEY,
    ]:
        pass
    # The parent keys should also be present
    for key in [PARENT_COORDINATES_KEY, PARENT_DIMENSIONS_KEY, PARENT_ID_KEY]:
        pass


def test_basic_list_of_detections():
    # Test a list of Detections is recursively handled
    det1 = make_basic_detections()
    det2 = make_basic_detections()
    det2.xyxy = np.array([[1, 2, 3, 4]])
    codeflash_output = convert_sv_detections_coordinates([det1, det2])
    result = codeflash_output  # 1.98μs -> 2.27μs (12.7% slower)


def test_basic_dict_of_detections():
    # Test a dict of Detections is recursively handled
    det = make_basic_detections()
    d = {"a": det, "b": 42}
    codeflash_output = convert_sv_detections_coordinates(d)
    result = codeflash_output  # 2.22μs -> 2.44μs (9.01% slower)


def test_basic_non_detection_passthrough():
    # Non-detections and non-collections are passed through
    codeflash_output = convert_sv_detections_coordinates(
        123
    )  # 661ns -> 739ns (10.6% slower)
    codeflash_output = convert_sv_detections_coordinates(
        "abc"
    )  # 344ns -> 366ns (6.01% slower)
    codeflash_output = convert_sv_detections_coordinates(
        None
    )  # 272ns -> 262ns (3.82% faster)


# 2. EDGE TEST CASES


def test_empty_detections():
    # An empty Detections (no boxes)
    det = Detections(xyxy=[])
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 664ns -> 698ns (4.87% slower)


def test_missing_root_keys():
    # Detections missing required root keys should be returned unchanged
    xyxy = [[1, 2, 3, 4]]
    det = Detections(xyxy=xyxy, data={})
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 649ns -> 710ns (8.59% slower)
    # Should not add parent/root keys
    for key in [
        ROOT_PARENT_COORDINATES_KEY,
        ROOT_PARENT_DIMENSIONS_KEY,
        ROOT_PARENT_ID_KEY,
    ]:
        pass


def test_nested_collections():
    # Nested dicts/lists of Detections
    det = make_basic_detections()
    nested = {"foo": [det, {"bar": det}], "baz": 99}
    codeflash_output = convert_sv_detections_coordinates(nested)
    result = codeflash_output  # 3.77μs -> 4.21μs (10.4% slower)


def test_keypoints_shifted():
    # Detections with keypoints
    xyxy = [[0, 0, 10, 10]]
    keypoints = [np.array([1.0, 2.0])]
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[3, 4]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[20, 20]]),
        ROOT_PARENT_ID_KEY: np.array([5]),
        KEYPOINTS_XY_KEY_IN_SV_DETECTIONS: [np.array([1.0, 2.0])],
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 664ns -> 733ns (9.41% slower)


def test_mask_shifted():
    # Detections with mask
    xyxy = [[0, 0, 2, 2]]
    mask = np.zeros((1, 2, 2), dtype=bool)
    mask[0, 0, 0] = True
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[1, 1]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[4, 4]]),
        ROOT_PARENT_ID_KEY: np.array([1]),
    }
    det = Detections(xyxy=xyxy, mask=mask, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 715ns -> 751ns (4.79% slower)
    # The mask should be shifted by (1,1) in the output mask
    expected_mask = np.zeros((1, 4, 4), dtype=bool)
    expected_mask[0, 1, 1] = True


def test_scaling_relative_to_root_parent():
    # If scaling_relative_to_root_parent is present, the detection is rescaled
    xyxy = [[10, 10, 20, 20]]
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[0, 0]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[40, 40]]),
        ROOT_PARENT_ID_KEY: np.array([1]),
        SCALING_RELATIVE_TO_ROOT_PARENT_KEY: np.array(
            [2.0]
        ),  # scale=2.0, so unscale by 0.5
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 676ns -> 732ns (7.65% slower)


def test_polygon_scaling():
    # Detections with polygon data, check scaling is applied
    xyxy = [[0, 0, 10, 10]]
    polygon = np.array([[1, 1], [2, 2]])
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[0, 0]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[10, 10]]),
        ROOT_PARENT_ID_KEY: np.array([1]),
        POLYGON_KEY_IN_SV_DETECTIONS: polygon,
        SCALING_RELATIVE_TO_ROOT_PARENT_KEY: np.array([2.0]),
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 679ns -> 682ns (0.440% slower)


def test_nonstandard_types_in_dict():
    # Dict with non-detection, non-collection values
    d = {"foo": 1.23, "bar": None, "baz": "hello"}
    codeflash_output = convert_sv_detections_coordinates(d)
    result = codeflash_output  # 2.29μs -> 2.51μs (8.72% slower)


# 3. LARGE SCALE TEST CASES


def test_large_number_of_detections():
    # Many detections (up to 1000)
    n = 1000
    xyxy = np.tile([1, 2, 3, 4], (n, 1))
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[10, 20]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[100, 100]]),
        ROOT_PARENT_ID_KEY: np.array([7]),
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 696ns -> 825ns (15.6% slower)
    # All boxes should be shifted by (10,20,10,20)
    expected = np.tile([11, 22, 13, 24], (n, 1))
    # Check that all parent/root keys are present
    for key in [
        ROOT_PARENT_COORDINATES_KEY,
        ROOT_PARENT_DIMENSIONS_KEY,
        ROOT_PARENT_ID_KEY,
        PARENT_COORDINATES_KEY,
        PARENT_DIMENSIONS_KEY,
        PARENT_ID_KEY,
    ]:
        pass


def test_large_nested_structure():
    # Deeply nested structure with Detections
    n = 20
    xyxy = np.tile([5, 5, 10, 10], (n, 1))
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[2, 3]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[50, 50]]),
        ROOT_PARENT_ID_KEY: np.array([99]),
    }
    det = Detections(xyxy=xyxy, data=data)
    nested = {"a": [det for _ in range(10)], "b": {"c": [det for _ in range(5)]}}
    codeflash_output = convert_sv_detections_coordinates(nested)
    result = codeflash_output  # 5.70μs -> 6.12μs (6.90% slower)
    # Check that all Detections in the nested structure are converted
    for d in result["a"]:
        pass
    for d in result["b"]["c"]:
        pass


def test_large_detections_with_keypoints():
    # Detections with many keypoints
    n = 500
    xyxy = np.tile([0, 0, 10, 10], (n, 1))
    keypoints = [np.array([1.0, 2.0]) for _ in range(n)]
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[1, 2]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[20, 20]]),
        ROOT_PARENT_ID_KEY: np.array([5]),
        KEYPOINTS_XY_KEY_IN_SV_DETECTIONS: keypoints,
    }
    det = Detections(xyxy=xyxy, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 688ns -> 789ns (12.8% slower)
    # All keypoints should be shifted by (1,2)
    for kp in result[KEYPOINTS_XY_KEY_IN_SV_DETECTIONS]:
        pass


def test_large_detections_with_masks():
    # Detections with large masks
    n = 100
    xyxy = np.tile([0, 0, 5, 5], (n, 1))
    mask = np.zeros((n, 5, 5), dtype=bool)
    for i in range(n):
        mask[i, 0, 0] = True
    data = {
        ROOT_PARENT_COORDINATES_KEY: np.array([[2, 2]]),
        ROOT_PARENT_DIMENSIONS_KEY: np.array([[10, 10]]),
        ROOT_PARENT_ID_KEY: np.array([1]),
    }
    det = Detections(xyxy=xyxy, mask=mask, data=data)
    codeflash_output = convert_sv_detections_coordinates(det)
    result = codeflash_output  # 742ns -> 745ns (0.403% slower)
    # Each mask should have its True value shifted by (2,2)
    for i in range(n):
        pass


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-convert_sv_detections_coordinates-miqihq1o and push.