⚡️ Speed up function get_bbox_size_category by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for get_bbox_size_category in supervision/metrics/utils/object_size.py

⏱️ Runtime : 357 microseconds → 320 microseconds (best of 43 runs)

📝 Explanation and details

Here is an optimized version of the provided Python program.

Explanation of Optimizations

1. Replaced len(xyxy.shape) Check with xyxy.ndim:
   The ndim property is faster for checking the number of dimensions compared to using len(xyxy.shape).

2. Replaced np.full with np.empty for Result Initialization.
   Using np.empty avoids unnecessary initialization and saves memory operations. The subsequent lines will fill the array completely.

3. Removed Redundant Assignment.
   Eliminated the default assignment of ObjectSizeCategory.ANY.value for the result array since all its elements will be overwritten in subsequent assignments.

These optimizations reduce unnecessary checks and memory operations, enhancing the overall performance of the function.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from __future__ import annotations

from enum import Enum

import numpy as np
import numpy.typing as npt
# imports
import pytest  # used for our unit tests
from supervision.metrics.utils.object_size import get_bbox_size_category


class ObjectSizeCategory(Enum):
    ANY = -1
    SMALL = 1
    MEDIUM = 2
    LARGE = 3

SIZE_THRESHOLDS = (32**2, 96**2)
from supervision.metrics.utils.object_size import get_bbox_size_category

# unit tests

def test_single_bounding_box():
    # Single bounding box, small size
    bbox = np.array([[0, 0, 10, 10]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)

def test_multiple_bounding_boxes():
    # Multiple bounding boxes with different sizes
    bbox = np.array([[0, 0, 10, 10], [0, 0, 50, 50]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)
    expected = np.array([ObjectSizeCategory.SMALL.value, ObjectSizeCategory.MEDIUM.value])

def test_zero_area_bounding_box():
    # Bounding box with zero area
    bbox = np.array([[0, 0, 0, 10]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)

def test_negative_dimensions():
    # Bounding box with negative dimensions
    bbox = np.array([[10, 10, 0, 0]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)

def test_invalid_shape_1d_array():
    # 1D array input
    bbox = np.array([0, 0, 10, 10], dtype=np.float32)
    with pytest.raises(ValueError):
        get_bbox_size_category(bbox)

def test_invalid_shape_incorrect_columns():
    # Incorrect number of columns
    bbox = np.array([[0, 0, 10]], dtype=np.float32)
    with pytest.raises(ValueError):
        get_bbox_size_category(bbox)

def test_large_number_of_bounding_boxes():
    # Large number of bounding boxes
    bbox = np.random.rand(10000, 4).astype(np.float32) * 100
    codeflash_output = get_bbox_size_category(bbox)

def test_boundary_conditions():
    # Bounding boxes exactly at thresholds
    bbox = np.array([[0, 0, 32, 32], [0, 0, 96, 96]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)
    expected = np.array([ObjectSizeCategory.SMALL.value, ObjectSizeCategory.MEDIUM.value])

def test_bounding_boxes_just_below_and_above_thresholds():
    # Bounding boxes just below and above thresholds
    bbox = np.array([[0, 0, 31.9, 31.9], [0, 0, 32.1, 32.1], [0, 0, 95.9, 95.9], [0, 0, 96.1, 96.1]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)
    expected = np.array([ObjectSizeCategory.SMALL.value, ObjectSizeCategory.MEDIUM.value, ObjectSizeCategory.MEDIUM.value, ObjectSizeCategory.LARGE.value])

def test_mixed_size_categories():
    # Bounding boxes of different sizes
    bbox = np.array([[0, 0, 10, 10], [0, 0, 50, 50], [0, 0, 100, 100]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)
    expected = np.array([ObjectSizeCategory.SMALL.value, ObjectSizeCategory.MEDIUM.value, ObjectSizeCategory.LARGE.value])

def test_floating_point_precision():
    # Bounding boxes with high precision coordinates
    bbox = np.array([[0.000001, 0.000001, 32.000001, 32.000001], [0.000001, 0.000001, 95.999999, 95.999999]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)
    expected = np.array([ObjectSizeCategory.MEDIUM.value, ObjectSizeCategory.MEDIUM.value])

def test_min_max_float_values():
    # Bounding boxes with min and max float values
    bbox = np.array([[np.finfo(np.float32).min, np.finfo(np.float32).min, np.finfo(np.float32).max, np.finfo(np.float32).max]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)

def test_non_rectangular_inputs():
    # Bounding boxes with non-standard shapes
    bbox = np.array([[0, 0, 10, 20], [0, 0, 20, 10]], dtype=np.float32)
    codeflash_output = get_bbox_size_category(bbox)
    expected = np.array([ObjectSizeCategory.SMALL.value, ObjectSizeCategory.SMALL.value])

def test_empty_input():
    # No bounding boxes
    bbox = np.array([], dtype=np.float32).reshape(0, 4)
    codeflash_output = get_bbox_size_category(bbox)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

from enum import Enum

import numpy as np
import numpy.typing as npt
# imports
import pytest  # used for our unit tests
from supervision.metrics.utils.object_size import get_bbox_size_category


class ObjectSizeCategory(Enum):
    ANY = -1
    SMALL = 1
    MEDIUM = 2
    LARGE = 3

SIZE_THRESHOLDS = (32**2, 96**2)
from supervision.metrics.utils.object_size import get_bbox_size_category

# unit tests

def test_single_small_bbox():
    # Single small bounding box
    input_data = np.array([[0, 0, 10, 10]], dtype=np.float32)
    expected_output = np.array([1], dtype=np.int_)

def test_single_medium_bbox():
    # Single medium bounding box
    input_data = np.array([[0, 0, 50, 50]], dtype=np.float32)
    expected_output = np.array([2], dtype=np.int_)

def test_single_large_bbox():
    # Single large bounding box
    input_data = np.array([[0, 0, 100, 100]], dtype=np.float32)
    expected_output = np.array([3], dtype=np.int_)

def test_mixed_sizes():
    # Mixed sizes of bounding boxes
    input_data = np.array([[0, 0, 10, 10], [0, 0, 50, 50], [0, 0, 100, 100]], dtype=np.float32)
    expected_output = np.array([1, 2, 3], dtype=np.int_)

def test_zero_area_bbox():
    # Bounding box with zero area
    input_data = np.array([[0, 0, 0, 0]], dtype=np.float32)
    expected_output = np.array([1], dtype=np.int_)

def test_threshold_small_medium():
    # Bounding box on the threshold of small and medium
    input_data = np.array([[0, 0, 32, 32]], dtype=np.float32)
    expected_output = np.array([1], dtype=np.int_)

def test_threshold_medium_large():
    # Bounding box on the threshold of medium and large
    input_data = np.array([[0, 0, 96, 96]], dtype=np.float32)
    expected_output = np.array([2], dtype=np.int_)

def test_incorrect_shape_1d():
    # Incorrect shape (1D array)
    input_data = np.array([0, 0, 10, 10], dtype=np.float32)
    with pytest.raises(ValueError):
        get_bbox_size_category(input_data)

def test_incorrect_shape_3d():
    # Incorrect shape (3D array)
    input_data = np.array([[[0, 0, 10, 10]]], dtype=np.float32)
    with pytest.raises(ValueError):
        get_bbox_size_category(input_data)

def test_incorrect_inner_dimension():
    # Incorrect inner dimension
    input_data = np.array([[0, 0, 10]], dtype=np.float32)
    with pytest.raises(ValueError):
        get_bbox_size_category(input_data)

def test_large_number_small_bboxes():
    # Large number of small bounding boxes
    input_data = np.array([[0, 0, 10, 10]] * 1000, dtype=np.float32)
    expected_output = np.array([1] * 1000, dtype=np.int_)

def test_large_number_mixed_bboxes():
    # Large number of mixed bounding boxes
    input_data = np.array([[0, 0, 10, 10], [0, 0, 50, 50], [0, 0, 100, 100]] * 1000, dtype=np.float32)
    expected_output = np.array([1, 2, 3] * 1000, dtype=np.int_)

def test_negative_coordinates():
    # Bounding box with negative coordinates
    input_data = np.array([[-10, -10, 10, 10]], dtype=np.float32)
    expected_output = np.array([2], dtype=np.int_)

def test_floating_point_precision():
    # Bounding box with floating point precision
    input_data = np.array([[0.5, 0.5, 32.5, 32.5]], dtype=np.float32)
    expected_output = np.array([2], dtype=np.int_)

def test_extremely_large_input():
    # Extremely large input
    input_data = np.array([[0, 0, 10, 10]] * 1000000, dtype=np.float32)
    expected_output = np.array([1] * 1000000, dtype=np.int_)

def test_exact_threshold():
    # Bounding box at the exact threshold
    input_data = np.array([[0, 0, 32, 32], [0, 0, 96, 96]], dtype=np.float32)
    expected_output = np.array([1, 2], dtype=np.int_)

def test_varied_sizes():
    # Varied bounding box sizes
    input_data = np.array([[0, 0, 10, 10], [0, 0, 32, 32], [0, 0, 50, 50], [0, 0, 96, 96], [0, 0, 150, 150]], dtype=np.float32)
    expected_output = np.array([1, 1, 2, 2, 3], dtype=np.int_)

def test_comprehensive():
    # Comprehensive test combining various edge cases and regular cases
    input_data = np.array([[0, 0, 10, 10], [0, 0, 32, 32], [0, 0, 50, 50], [0, 0, 96, 96], [0, 0, 150, 150], [0, 0, 0, 0], [-10, -10, 10, 10], [0.5, 0.5, 32.5, 32.5]], dtype=np.float32)
    expected_output = np.array([1, 1, 2, 2, 3, 1, 2, 2], dtype=np.int_)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.