⚡️ Speed up function utm_transformers_from_ll by 642%

[codeflash-ai]

📄 642% (6.42x) speedup for utm_transformers_from_ll in opendm/location.py

⏱️ Runtime : 513 milliseconds → 69.1 milliseconds (best of 83 runs)

📝 Explanation and details

The optimized code achieves a 642% speedup by implementing strategic caching for expensive object creation operations that were being redundantly executed in the original code.

Key optimizations applied:

1. Coordinate Transformation Caching (_transformer_cache): The original code created new osr.CoordinateTransformation objects on every call (56.2% of transformer() time). The optimized version caches these using object IDs as keys, reducing 1,748 redundant transformations to just 240 cache misses.

2. OSR SpatialReference Caching (_crs2osr_cache): Cached the expensive proj_srs_convert() calls that were consuming 43.8% of transformer() time. Uses EPSG codes when available, falling back to proj4 strings for stable cache keys.

3. UTM SRS Caching (_utm_srs_cache): The parse_srs_header() call was taking 98.3% of utm_srs_from_ll() time. Caching by (zone, hemisphere) reduces 874 redundant calls to just 120 cache misses.

4. WGS84 CRS Caching: The frequently used CRS.from_epsg(4326) is cached as a function attribute, eliminating 996 redundant instantiations.

Performance impact by test case:

• Error handling test cases show 300-1300% speedups due to reduced object creation overhead
• The optimizations are particularly effective for workloads with repeated coordinate transformations in the same UTM zones

The line profiler shows the optimized transformer() function spending only 71% of time on actual CoordinateTransformation creation (vs 100% originally), with the rest being fast cache lookups.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import math

# imports
import pytest  # used for our unit tests
from opendm.location import utm_transformers_from_ll
from osgeo import osr
from pyproj import CRS

# unit tests

# Helper to transform coordinates using the osr.CoordinateTransformation object
def transform_point(transformer, lon, lat, alt=0):
    # Returns (x, y, z)
    result = transformer.TransformPoint(lon, lat, alt)
    return result

# 1. Basic Test Cases









def test_edge_invalid_latitude():
    # Test at latitude out of UTM bounds (>84 or <-80)
    with pytest.raises(Exception):
        # Should fail to create a valid UTM SRS
        utm_transformers_from_ll(0, 90)
    with pytest.raises(Exception):
        utm_transformers_from_ll(0, -90)

def test_edge_invalid_longitude():
    # Test at longitude out of bounds (<-180 or >180)
    with pytest.raises(Exception):
        utm_transformers_from_ll(-181, 0)
    with pytest.raises(Exception):
        utm_transformers_from_ll(181, 0)

def test_edge_non_numeric_input():
    # Test with non-numeric input
    with pytest.raises(Exception):
        utm_transformers_from_ll("a", 0) # 34.8μs -> 2.48μs (1301% faster)
    with pytest.raises(Exception):
        utm_transformers_from_ll(0, "b") # 11.3μs -> 2.40μs (369% faster)
    with pytest.raises(Exception):
        utm_transformers_from_ll(None, None) # 7.60μs -> 1.30μs (486% faster)

# 3. Large Scale Test Cases





#------------------------------------------------
import math

# imports
import pytest  # used for our unit tests
from opendm.location import utm_transformers_from_ll
from osgeo import osr
from pyproj import CRS


def get_utm_zone_and_hemisphere_from(lon, lat):
    """
    Calculate the UTM zone and hemisphere that a longitude/latitude pair falls on
    :param lon longitude
    :param lat latitude
    :return [utm_zone, hemisphere]
    """
    utm_zone = (int(math.floor((lon + 180.0)/6.0)) % 60) + 1
    hemisphere = 'S' if lat < 0 else 'N'
    return [utm_zone, hemisphere]
from opendm.location import utm_transformers_from_ll

# unit tests

# Helper for round-trip test: transform and then inverse transform
def round_trip_transform(ll_to_utm, utm_to_ll, lon, lat, alt=0):
    # Transform from lon/lat to UTM
    utm_x, utm_y, utm_z = ll_to_utm.TransformPoint(lon, lat, alt)
    # Transform back from UTM to lon/lat
    lon2, lat2, alt2 = utm_to_ll.TransformPoint(utm_x, utm_y, utm_z)
    return (lon2, lat2, alt2)

# 1. Basic Test Cases














def test_edge_invalid_latitude():
    # Test an invalid latitude (should raise or produce a math domain error)
    lon, lat = 0, 100  # Latitude out of range
    with pytest.raises(Exception):
        utm_transformers_from_ll(lon, lat)

def test_edge_invalid_longitude():
    # Test an invalid longitude (should raise or produce a math domain error)
    lon, lat = 200, 0  # Longitude out of range
    with pytest.raises(Exception):
        utm_transformers_from_ll(lon, lat)

# 3. Large Scale Test Cases

To edit these changes git checkout codeflash/optimize-utm_transformers_from_ll-mh4fi7bj and push.