⚡️ Speed up function estimate_page_angle by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for estimate_page_angle in doctr/utils/geometry.py

⏱️ Runtime : 1.97 milliseconds → 1.88 milliseconds (best of 184 runs)

📝 Explanation and details

The optimization replaces manual degree conversion with NumPy's built-in np.degrees() function. Instead of multiplying by 180 / np.pi, the code now uses np.degrees(np.arctan(...)).

Key Performance Improvement:

• np.degrees() is a highly optimized C-level operation in NumPy that's faster than the explicit multiplication * 180 / np.pi
• The line profiler shows the arithmetic operation time decreased from 491,498 ns to 365,543 ns (25% faster on that specific line)

Why This Works:
NumPy's degrees() function is implemented in C and optimized for vectorized operations, making it more efficient than Python-level arithmetic operations. The constant 180 / np.pi must be computed and then applied via multiplication, while np.degrees() performs this conversion directly in optimized native code.

Test Case Performance:
The optimization shows consistent 3-8% improvements across most test cases, with particularly good results for:

• Large batches (1000+ polygons): 3-7% faster
• Edge cases with extreme values: 7-8% faster
• Single polygon operations: 6-8% faster

The 5% overall speedup comes from this simple but effective replacement of manual trigonometric conversion with NumPy's optimized function, demonstrating how leveraging library-optimized operations can yield meaningful performance gains even in small code changes.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 14 Passed
🌀 Generated Regression Tests	✅ 40 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
common/test_utils_geometry.py::test_estimate_page_angle	56.2μs	54.3μs	3.55%✅

🌀 Generated Regression Tests and Runtime

import numpy as np
# imports
import pytest  # used for our unit tests
from doctr.utils.geometry import estimate_page_angle

# unit tests

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

def test_single_horizontal_poly():
    # Polygon is perfectly horizontal, so angle should be 0
    poly = np.array([[[0, 0], [10, 0], [10, 2], [0, 2]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 59.8μs -> 55.5μs (7.66% faster)

def test_single_vertical_poly():
    # Polygon is vertical, so angle should be +/-90
    poly = np.array([[[0, 0], [0, 10], [2, 10], [2, 0]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 16.2μs -> 15.6μs (3.52% faster)

def test_single_45_degree_poly():
    # Polygon is rotated 45 degrees
    poly = np.array([[[0, 0], [7, 7], [9, 9], [2, 2]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 54.7μs -> 51.3μs (6.55% faster)

def test_batch_of_horizontal_polys():
    # Multiple horizontal polygons, expect 0
    polys = np.array([
        [[0, 0], [10, 0], [10, 2], [0, 2]],
        [[1, 1], [11, 1], [11, 3], [1, 3]],
        [[-5, -5], [5, -5], [5, -3], [-5, -3]],
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 51.9μs -> 48.8μs (6.30% faster)

def test_batch_of_varied_angles():
    # Batch with different angles, median should be correct
    polys = np.array([
        [[0, 0], [10, 0], [10, 2], [0, 2]],    # 0 deg
        [[0, 0], [0, 10], [2, 10], [2, 0]],    # 90 deg
        [[0, 0], [7, 7], [9, 9], [2, 2]],      # -45 deg
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 15.5μs -> 15.3μs (1.21% faster)

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

def test_all_points_identical():
    # All points are the same, so difference is zero, should return 0.0
    poly = np.array([[[1, 1], [1, 1], [1, 1], [1, 1]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 14.8μs -> 14.4μs (3.38% faster)

def test_vertical_line_division_by_zero():
    # xright == xleft, so division by zero, should return 0.0
    # All x coordinates are the same
    poly = np.array([[[1, 0], [1, 10], [1, 20], [1, 30]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 14.3μs -> 13.9μs (2.95% faster)

def test_empty_input():
    # Empty input should raise an error or return 0.0
    poly = np.zeros((0, 4, 2))
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 57.7μs -> 53.3μs (8.29% faster)

def test_nan_input():
    # Input contains NaN, should return 0.0 due to invalid calculation
    poly = np.array([[[np.nan, 0], [10, 0], [10, 2], [0, 2]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 56.5μs -> 52.6μs (7.27% faster)

def test_inf_input():
    # Input contains inf, should return 0.0 due to invalid calculation
    poly = np.array([[[np.inf, 0], [10, 0], [10, 2], [0, 2]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 50.1μs -> 46.6μs (7.56% faster)

def test_negative_coordinates():
    # Negative coordinates, but still horizontal
    poly = np.array([[[-10, -10], [0, -10], [0, -8], [-10, -8]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 50.8μs -> 48.2μs (5.46% faster)

def test_extreme_values():
    # Very large values
    poly = np.array([[[1e9, 1e9], [1e9+10, 1e9], [1e9+10, 1e9+2], [1e9, 1e9+2]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 48.8μs -> 45.0μs (8.41% faster)

def test_small_values():
    # Very small values
    poly = np.array([[[1e-9, 1e-9], [1e-9+10, 1e-9], [1e-9+10, 1e-9+2], [1e-9, 1e-9+2]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 48.4μs -> 44.7μs (8.14% faster)

def test_non_integer_coordinates():
    # Floating point coordinates
    poly = np.array([[[0.5, 0.5], [10.5, 0.5], [10.5, 2.5], [0.5, 2.5]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 47.8μs -> 44.8μs (6.63% faster)

def test_non_square_polygon():
    # Rectangle with width != height, still horizontal
    poly = np.array([[[0, 0], [20, 0], [20, 5], [0, 5]]])
    codeflash_output = estimate_page_angle(poly); angle = codeflash_output # 48.3μs -> 46.2μs (4.42% faster)

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

def test_large_batch_horizontal():
    # Large batch of horizontal polygons
    polys = np.zeros((1000, 4, 2))
    for i in range(1000):
        # Each poly is horizontal, but offset
        polys[i] = [[i, i], [i+10, i], [i+10, i+2], [i, i+2]]
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 67.9μs -> 63.6μs (6.77% faster)

def test_large_batch_mixed_angles():
    # 500 horizontal, 500 vertical
    polys = np.zeros((1000, 4, 2))
    for i in range(500):
        # Horizontal
        polys[i] = [[i, i], [i+10, i], [i+10, i+2], [i, i+2]]
    for i in range(500, 1000):
        # Vertical
        polys[i] = [[i, i], [i, i+10], [i+2, i+10], [i+2, i]]
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 21.2μs -> 21.3μs (0.311% slower)

def test_large_batch_random_angles():
    # Randomly rotated rectangles
    np.random.seed(42)
    polys = np.zeros((1000, 4, 2))
    for i in range(1000):
        angle = np.random.uniform(-90, 90)
        theta = np.deg2rad(angle)
        # Rectangle centered at (0,0), width=10, height=2
        rect = np.array([[-5, -1], [5, -1], [5, 1], [-5, 1]])
        rot = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
        polys[i] = rect @ rot.T
    codeflash_output = estimate_page_angle(polys); result = codeflash_output # 77.6μs -> 74.9μs (3.63% faster)

def test_large_batch_extreme_values():
    # Large batch with extreme values
    polys = np.zeros((1000, 4, 2))
    for i in range(1000):
        base = 1e6 * i
        polys[i] = [[base, base], [base+10, base], [base+10, base+2], [base, base+2]]
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 70.1μs -> 65.5μs (7.00% faster)

def test_large_batch_nan_injection():
    # Batch with some NaN entries
    polys = np.zeros((1000, 4, 2))
    for i in range(1000):
        polys[i] = [[i, i], [i+10, i], [i+10, i+2], [i, i+2]]
    polys[500, 0, 0] = np.nan
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 67.6μs -> 63.9μs (5.72% faster)

def test_large_batch_inf_injection():
    # Batch with some inf entries
    polys = np.zeros((1000, 4, 2))
    for i in range(1000):
        polys[i] = [[i, i], [i+10, i], [i+10, i+2], [i, i+2]]
    polys[700, 1, 0] = np.inf
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 66.8μs -> 63.2μs (5.68% 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 doctr.utils.geometry import estimate_page_angle

# unit tests

# Basic Test Cases

def test_horizontal_polys():
    # All polygons are perfectly horizontal (angle should be 0)
    polys = np.array([
        [[0, 0], [10, 0], [10, 2], [0, 2]],
        [[5, 5], [15, 5], [15, 7], [5, 7]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 55.3μs -> 52.4μs (5.51% faster)

def test_vertical_polys():
    # All polygons are perfectly vertical (angle should be 90 or -90 depending on convention)
    polys = np.array([
        [[0, 0], [0, 10], [2, 10], [2, 0]],
        [[5, 5], [5, 15], [7, 15], [7, 5]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 15.3μs -> 15.0μs (2.48% faster)

def test_diagonal_45_deg_polys():
    # Polygons at 45 degrees
    polys = np.array([
        [[0, 0], [7, 7], [9, 9], [2, 2]],
        [[10, 10], [17, 17], [19, 19], [12, 12]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 53.5μs -> 50.4μs (6.08% faster)

def test_negative_angle_polys():
    # Polygons sloping downwards (negative angle)
    polys = np.array([
        [[0, 10], [10, 0], [12, 2], [2, 12]],
        [[5, 15], [15, 5], [17, 7], [7, 17]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 52.7μs -> 50.7μs (3.90% faster)

def test_single_poly():
    # Single polygon, horizontal
    polys = np.array([[[0, 0], [10, 0], [10, 2], [0, 2]]])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 51.6μs -> 47.7μs (8.06% faster)

# Edge Test Cases

def test_zero_width_poly():
    # All points have the same x, so width is zero, should trigger FloatingPointError and return 0.0
    polys = np.array([
        [[5, 0], [5, 10], [5, 12], [5, 2]],
        [[8, 1], [8, 11], [8, 13], [8, 3]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 15.4μs -> 15.3μs (0.642% faster)

def test_zero_height_poly():
    # All points have the same y, so height is zero, but function should still work
    polys = np.array([
        [[0, 5], [10, 5], [12, 5], [2, 5]],
        [[3, 8], [13, 8], [15, 8], [5, 8]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 53.7μs -> 50.0μs (7.39% faster)

def test_degenerate_poly():
    # All points are the same, so polygon is a point
    polys = np.array([
        [[1, 1], [1, 1], [1, 1], [1, 1]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 15.5μs -> 14.9μs (3.58% faster)

def test_mixed_angles():
    # Mixed angles, median should be the middle value
    polys = np.array([
        [[0, 0], [10, 0], [10, 2], [0, 2]],    # 0 deg
        [[0, 0], [0, 10], [2, 10], [2, 0]],    # 90 deg
        [[0, 0], [7, 7], [9, 9], [2, 2]],      # 45 deg
        [[0, 10], [10, 0], [12, 2], [2, 12]],  # -45 deg
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 14.7μs -> 14.2μs (3.29% faster)

def test_empty_input():
    # No polygons, should return 0.0
    polys = np.empty((0, 4, 2))
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 55.2μs -> 52.5μs (5.16% faster)

def test_nan_input():
    # Contains NaN values, should trigger FloatingPointError and return 0.0
    polys = np.array([
        [[np.nan, 0], [10, 0], [10, 2], [0, 2]],
        [[5, 5], [15, 5], [15, 7], [5, 7]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 54.0μs -> 51.5μs (4.98% faster)

def test_inf_input():
    # Contains inf values, should trigger FloatingPointError and return 0.0
    polys = np.array([
        [[np.inf, 0], [10, 0], [10, 2], [0, 2]],
        [[5, 5], [15, 5], [15, 7], [5, 7]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 50.4μs -> 47.1μs (7.07% faster)

def test_negative_zero_width():
    # xright == xleft, but negative values, should trigger FloatingPointError and return 0.0
    polys = np.array([
        [[-5, 0], [-5, 10], [-5, 12], [-5, 2]],
        [[-8, 1], [-8, 11], [-8, 13], [-8, 3]]
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 15.8μs -> 15.4μs (2.54% faster)

# Large Scale Test Cases

def test_large_batch_horizontal():
    # 1000 horizontal polygons, should be very close to 0
    polys = np.array([
        [[i, 0], [i+10, 0], [i+10, 2], [i, 2]] for i in range(1000)
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 87.8μs -> 84.9μs (3.48% faster)

def test_large_batch_random_angles():
    # 1000 polygons with random angles between -45 and 45 degrees
    rng = np.random.default_rng(42)
    angles = rng.uniform(-45, 45, size=1000)
    polys = []
    for i, a in enumerate(angles):
        # Center at (i, i), size 10x2, rotated by angle a
        theta = np.deg2rad(a)
        c = np.array([i, i])
        rect = np.array([[-5, -1], [5, -1], [5, 1], [-5, 1]])
        rot = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
        poly = (rect @ rot.T) + c
        polys.append(poly)
    polys = np.array(polys)
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 88.3μs -> 89.1μs (0.900% slower)
    # Should be close to the median of angles
    expected = float(np.median(angles))

def test_large_batch_vertical():
    # 1000 vertical polygons, should be close to 90
    polys = np.array([
        [[i, 0], [i, 10], [i+2, 10], [i+2, 0]] for i in range(1000)
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 30.3μs -> 30.2μs (0.368% faster)

def test_large_batch_zero_width():
    # 1000 degenerate polygons (zero width), should return 0.0
    polys = np.array([
        [[i, 0], [i, 10], [i, 12], [i, 2]] for i in range(1000)
    ])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 29.3μs -> 28.9μs (1.36% faster)

def test_large_batch_nan():
    # 1000 polygons, one contains NaN, should return 0.0
    polys = np.array([
        [[i, 0], [i+10, 0], [i+10, 2], [i, 2]] for i in range(999)
    ] + [[[np.nan, 0], [10, 0], [10, 2], [0, 2]]])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 88.5μs -> 84.1μs (5.26% faster)

def test_large_batch_inf():
    # 1000 polygons, one contains inf, should return 0.0
    polys = np.array([
        [[i, 0], [i+10, 0], [i+10, 2], [i, 2]] for i in range(999)
    ] + [[[np.inf, 0], [10, 0], [10, 2], [0, 2]]])
    codeflash_output = estimate_page_angle(polys); angle = codeflash_output # 81.7μs -> 78.9μs (3.58% faster)
# 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-estimate_page_angle-mg7sxmng and push.