⚡️ Speed up method GlobalGeodetic.ZoomForPixelSize by 136%

[codeflash-ai]

📄 136% (1.36x) speedup for GlobalGeodetic.ZoomForPixelSize in opendm/tiles/gdal2tiles.py

⏱️ Runtime : 2.71 milliseconds → 1.15 milliseconds (best of 302 runs)

📝 Explanation and details

The optimized code achieves a 136% speedup through two key algorithmic improvements:

1. Bitwise shift optimization in Resolution() method:

• Changed 2**zoom to (1 << zoom) for power-of-2 calculations
• Bitwise left shift is significantly faster than exponentiation for integer powers of 2
• Reduces per-call overhead from 398ns to 454ns, though this method is called less frequently in the optimized version

2. Incremental resolution calculation in ZoomForPixelSize():

• Most impactful change: Eliminated repeated calls to self.Resolution(i) inside the loop
• Instead of recalculating self.resFact / (1 << i) on each iteration, now maintains a resolution variable that starts at self.resFact and divides by 2 each iteration (resolution /= 2)
• This transforms O(i) work per iteration into O(1) work per iteration
• Line profiler shows the bottleneck shifted from expensive Resolution() calls (85.2% of time) to simple comparisons and divisions

Performance impact by test case:

• Extreme cases (very small pixelSizes requiring deep iteration): Up to 567% faster
• Mid-range cases (pixelSizes between zoom levels 1-5): 100-400% faster
• Early termination cases (large pixelSizes): 12-78% faster

The optimization is particularly effective for geospatial applications where small pixel sizes require iterating through many zoom levels to find the appropriate scale, which is common in high-resolution mapping scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from opendm.tiles.gdal2tiles import GlobalGeodetic

# function to test
MAXZOOMLEVEL = 32

# unit tests

# Helper function to get expected zoom level for a given pixelSize
def expected_zoom(geodetic, pixelSize):
    for i in range(MAXZOOMLEVEL):
        if pixelSize > geodetic.Resolution(i):
            if i != 0:
                return i-1
            else:
                return 0
    return MAXZOOMLEVEL - 1

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

def test_basic_tileSize_256_tmscompatible_true():
    # Standard tileSize, tmscompatible True
    geodetic = GlobalGeodetic(tmscompatible=True, tileSize=256)
    # pixelSize exactly at level 0 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(0)) # 1.38μs -> 1.08μs (27.5% faster)
    # pixelSize slightly larger than level 0 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(0) + 1e-6) # 485ns -> 433ns (12.0% faster)
    # pixelSize slightly smaller than level 0 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(0) - 1e-6) # 649ns -> 363ns (78.8% faster)
    # pixelSize between level 1 and level 2
    codeflash_output = geodetic.ZoomForPixelSize((geodetic.Resolution(1) + geodetic.Resolution(2)) / 2) # 913ns -> 394ns (132% faster)

def test_basic_tileSize_256_tmscompatible_false():
    # Standard tileSize, tmscompatible False
    geodetic = GlobalGeodetic(tmscompatible=False, tileSize=256)
    # pixelSize at level 0 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(0)) # 1.35μs -> 1.00μs (34.7% faster)
    # pixelSize at level 5 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(5)) # 2.11μs -> 707ns (198% faster)
    # pixelSize between level 2 and level 3
    codeflash_output = geodetic.ZoomForPixelSize((geodetic.Resolution(2) + geodetic.Resolution(3)) / 2) # 1.17μs -> 395ns (196% faster)

def test_basic_different_tile_sizes():
    # Non-standard tile size
    geodetic = GlobalGeodetic(tmscompatible=True, tileSize=512)
    # pixelSize at level 3 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(3)) # 2.20μs -> 1.18μs (86.3% faster)
    # pixelSize just above level 1 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(1) + 1e-8) # 720ns -> 422ns (70.6% faster)

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

def test_edge_pixelSize_zero():
    # pixelSize = 0 should return the highest zoom level (MAXZOOMLEVEL-1)
    geodetic = GlobalGeodetic(tmscompatible=True)
    codeflash_output = geodetic.ZoomForPixelSize(0) # 10.7μs -> 2.19μs (389% faster)

def test_edge_pixelSize_very_large():
    # pixelSize much larger than any resolution should return 0
    geodetic = GlobalGeodetic(tmscompatible=True)
    codeflash_output = geodetic.ZoomForPixelSize(1e9) # 1.00μs -> 766ns (31.2% faster)

def test_edge_pixelSize_negative():
    # pixelSize < 0 should also return the highest zoom level (MAXZOOMLEVEL-1)
    geodetic = GlobalGeodetic(tmscompatible=True)
    codeflash_output = geodetic.ZoomForPixelSize(-1e-6) # 10.2μs -> 2.03μs (404% faster)

def test_edge_pixelSize_exact_resolution_boundaries():
    # Test at exact resolution boundaries for all levels
    geodetic = GlobalGeodetic(tmscompatible=True)
    for zoom in range(0, 10):
        res = geodetic.Resolution(zoom)
        # At exact resolution, should return zoom level
        codeflash_output = geodetic.ZoomForPixelSize(res) # 18.4μs -> 5.61μs (228% faster)
        # Just below resolution, should still return zoom level
        codeflash_output = geodetic.ZoomForPixelSize(res - 1e-12)
        # Just above resolution, should return zoom-1 (or 0 if zoom==0)
        expected = zoom if zoom == 0 else zoom - 1 # 17.6μs -> 4.90μs (259% faster)
        codeflash_output = geodetic.ZoomForPixelSize(res + 1e-12)

def test_edge_tileSize_one():
    # tileSize = 1, extreme case
    geodetic = GlobalGeodetic(tmscompatible=True, tileSize=1)
    # pixelSize at level 0 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(0)) # 1.41μs -> 1.06μs (33.6% faster)
    # pixelSize = 0
    codeflash_output = geodetic.ZoomForPixelSize(0) # 9.85μs -> 1.79μs (450% faster)

def test_edge_tileSize_max():
    # tileSize = 1000, upper reasonable bound
    geodetic = GlobalGeodetic(tmscompatible=True, tileSize=1000)
    # pixelSize at level 0 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(0)) # 1.39μs -> 1.04μs (33.4% faster)
    # pixelSize at level 10 resolution
    codeflash_output = geodetic.ZoomForPixelSize(geodetic.Resolution(10)) # 3.58μs -> 936ns (282% faster)

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

def test_large_scale_many_pixelSizes():
    # Test a large number of pixelSizes in a reasonable range
    geodetic = GlobalGeodetic(tmscompatible=True)
    pixelSizes = [geodetic.Resolution(z) for z in range(0, MAXZOOMLEVEL)]
    # Test all resolutions
    for z, ps in enumerate(pixelSizes):
        codeflash_output = geodetic.ZoomForPixelSize(ps) # 148μs -> 27.5μs (441% faster)
    # Test pixelSizes between levels
    for z in range(1, MAXZOOMLEVEL):
        mid = (pixelSizes[z-1] + pixelSizes[z]) / 2
        codeflash_output = geodetic.ZoomForPixelSize(mid) # 139μs -> 25.5μs (449% faster)

def test_large_scale_random_pixelSizes():
    # Test with 1000 random pixelSizes across the range
    geodetic = GlobalGeodetic(tmscompatible=True)
    import random
    random.seed(42)
    for _ in range(1000):
        # pixelSize in [0, 1000]
        ps = random.uniform(0, 1000)
        # Compare with expected_zoom helper
        codeflash_output = geodetic.ZoomForPixelSize(ps) # 339μs -> 247μs (37.2% faster)

def test_large_scale_various_tileSizes():
    # Test with a range of tileSizes
    for tileSize in range(1, 1001, 100):
        geodetic = GlobalGeodetic(tmscompatible=True, tileSize=tileSize)
        for zoom in range(0, 10):
            ps = geodetic.Resolution(zoom)
            codeflash_output = geodetic.ZoomForPixelSize(ps)

def test_large_scale_all_zoom_levels():
    # Test all zoom levels for both tmscompatible True/False
    for tmscompatible in [True, False]:
        geodetic = GlobalGeodetic(tmscompatible=tmscompatible)
        for zoom in range(0, MAXZOOMLEVEL):
            ps = geodetic.Resolution(zoom)
            codeflash_output = geodetic.ZoomForPixelSize(ps)

# ------------------------
# DETERMINISM TEST CASE
# ------------------------

def test_determinism():
    # The function should always return the same result for the same input
    geodetic = GlobalGeodetic(tmscompatible=True)
    ps = geodetic.Resolution(5)
    results = [geodetic.ZoomForPixelSize(ps) for _ in range(10)] # 2.70μs -> 1.32μs (104% faster)

# ------------------------
# FUNCTIONALITY TEST CASES
# ------------------------

def test_functionality_various_inputs():
    # Test a variety of pixelSizes and tileSizes for functional correctness
    for tileSize in [16, 128, 256, 512]:
        for tmscompatible in [True, False]:
            geodetic = GlobalGeodetic(tmscompatible=tmscompatible, tileSize=tileSize)
            for zoom in range(0, 8):
                ps = geodetic.Resolution(zoom)
                # At each resolution, ZoomForPixelSize should return the zoom level
                codeflash_output = geodetic.ZoomForPixelSize(ps)
                # At slightly larger pixelSize, should return zoom-1 (or 0 if zoom==0)
                expected = zoom if zoom == 0 else zoom - 1
                codeflash_output = geodetic.ZoomForPixelSize(ps + 1e-8)
                # At slightly smaller pixelSize, should return zoom
                codeflash_output = geodetic.ZoomForPixelSize(ps - 1e-8)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from opendm.tiles.gdal2tiles import GlobalGeodetic

# function to test (from opendm/tiles/gdal2tiles.py, simplified for test context)
MAXZOOMLEVEL = 32

# unit tests

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

def test_basic_zoomforpixelsize_exact_resolution():
    """
    Test when pixelSize matches exactly a zoom level's resolution.
    Should return that zoom level.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    for z in range(0, 10):
        pixel_size = gg.Resolution(z)
        # If pixelSize == Resolution(z), the function should return z
        # because pixelSize > Resolution(z) is false, so loop continues,
        # and eventually returns MAXZOOMLEVEL-1, which is not correct.
        # But per function, if pixelSize == Resolution(z), it will skip to next.
        # So, test pixelSize just above and just below.
        # Let's test just above and just below.
        just_above = pixel_size + 1e-10
        just_below = pixel_size - 1e-10
        # just_above: should return z-1 (unless z==0)
        if z > 0:
            codeflash_output = gg.ZoomForPixelSize(just_above)
        else:
            codeflash_output = gg.ZoomForPixelSize(just_above)
        # just_below: should not return z-1, but continue to next zoom
        # So for just_below, the function will keep going until it finds a zoom where pixelSize > Resolution(i)
        # So for just_below, the answer should be z (since at z, pixelSize < Resolution(z), but at z+1, pixelSize > Resolution(z+1))
        # Let's check that
        if z < MAXZOOMLEVEL-1:
            codeflash_output = gg.ZoomForPixelSize(just_below)

def test_basic_zoomforpixelsize_typical_values():
    """
    Test typical pixel sizes that fall between zoom levels.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    # Between zoom 2 and 3
    res2 = gg.Resolution(2)
    res3 = gg.Resolution(3)
    # Pick a pixelSize between res2 and res3
    pixelSize = (res2 + res3) / 2
    # Should return zoom 2 (the highest zoom where Resolution(z) >= pixelSize)
    codeflash_output = gg.ZoomForPixelSize(pixelSize) # 1.93μs -> 1.19μs (61.7% faster)

    # Between zoom 0 and 1
    res0 = gg.Resolution(0)
    res1 = gg.Resolution(1)
    pixelSize = (res0 + res1) / 2
    codeflash_output = gg.ZoomForPixelSize(pixelSize) # 759ns -> 461ns (64.6% faster)

def test_basic_zoomforpixelsize_tmscompatible_false():
    """
    Test with tmscompatible=False (different resFact).
    """
    gg = GlobalGeodetic(tmscompatible=False, tileSize=256)
    # Try a pixelSize between zoom 1 and 2
    res1 = gg.Resolution(1)
    res2 = gg.Resolution(2)
    pixelSize = (res1 + res2) / 2
    codeflash_output = gg.ZoomForPixelSize(pixelSize) # 1.66μs -> 1.13μs (46.7% faster)

def test_basic_zoomforpixelsize_tileSize_variation():
    """
    Test with different tileSize values.
    """
    for tileSize in [128, 256, 512]:
        gg = GlobalGeodetic(tmscompatible=True, tileSize=tileSize)

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

def test_edge_zoomforpixelsize_zero_and_negative():
    """
    Test pixelSize of 0 and negative values.
    Should return the highest zoom level (MAXZOOMLEVEL-1).
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    codeflash_output = gg.ZoomForPixelSize(0) # 10.8μs -> 2.35μs (362% faster)
    codeflash_output = gg.ZoomForPixelSize(-1.0) # 9.21μs -> 1.50μs (515% faster)
    codeflash_output = gg.ZoomForPixelSize(-1e10) # 8.71μs -> 1.31μs (567% faster)

def test_edge_zoomforpixelsize_large_pixel_size():
    """
    Test very large pixelSize (much larger than zoom 0 resolution).
    Should return zoom 0 (lowest zoom, no scale up).
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    huge_pixel_size = gg.Resolution(0) * 10
    codeflash_output = gg.ZoomForPixelSize(huge_pixel_size) # 938ns -> 836ns (12.2% faster)

def test_edge_zoomforpixelsize_exactly_on_resolution_boundaries():
    """
    Test pixelSize exactly equal to the resolution at each zoom.
    Should always return the zoom level, since the for-loop will not trigger until pixelSize > Resolution(i).
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    for z in range(0, 10):
        pixelSize = gg.Resolution(z)
        # The function will not return until pixelSize > Resolution(i), so it will keep looping.
        # If pixelSize == Resolution(z), it will continue to next zoom.
        # So, if pixelSize == Resolution(MAXZOOMLEVEL-1), it will finish the loop and return MAXZOOMLEVEL-1.
        # Let's check for z < MAXZOOMLEVEL-1
        if z < MAXZOOMLEVEL-1:
            codeflash_output = gg.ZoomForPixelSize(pixelSize)
        else:
            # For the last zoom, it should return MAXZOOMLEVEL-1
            codeflash_output = gg.ZoomForPixelSize(pixelSize)

def test_edge_zoomforpixelsize_very_small_pixel_size():
    """
    Test pixelSize much smaller than the smallest resolution.
    Should return MAXZOOMLEVEL-1.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    tiny_pixel_size = 1e-20
    codeflash_output = gg.ZoomForPixelSize(tiny_pixel_size) # 10.0μs -> 2.00μs (399% faster)

def test_edge_zoomforpixelsize_just_below_and_above_resolution():
    """
    Test pixelSize just below and just above a zoom's resolution.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    for z in range(1, 5):
        res = gg.Resolution(z)
        just_below = res - 1e-12
        just_above = res + 1e-12
        # just_below: should not trigger return at this zoom, so should return z
        codeflash_output = gg.ZoomForPixelSize(just_below) # 5.74μs -> 2.39μs (141% faster)
        # just_above: should trigger return at z, so should return z-1
        codeflash_output = gg.ZoomForPixelSize(just_above)

def test_edge_zoomforpixelsize_non_integer_tileSize():
    """
    Test with a non-integer tileSize.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=255.5)
    # Should not raise, and should calculate resolutions accordingly
    res0 = gg.Resolution(0)
    pixelSize = res0 / 2
    # Should return zoom 1
    codeflash_output = gg.ZoomForPixelSize(pixelSize) # 1.65μs -> 1.12μs (47.7% faster)

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

def test_large_zoomforpixelsize_many_pixel_sizes():
    """
    Test the function with a large number of pixel sizes, spanning the full range.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    # Generate 1000 pixel sizes from very small to very large
    min_ps = 1e-10
    max_ps = gg.Resolution(0) * 10
    step = (max_ps - min_ps) / 999
    pixel_sizes = [min_ps + i*step for i in range(1000)]
    # For each, ensure the returned zoom is within valid range
    for ps in pixel_sizes:
        codeflash_output = gg.ZoomForPixelSize(ps); z = codeflash_output # 392μs -> 255μs (53.7% faster)

def test_large_zoomforpixelsize_all_zoom_levels():
    """
    For every zoom level, test pixel sizes just above and just below the resolution.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    for z in range(1, MAXZOOMLEVEL-1):
        res = gg.Resolution(z)
        # just below: should return z
        codeflash_output = gg.ZoomForPixelSize(res - 1e-14) # 141μs -> 26.3μs (438% faster)
        # just above: should return z-1
        codeflash_output = gg.ZoomForPixelSize(res + 1e-14)

def test_large_zoomforpixelsize_performance():
    """
    Performance test: ensure the function is efficient for many calls.
    """
    gg = GlobalGeodetic(tmscompatible=True, tileSize=256)
    # 1000 calls with random pixelSizes
    import random
    for _ in range(1000):
        ps = random.uniform(gg.Resolution(MAXZOOMLEVEL-1)/10, gg.Resolution(0)*10)
        codeflash_output = gg.ZoomForPixelSize(ps); z = codeflash_output # 375μs -> 256μs (46.4% faster)

def test_large_zoomforpixelsize_various_tile_sizes():
    """
    Test a range of tile sizes with various pixel sizes.
    """
    for tileSize in range(128, 1025, 128):  # 128, 256, ..., 1024
        gg = GlobalGeodetic(tmscompatible=True, tileSize=tileSize)
        for z in range(0, 5):
            ps = gg.Resolution(z)
            # just below
            codeflash_output = gg.ZoomForPixelSize(ps - 1e-10)
            # just above
            if z > 0:
                codeflash_output = gg.ZoomForPixelSize(ps + 1e-10)
            else:
                codeflash_output = gg.ZoomForPixelSize(ps + 1e-10)
# 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-GlobalGeodetic.ZoomForPixelSize-mh500z0z and push.