⚡️ Speed up function image_rotation by 2,904%

[codeflash-ai]

📄 2,904% (29.04x) speedup for image_rotation in src/numpy_pandas/signal_processing.py

⏱️ Runtime : 1.71 seconds → 57.0 milliseconds (best of 133 runs)

📝 Explanation and details

The optimized code achieves a 29x speedup by replacing nested Python loops with vectorized NumPy operations. The key optimization is eliminating the double for-loop that was performing 4.6 million iterations in the original code.

What was optimized:

• Replaced nested loops with meshgrid: Instead of iterating through each pixel, np.meshgrid generates all coordinate pairs at once
• Vectorized coordinate transformations: The rotation matrix calculations (original_y, original_x) are now applied to entire arrays simultaneously using NumPy broadcasting
• Boolean masking for bounds checking: The validity check is now a vectorized boolean operation applied to all pixels at once, followed by masked assignment

Why this is faster:

• The original code spent 62.7% of its time in the nested loops doing repetitive arithmetic operations in interpreted Python
• NumPy operations are implemented in optimized C code and can leverage SIMD instructions and better memory access patterns
• Memory allocation happens once instead of millions of individual pixel assignments

Performance characteristics from tests:

• Small images (2x2 to 5x5): Actually 70-80% slower due to vectorization overhead, but these complete in microseconds anyway
• Large images (300x400+): Dramatic speedups of 15-38x, where the optimization truly shines
• The crossover point appears around 100x100 images where vectorization overhead is overcome by computational benefits

This optimization is most effective for larger images where the setup cost of vectorized operations is amortized across many pixels.

✅ 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%

🌀 Generated Regression Tests and Runtime

import numpy as np
# imports
import pytest  # used for our unit tests
from src.numpy_pandas.signal_processing import image_rotation

# unit tests

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

def test_identity_rotation_grayscale():
    # Rotating by 0 degrees should return an image with the same central region as the input
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 0); rotated = codeflash_output # 6.08μs -> 22.8μs (73.3% slower)

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

def test_90_degree_rotation_square_grayscale():
    # Rotating a 2x2 image by 90 degrees should transpose and flip
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 5.25μs -> 21.9μs (76.0% slower)
    # For this implementation, output shape is the same as input for 2x2
    expected = np.array([[2, 4], [1, 3]])

def test_180_degree_rotation_square_grayscale():
    # Rotating a 2x2 image by 180 degrees should flip both axes
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 180); rotated = codeflash_output # 5.04μs -> 22.0μs (77.1% slower)
    expected = np.array([[4, 3], [2, 1]])

def test_90_degree_rotation_rectangular_grayscale():
    # 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 # 5.88μs -> 21.8μs (73.0% slower)
    # Check that the central region matches expected rotation
    expected = np.array([[3,6],[2,5],[1,4]])

def test_45_degree_rotation_small():
    # Rotating a 3x3 image by 45 degrees
    img = np.arange(1, 10).reshape(3,3)
    codeflash_output = image_rotation(img, 45); rotated = codeflash_output # 10.3μs -> 22.0μs (53.2% slower)

def test_negative_angle_rotation():
    # Rotating by -90 degrees should rotate in the opposite direction
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, -90); rotated = codeflash_output # 5.08μs -> 21.3μs (76.1% slower)
    expected = np.array([[3,1],[4,2]])

def test_rotation_360_degrees():
    # Rotating by 360 degrees should return the original image
    img = np.random.randint(0, 255, (5,5), dtype=np.uint8)
    codeflash_output = image_rotation(img, 360); rotated = codeflash_output # 15.5μs -> 22.9μs (32.4% slower)

def test_rgb_image_rotation_90():
    # Test rotation on a 3-channel image
    img = np.array([
        [[1,2,3],[4,5,6]],
        [[7,8,9],[10,11,12]]
    ])
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 5.62μs -> 22.3μs (74.8% slower)
    expected = np.array([
        [[4,5,6],[10,11,12]],
        [[1,2,3],[7,8,9]]
    ])

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

def test_empty_image():
    # Rotating an empty image should return an empty image
    img = np.array([[]])
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 3.46μs -> 19.8μs (82.5% slower)

def test_single_pixel_image():
    # Rotating a 1x1 image should return the same image
    img = np.array([[42]])
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 4.12μs -> 18.2μs (77.4% slower)

def test_non_square_large_angle():
    # Rotating a non-square image by 270 degrees
    img = np.arange(6).reshape(2,3)
    codeflash_output = image_rotation(img, 270); rotated = codeflash_output # 6.42μs -> 22.4μs (71.4% slower)
    expected = np.array([[2,5],[1,4],[0,3]])

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 # 5.04μs -> 22.0μs (77.0% slower)
    expected = np.array([[0.2,0.4],[0.1,0.3]])

def test_rotation_more_than_360():
    # Rotating by 450 degrees (360 + 90) should be same as 90
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, 450); rotated = codeflash_output # 5.29μs -> 21.6μs (75.5% slower)
    expected = np.array([[2,4],[1,3]])

def test_image_with_alpha_channel():
    # Rotating an RGBA image
    img = np.array([
        [[1,2,3,4],[5,6,7,8]],
        [[9,10,11,12],[13,14,15,16]]
    ])
    codeflash_output = image_rotation(img, 180); rotated = codeflash_output # 5.42μs -> 23.5μs (76.9% slower)
    expected = np.array([
        [[16,15,14,13],[12,11,10,9]],
        [[8,7,6,5],[4,3,2,1]]
    ])

def test_non_integer_angle():
    # Rotating by a non-integer angle (e.g., 45.5 degrees)
    img = np.arange(1,10).reshape(3,3)
    codeflash_output = image_rotation(img, 45.5); rotated = codeflash_output # 9.92μs -> 22.1μs (55.2% slower)
    # Center pixel should still be close to input center
    center = rotated[rotated.shape[0]//2, rotated.shape[1]//2]

def test_non_contiguous_input():
    # Rotating a non-contiguous array (slice of a larger array)
    base = np.arange(16).reshape(4,4)
    img = base[::2, ::2]  # shape (2,2)
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 5.33μs -> 22.0μs (75.8% slower)
    expected = np.array([[2,10],[0,8]])

def test_highly_rectangular_image():
    # Rotating a 1x10 image
    img = np.arange(10).reshape(1,10)
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 8.04μs -> 21.9μs (63.3% slower)

def test_large_angle_negative():
    # Rotating by -450 degrees should be same as -90
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, -450); rotated = codeflash_output # 5.21μs -> 21.8μs (76.1% slower)
    expected = np.array([[3,1],[4,2]])

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

def test_large_square_image_90():
    # Rotating a large 500x500 image by 90 degrees
    img = np.arange(500*500).reshape(500,500)
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 107ms -> 2.82ms (3710% faster)

def test_large_rectangular_image_180():
    # Rotating a large 100x800 image by 180 degrees
    img = np.arange(100*800).reshape(100,800)
    codeflash_output = image_rotation(img, 180); rotated = codeflash_output # 34.3ms -> 875μs (3814% faster)

def test_large_rgb_image_270():
    # Rotating a large RGB image by 270 degrees
    img = np.random.randint(0, 255, (300,400,3), dtype=np.uint8)
    codeflash_output = image_rotation(img, 270); rotated = codeflash_output # 59.5ms -> 3.24ms (1737% faster)
    # Check that the central pixel in the output matches the expected input pixel
    cy, cx = 300//2, 400//2
    out_cy, out_cx = 400//2, 300//2

def test_large_non_square_float_image():
    # Rotating a large float image
    img = np.linspace(0,1,999*500).reshape(999,500)
    codeflash_output = image_rotation(img, 90); rotated = codeflash_output # 195ms -> 6.08ms (3115% faster)

def test_large_image_performance():
    # Rotating a 1000x1000 image by 45 degrees (performance test)
    img = np.ones((1000,1000))
    codeflash_output = image_rotation(img, 45); rotated = codeflash_output # 687ms -> 22.5ms (2957% faster)
# 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  # used for our unit tests
from src.numpy_pandas.signal_processing import image_rotation

# unit tests

# 1. Basic Test Cases

def test_identity_rotation_gray():
    # 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); out = codeflash_output # 13.8μs -> 38.8μs (64.6% slower)

def test_identity_rotation_rgb():
    # Rotating a color image by 0 degrees should return the same image
    img = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
    codeflash_output = image_rotation(img, 0); out = codeflash_output # 7.38μs -> 23.8μs (68.9% slower)

def test_90_degree_rotation_gray():
    # Rotating a 2x2 gray image by 90 degrees
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 90); out = codeflash_output # 5.25μs -> 21.4μs (75.4% slower)

def test_180_degree_rotation_gray():
    # Rotating a 2x2 gray image by 180 degrees
    img = np.array([[1, 2], [3, 4]])
    codeflash_output = image_rotation(img, 180); out = codeflash_output # 5.12μs -> 21.3μs (75.9% slower)

def test_45_degree_rotation_gray():
    # Rotating a 3x3 image by 45 degrees should increase dimensions
    img = np.arange(9).reshape((3,3))
    codeflash_output = image_rotation(img, 45); out = codeflash_output # 10.2μs -> 21.8μs (53.2% slower)

def test_90_degree_rotation_rgb():
    # Rotating a 2x2 RGB image by 90 degrees
    img = np.array([
        [[1,2,3],[4,5,6]],
        [[7,8,9],[10,11,12]]
    ])
    codeflash_output = image_rotation(img, 90); out = codeflash_output # 5.54μs -> 22.2μs (75.0% slower)
    # All original pixels should appear somewhere in the output
    for row in img:
        for pixel in row:
            pass

# 2. Edge Test Cases

def test_empty_image():
    # Rotating an empty image should return an empty image
    img = np.empty((0,0))
    codeflash_output = image_rotation(img, 45); out = codeflash_output # 3.58μs -> 20.7μs (82.7% slower)

def test_one_pixel_image():
    # Rotating a single pixel image should return a single pixel image
    img = np.array([[42]])
    codeflash_output = image_rotation(img, 123); out = codeflash_output # 4.00μs -> 17.6μs (77.3% slower)

def test_non_square_image():
    # Rotating a non-square image by 90 degrees
    img = np.arange(6).reshape((2,3))
    codeflash_output = image_rotation(img, 90); out = codeflash_output # 5.88μs -> 21.8μs (73.0% slower)

def test_negative_angle():
    # Rotating by a negative angle should work (counter-clockwise)
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, -90); out = codeflash_output # 5.17μs -> 21.1μs (75.5% slower)
    # All original values should appear somewhere in the output
    for val in img.flatten():
        pass

def test_angle_over_360():
    # Rotating by angles > 360 should be equivalent to modulo 360
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, 450); out1 = codeflash_output # 5.21μs -> 21.5μs (75.8% slower)
    codeflash_output = image_rotation(img, 90); out2 = codeflash_output # 4.08μs -> 18.8μs (78.2% slower)

def test_large_angle_negative():
    # Rotating by large negative angle
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, -630); out1 = codeflash_output # 5.08μs -> 21.3μs (76.1% slower)
    codeflash_output = image_rotation(img, 90); out2 = codeflash_output # 3.83μs -> 18.5μs (79.2% slower)

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); out = codeflash_output # 5.08μs -> 21.2μs (76.0% slower)
    # All original values should appear somewhere in the output
    for val in img.flatten():
        pass

def test_high_channel_image():
    # Rotating an image with more than 3 channels
    img = np.ones((4,4,5))
    codeflash_output = image_rotation(img, 90); out = codeflash_output # 11.5μs -> 23.8μs (51.4% slower)

def test_large_angle_precision():
    # Rotating by 359.999 degrees should nearly flip the image
    img = np.array([[1,2],[3,4]])
    codeflash_output = image_rotation(img, 359.999); out = codeflash_output # 5.42μs -> 22.0μs (75.3% slower)
    # All original values should appear somewhere in the output
    for val in img.flatten():
        pass

# 3. Large Scale Test Cases

def test_large_gray_image_90deg():
    # Rotating a large grayscale image by 90 degrees
    img = np.arange(1000*500).reshape((1000,500))
    codeflash_output = image_rotation(img, 90); out = codeflash_output # 215ms -> 6.09ms (3433% faster)

def test_large_rgb_image_45deg():
    # Rotating a large RGB image by 45 degrees
    img = np.random.randint(0, 255, (300, 400, 3), dtype=np.uint8)
    codeflash_output = image_rotation(img, 45); out = codeflash_output # 95.1ms -> 4.60ms (1966% faster)

def test_large_non_square_image():
    # Rotating a large non-square image by 30 degrees
    img = np.ones((200, 800))
    codeflash_output = image_rotation(img, 30); out = codeflash_output # 148ms -> 4.41ms (3259% faster)

def test_performance_large_image():
    # Rotating a 500x500 image should not take excessive time or memory
    img = np.ones((500,500))
    codeflash_output = image_rotation(img, 30); out = codeflash_output # 162ms -> 5.10ms (3087% faster)

def test_large_channels():
    # Rotating an image with many channels
    img = np.ones((100,100,10))
    codeflash_output = image_rotation(img, 60); out = codeflash_output # 7.46ms -> 512μs (1358% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.numpy_pandas.signal_processing import image_rotation

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