⚡️ Speed up function image_rotation by 2,214%

[codeflash-ai]

📄 2,214% (22.14x) speedup for image_rotation in src/signal/image.py

⏱️ Runtime : 1.44 seconds → 62.1 milliseconds (best of 21 runs)

📝 Explanation and details

The optimized code achieves a 22x speedup by replacing nested Python loops with vectorized NumPy operations. Here's why this transformation is so effective:

Key Optimization: Vectorization

What changed:

• The original code uses nested for loops iterating over ~2.1 million pixels (for typical test images), performing scalar arithmetic and array indexing at each iteration
• The optimized code uses np.meshgrid() to create coordinate grids, then performs all transformations as array operations in a single pass

Why it's faster:

1. Eliminates Python interpreter overhead: The original code spends 70% of runtime in loop overhead and scalar operations (lines with for, offset_y = y - new_center_y, etc.). Vectorization moves computation to compiled C code in NumPy.

2. SIMD and cache efficiency: NumPy operations leverage CPU vectorization (SIMD instructions) and better cache locality by processing contiguous memory blocks, versus scattered memory access in nested loops.

3. Reduces per-pixel overhead: The line profiler shows the original code spends 785-833ns per pixel just computing original_y and original_x. The optimized version does all ~2M transformations in 13.8ms total (6.5ns per pixel) - a 120x improvement for the transformation step alone.

Performance Characteristics

Small images (< 10x10 pixels): The optimization is 60-86% slower due to NumPy array allocation overhead exceeding the benefit of vectorization. This is evident in tests like test_single_pixel_image (7μs → 36μs).

Large images (≥ 100x100 pixels): The optimization shines with 19-29x speedups:

• test_large_square_image_rotation_90: 7.38ms → 365μs (19x faster)
• test_large_rectangular_image_rotation_45: 26.7ms → 905μs (28x faster)
• test_large_image_non_multiple_of_90: 250ms → 9.33ms (26x faster)

Impact Assessment

When this matters:

• Image processing pipelines handling images larger than ~50x50 pixels
• Batch operations on multiple images
• Real-time rotation requirements where the function is called frequently
• Any scenario processing video frames or high-resolution images

Trade-offs:

• Increased memory usage (temporary arrays for coordinate grids, ~8x the output size during execution)
• Slightly worse performance for tiny images (< 10x10), but these cases are rare in practice and the absolute difference is negligible (< 50μs)

The optimization transforms this from an O(n²) Python loop bottleneck into an O(n²) vectorized operation that leverages hardware acceleration, making it suitable for production image processing workloads.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import numpy as np

# imports
import pytest
from src.signal.image import image_rotation

# unit tests

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


def test_identity_rotation_grayscale():
    # Rotating by 0 degrees should return an image with the same pixel values (possibly different shape)
    img = np.arange(9).reshape(3, 3)
    codeflash_output = image_rotation(img, 0)
    rotated = codeflash_output  # 27.5μs -> 79.8μs (65.5% slower)


def test_identity_rotation_rgb():
    # Rotating by 0 degrees for RGB image
    img = np.arange(27).reshape(3, 3, 3)
    codeflash_output = image_rotation(img, 0)
    rotated = codeflash_output  # 18.2μs -> 50.2μs (63.8% slower)


def test_90_degree_rotation_grayscale():
    # Rotating by 90 degrees should transpose and flip the image
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 10.5μs -> 45.8μs (77.2% slower)
    # The corners should be in the correct rotated positions
    # Manual check: original [[1,2],[3,4]] rotated 90deg CCW: [[2,4],[1,3]]
    expected = np.array([[2, 4], [1, 3]])


def test_180_degree_rotation_grayscale():
    # Rotating by 180 degrees should flip the image upside down and left-right
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 180)
    rotated = codeflash_output  # 9.46μs -> 44.6μs (78.8% slower)
    expected = np.array([[4, 3], [2, 1]])


def test_270_degree_rotation_rgb():
    # Rotating by 270 degrees should rotate the image 270deg CCW (or 90deg CW)
    img = np.zeros((2, 3, 3), dtype=int)
    img[0, 0] = [255, 0, 0]  # Red
    img[1, 2] = [0, 0, 255]  # Blue
    codeflash_output = image_rotation(img, 270)
    rotated = codeflash_output  # 13.0μs -> 47.0μs (72.3% slower)


def test_rotation_non_square_image():
    # Test rotating a non-square image (2x3)
    img = np.array([[1, 2, 3], [4, 5, 6]])
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 10.9μs -> 44.2μs (75.3% slower)


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


def test_empty_image():
    # Rotating an empty image should return an empty image
    img = np.array([[]])
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 6.29μs -> 44.9μs (86.0% slower)


def test_single_pixel_image():
    # Rotating a single pixel should return the same pixel
    img = np.array([[42]])
    codeflash_output = image_rotation(img, 123)
    rotated = codeflash_output  # 7.12μs -> 37.2μs (80.8% slower)


def test_large_angle_over_360():
    # Rotating by an angle > 360 should be equivalent to angle % 360
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 450)
    rotated1 = codeflash_output  # 9.42μs -> 44.4μs (78.8% slower)
    codeflash_output = image_rotation(img, 90)
    rotated2 = codeflash_output  # 7.00μs -> 37.2μs (81.2% slower)


def test_negative_angle():
    # Rotating by a negative angle should rotate in the opposite direction
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 90)
    rot_pos = codeflash_output  # 9.00μs -> 42.6μs (78.9% slower)
    codeflash_output = image_rotation(img, -270)
    rot_neg = codeflash_output  # 6.88μs -> 36.2μs (81.0% slower)


def test_float_image_values():
    # Test that function works with float images
    img = np.array([[0.5, 0.2], [0.7, 0.9]])
    codeflash_output = image_rotation(img, 180)
    rotated = codeflash_output  # 8.67μs -> 43.3μs (80.0% slower)
    expected = np.array([[0.9, 0.7], [0.2, 0.5]])


def test_large_angle_negative():
    # Rotating by a large negative angle
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, -630)
    rotated1 = codeflash_output  # 8.96μs -> 42.9μs (79.1% slower)
    codeflash_output = image_rotation(img, 90)
    rotated2 = codeflash_output  # 6.88μs -> 36.1μs (81.0% slower)


def test_channel_preservation():
    # Test that the number of channels is preserved
    img = np.ones((5, 5, 4))
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 47.0μs -> 52.2μs (9.83% slower)


def test_odd_sized_image_centering():
    # Test that the center pixel of an odd-sized image remains in the center after 180deg rotation
    img = np.zeros((5, 5))
    img[2, 2] = 99
    codeflash_output = image_rotation(img, 180)
    rotated = codeflash_output  # 23.8μs -> 46.5μs (49.0% slower)


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


def test_large_square_image_rotation_90():
    # Test rotating a large square image
    img = np.arange(100 * 100).reshape(100, 100)
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 7.38ms -> 365μs (1917% faster)


def test_large_rectangular_image_rotation_45():
    # Rotating a large rectangular image by 45 degrees
    img = np.arange(200 * 100).reshape(200, 100)
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 26.7ms -> 905μs (2849% faster)
    # Check that the center pixel is preserved at the center (approximately)
    center_in = img[img.shape[0] // 2, img.shape[1] // 2]
    center_out = rotated[rotated.shape[0] // 2, rotated.shape[1] // 2]


def test_large_rgb_image_rotation_180():
    # Rotating a large RGB image by 180 degrees
    img = np.random.randint(0, 256, (300, 400, 3), dtype=np.uint8)
    codeflash_output = image_rotation(img, 180)
    rotated = codeflash_output  # 100ms -> 7.64ms (1218% faster)


def test_performance_on_large_image():
    # Test that the function completes in reasonable time for a 500x500 image
    img = np.ones((500, 500))
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 281ms -> 10.6ms (2570% faster)


# ------------------ MISCELLANEOUS/ROBUSTNESS TESTS ------------------


def test_non_integer_angle():
    # Rotating by a non-integer angle
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 33.3)
    rotated = codeflash_output  # 26.8μs -> 68.9μs (61.0% slower)
    # Center pixel should be from the input
    center_in = img[img.shape[0] // 2, img.shape[1] // 2]
    center_out = rotated[rotated.shape[0] // 2, rotated.shape[1] // 2]


def test_dtype_preservation():
    # The dtype of the output should match the input
    img = np.arange(9, dtype=np.uint16).reshape(3, 3)
    codeflash_output = image_rotation(img, 0)
    rotated = codeflash_output  # 19.0μs -> 48.4μs (60.7% slower)


def test_input_not_modified():
    # The input image should not be modified by the function
    img = np.array([[1, 2], [3, 4]])
    img_copy = img.copy()
    codeflash_output = image_rotation(img, 90)
    _ = codeflash_output  # 10.0μs -> 43.2μs (76.8% slower)


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

import numpy as np

# imports
import pytest
from src.signal.image import image_rotation

# unit tests

# --------------------------
# Basic Test Cases
# --------------------------


def test_identity_rotation_grayscale():
    # Rotating by 0 degrees should return an image with the same content
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 0)
    rotated = codeflash_output  # 10.2μs -> 43.5μs (76.5% slower)


def test_identity_rotation_rgb():
    # Rotating by 0 degrees should return an image with the same content (RGB)
    img = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
    codeflash_output = image_rotation(img, 0)
    rotated = codeflash_output  # 12.2μs -> 45.2μs (73.1% slower)


def test_90_degree_rotation_square():
    # Rotating a 2x2 image by 90 degrees
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 9.42μs -> 43.2μs (78.2% slower)
    # Output should be 2x2, with pixels rotated
    expected = np.array([[2, 4], [1, 3]])


def test_180_degree_rotation_square():
    # Rotating a 2x2 image by 180 degrees
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 180)
    rotated = codeflash_output  # 8.88μs -> 43.2μs (79.4% slower)
    expected = np.array([[4, 3], [2, 1]])


def test_90_degree_rotation_rectangular():
    # Rotating a 2x3 image by 90 degrees
    img = np.array([[1, 2, 3], [4, 5, 6]])
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 10.8μs -> 43.8μs (75.2% slower)


def test_45_degree_rotation():
    # Rotating a 3x3 image by 45 degrees
    img = np.arange(9).reshape((3, 3))
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 18.2μs -> 45.6μs (60.0% slower)
    # All input values should appear somewhere in output
    for v in np.unique(img):
        pass


def test_negative_angle_rotation():
    # Rotating by -90 degrees should be a valid rotation
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, -90)
    rotated = codeflash_output  # 9.25μs -> 43.0μs (78.5% slower)


# --------------------------
# Edge Test Cases
# --------------------------


def test_single_pixel_image():
    # Rotating a 1x1 image should return the same value
    img = np.array([[42]])
    codeflash_output = image_rotation(img, 123)
    rotated = codeflash_output  # 7.08μs -> 35.8μs (80.2% slower)


def test_empty_image():
    # Rotating an empty image should return an empty image
    img = np.zeros((0, 0))
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 6.33μs -> 42.4μs (85.1% slower)


def test_large_angle_rotation():
    # Rotating by an angle > 360 should be equivalent to angle % 360
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 450)
    rotated1 = codeflash_output  # 9.50μs -> 43.1μs (78.0% slower)
    codeflash_output = image_rotation(img, 90)
    rotated2 = codeflash_output  # 6.58μs -> 36.4μs (81.9% slower)


def test_non_integer_angles():
    # Rotating by a non-integer angle
    img = np.arange(9).reshape((3, 3))
    codeflash_output = image_rotation(img, 33.3)
    rotated = codeflash_output  # 18.1μs -> 43.2μs (58.1% slower)


def test_rgb_image_rotation():
    # Rotating a 3x3 RGB image by 90 degrees
    img = np.arange(27).reshape((3, 3, 3))
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 15.8μs -> 44.9μs (64.8% slower)
    # All input values should appear in output
    for v in np.unique(img):
        pass


def test_non_square_rgb_image():
    # Rotating a 2x3x3 RGB image
    img = np.arange(18).reshape((2, 3, 3))
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 15.1μs -> 44.8μs (66.2% slower)
    # All input values should appear in output
    for v in np.unique(img):
        pass


def test_float_image():
    # Rotating an image with float values
    img = np.array([[0.1, 0.2], [0.3, 0.4]])
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 9.04μs -> 42.8μs (78.9% slower)


def test_image_with_negative_values():
    # Rotating an image with negative values
    img = np.array([[-1, -2], [-3, -4]])
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 8.92μs -> 42.6μs (79.1% slower)
    for v in np.unique(img):
        pass


def test_image_with_alpha_channel():
    # Rotating a 2x2 RGBA image
    img = np.arange(16).reshape((2, 2, 4))
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 9.79μs -> 43.5μs (77.5% slower)
    for v in np.unique(img):
        pass


# --------------------------
# Large Scale Test Cases
# --------------------------


def test_large_square_image_rotation():
    # Rotating a 100x100 image by 90 degrees
    img = np.arange(10000).reshape((100, 100))
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 7.38ms -> 368μs (1899% faster)
    # Check that all input values are present in output
    input_set = set(np.unique(img))
    output_set = set(np.unique(rotated))


def test_large_rectangular_image_rotation():
    # Rotating a 50x200 image by 45 degrees
    img = np.arange(50 * 200).reshape((50, 200))
    codeflash_output = image_rotation(img, 45)
    rotated = codeflash_output  # 17.2ms -> 573μs (2893% faster)
    # Check that all input values are present in output
    input_set = set(np.unique(img))
    output_set = set(np.unique(rotated))


def test_large_rgb_image_rotation():
    # Rotating a 100x100x3 RGB image by 180 degrees
    img = np.arange(100 * 100 * 3).reshape((100, 100, 3))
    codeflash_output = image_rotation(img, 180)
    rotated = codeflash_output  # 8.43ms -> 673μs (1151% faster)
    # Check that all input values are present in output
    input_set = set(np.unique(img))
    output_set = set(np.unique(rotated))


def test_maximum_size_image():
    # Rotating a 999x999 grayscale image by 90 degrees
    img = np.arange(999 * 999).reshape((999, 999))
    codeflash_output = image_rotation(img, 90)
    rotated = codeflash_output  # 737ms -> 30.1ms (2352% faster)
    # Check that all input values are present in output
    input_set = set(np.unique(img))
    output_set = set(np.unique(rotated))


def test_large_image_non_multiple_of_90():
    # Rotating a 500x500 image by 17 degrees
    img = np.arange(500 * 500).reshape((500, 500))
    codeflash_output = image_rotation(img, 17)
    rotated = codeflash_output  # 250ms -> 9.33ms (2590% faster)
    # Check that all input values are present in output
    input_set = set(np.unique(img))
    output_set = set(np.unique(rotated))


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

from src.signal.image import image_rotation

To edit these changes git checkout codeflash/optimize-image_rotation-mji14qzz and push.