⚡️ Speed up function thin_one_time by 557%

[codeflash-ai]

📄 557% (5.57x) speedup for thin_one_time in invokeai/app/util/controlnet_utils.py

⏱️ Runtime : 40.7 milliseconds → 6.20 milliseconds (best of 152 runs)

📝 Explanation and details

The optimized code achieves a 556% speedup by eliminating the expensive np.where() operation and replacing it with more efficient NumPy operations.

Key optimizations:

1. Replaced np.where() with boolean masking: The original code used np.where(objects > 127) which returns tuple of indices and required 66.9% of total execution time. The optimized version converts the morphology result directly to a boolean mask using objects.astype(bool), which is much faster since OpenCV's MORPH_HITMISS outputs binary values (0 or 255).

2. Direct boolean indexing: Instead of using the tuple of indices from np.where() for assignment, the optimized code uses direct boolean mask indexing (x[mask] = 0), which is significantly more efficient in NumPy.

3. Efficient existence check: Replaced objects[0].shape[0] > 0 with np.any(mask) to check if any updates are needed, avoiding tuple unpacking and shape operations.

Performance impact by test case type:

• Large-scale tests show the most dramatic improvements (435-972% faster), indicating the optimization scales very well with array size
• Dense pattern tests benefit most (971% faster for large dense patterns) because they involve more pixel updates where the boolean masking advantage is maximized
• Sparse and no-update cases still see substantial gains (349-438% faster) due to eliminating the expensive np.where() call
• Small basic tests show modest but consistent improvements (1-15% faster)

The optimization is particularly effective for morphological operations on large images with many pattern matches, which is typical in computer vision workflows where ControlNet utilities are commonly used.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import cv2
import numpy as np
# imports
import pytest  # used for our unit tests
from invokeai.app.util.controlnet_utils import thin_one_time

# unit tests

# --- Basic Test Cases ---

def test_basic_no_update():
    # All zeros, no pattern to remove
    x = np.zeros((5,5), dtype=np.uint8)
    kernels = [np.ones((3,3), dtype=np.uint8)]
    y, is_done = thin_one_time(x.copy(), kernels) # 26.0μs -> 24.2μs (7.31% faster)

def test_basic_single_update():
    # Single pattern matches kernel
    x = np.zeros((5,5), dtype=np.uint8)
    x[2,2] = 255
    kernel = np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 27.1μs -> 26.8μs (1.05% faster)
    # The center should be set to 0, is_done should be False
    expected = np.zeros((5,5), dtype=np.uint8)

def test_basic_multiple_kernels():
    # Multiple kernels, only one matches
    x = np.zeros((5,5), dtype=np.uint8)
    x[1,1] = 255
    kernels = [
        np.ones((3,3), dtype=np.uint8),
        np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    ]
    y, is_done = thin_one_time(x.copy(), kernels) # 36.7μs -> 35.6μs (2.96% faster)
    # Only the second kernel matches, so (1,1) should be set to 0
    expected = np.zeros((5,5), dtype=np.uint8)

def test_basic_no_match_with_kernels():
    # No kernel matches, so no change
    x = np.zeros((5,5), dtype=np.uint8)
    x[2,2] = 255
    kernels = [np.ones((3,3), dtype=np.uint8)]
    y, is_done = thin_one_time(x.copy(), kernels) # 23.2μs -> 20.1μs (15.6% faster)

# --- Edge Test Cases ---


def test_edge_empty_kernel_list():
    # No kernels
    x = np.ones((5,5), dtype=np.uint8) * 255
    kernels = []
    y, is_done = thin_one_time(x.copy(), kernels) # 641ns -> 651ns (1.54% slower)

def test_edge_non_square_image():
    # Non-square image
    x = np.zeros((3,5), dtype=np.uint8)
    x[1,2] = 255
    kernel = np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 43.1μs -> 42.8μs (0.778% faster)
    expected = np.zeros((3,5), dtype=np.uint8)

def test_edge_non_square_kernel():
    # Non-square kernel
    x = np.zeros((5,5), dtype=np.uint8)
    x[2,2] = 255
    kernel = np.array([[0,1,0]], dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 32.7μs -> 30.3μs (7.93% faster)

def test_edge_all_ones_image():
    # All ones (255), kernel matches everywhere
    x = np.ones((5,5), dtype=np.uint8) * 255
    kernel = np.ones((3,3), dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 26.1μs -> 27.5μs (4.97% slower)
    # All pixels except border should be set to 0
    expected = x.copy()
    expected[1:-1,1:-1] = 0

def test_edge_border_behavior():
    # Pattern at border, kernel cannot match
    x = np.zeros((5,5), dtype=np.uint8)
    x[0,0] = 255
    kernel = np.ones((3,3), dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 27.2μs -> 24.3μs (12.0% faster)

def test_edge_dtype_variations():
    # Test with different uint types
    x = np.zeros((5,5), dtype=np.uint16)
    x[2,2] = 255
    kernel = np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    # Convert to uint8 for cv2 compatibility
    y, is_done = thin_one_time(x.astype(np.uint8), [kernel]) # 27.5μs -> 26.8μs (2.31% faster)
    expected = np.zeros((5,5), dtype=np.uint8)

def test_edge_large_kernel_smaller_than_image():
    # Kernel larger than image, should not match
    x = np.ones((3,3), dtype=np.uint8) * 255
    kernel = np.ones((5,5), dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 23.8μs -> 26.1μs (8.86% slower)

def test_edge_multiple_updates():
    # Two kernels, both match different spots
    x = np.zeros((5,5), dtype=np.uint8)
    x[1,1] = 255
    x[3,3] = 255
    kernels = [
        np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8),
        np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    ]
    y, is_done = thin_one_time(x.copy(), kernels) # 37.3μs -> 35.2μs (6.21% faster)
    expected = np.zeros((5,5), dtype=np.uint8)

# --- Large Scale Test Cases ---

def test_large_scale_image_all_zeros():
    # Large image, all zeros
    x = np.zeros((1000,1000), dtype=np.uint8)
    kernel = np.ones((3,3), dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 1.92ms -> 359μs (435% faster)

def test_large_scale_image_sparse_pattern():
    # Large image, sparse pattern
    x = np.zeros((1000,1000), dtype=np.uint8)
    for i in range(0, 1000, 100):
        x[i,i] = 255
    kernel = np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 1.90ms -> 418μs (353% faster)
    expected = np.zeros((1000,1000), dtype=np.uint8)

def test_large_scale_image_dense_pattern():
    # Large image, dense pattern
    x = np.ones((1000,1000), dtype=np.uint8) * 255
    kernel = np.ones((3,3), dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 7.58ms -> 708μs (971% faster)
    # Border remains, center set to 0
    expected = x.copy()
    expected[1:-1,1:-1] = 0

def test_large_scale_multiple_kernels():
    # Large image, multiple kernels
    x = np.ones((1000,1000), dtype=np.uint8) * 255
    kernels = [
        np.ones((3,3), dtype=np.uint8),
        np.array([[0,0,0],[0,1,0],[0,0,0]], dtype=np.uint8)
    ]
    y, is_done = thin_one_time(x.copy(), kernels) # 9.46ms -> 1.01ms (839% faster)
    # Both kernels match, so center set to 0
    expected = x.copy()
    expected[1:-1,1:-1] = 0

def test_large_scale_no_update():
    # Large image, no matching kernel
    x = np.zeros((1000,1000), dtype=np.uint8)
    kernel = np.ones((3,3), dtype=np.uint8)
    y, is_done = thin_one_time(x.copy(), [kernel]) # 1.93ms -> 358μs (438% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import cv2
import numpy as np
# imports
import pytest  # used for our unit tests
from invokeai.app.util.controlnet_utils import thin_one_time

# unit tests

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

def test_basic_no_update():
    # 3x3 matrix, all zeros, kernel won't match anything
    arr = np.zeros((3,3), dtype=np.uint8)
    kernel = np.ones((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 42.3μs -> 37.6μs (12.6% faster)

def test_basic_single_update():
    # 3x3 matrix, center pixel is 255, kernel matches only center
    arr = np.zeros((3,3), dtype=np.uint8)
    arr[1,1] = 255
    kernel = np.zeros((3,3), dtype=np.uint8)
    kernel[1,1] = 1
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 34.5μs -> 33.3μs (3.58% faster)
    # Center pixel should be set to 0, is_done should be False
    expected = np.zeros((3,3), dtype=np.uint8)

def test_basic_multiple_kernels():
    # 3x3 matrix, two kernels match different pixels
    arr = np.zeros((3,3), dtype=np.uint8)
    arr[0,0] = 255
    arr[2,2] = 255
    k1 = np.zeros((3,3), dtype=np.uint8)
    k1[0,0] = 1
    k2 = np.zeros((3,3), dtype=np.uint8)
    k2[2,2] = 1
    res, is_done = thin_one_time(arr.copy(), [k1, k2]) # 40.7μs -> 39.0μs (4.28% faster)
    expected = np.zeros((3,3), dtype=np.uint8)

def test_basic_no_matching_kernels():
    # 3x3 matrix, kernel doesn't match any pixel
    arr = np.zeros((3,3), dtype=np.uint8)
    arr[1,1] = 255
    kernel = np.ones((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 25.2μs -> 22.0μs (14.4% faster)

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


def test_edge_single_pixel():
    # 1x1 array, kernel matches single pixel
    arr = np.array([[255]], dtype=np.uint8)
    kernel = np.array([[1]], dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 43.5μs -> 40.5μs (7.43% faster)
    expected = np.array([[0]], dtype=np.uint8)

def test_edge_non_square_array():
    # 2x3 array, test with matching kernel
    arr = np.zeros((2,3), dtype=np.uint8)
    arr[0,1] = 255
    kernel = np.zeros((2,3), dtype=np.uint8)
    kernel[0,1] = 1
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 34.8μs -> 33.0μs (5.38% faster)
    expected = np.zeros((2,3), dtype=np.uint8)

def test_edge_multiple_updates():
    # 3x3 matrix, kernel matches multiple pixels
    arr = np.full((3,3), 255, dtype=np.uint8)
    kernel = np.ones((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 30.0μs -> 28.6μs (4.87% faster)
    expected = np.zeros((3,3), dtype=np.uint8)

def test_edge_kernel_larger_than_image():
    # Kernel larger than image, should not match
    arr = np.ones((2,2), dtype=np.uint8) * 255
    kernel = np.ones((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 23.7μs -> 26.4μs (10.3% slower)

def test_edge_kernel_smaller_than_image():
    # Kernel smaller than image, matches part of image
    arr = np.zeros((5,5), dtype=np.uint8)
    arr[2,2] = 255
    kernel = np.zeros((1,1), dtype=np.uint8)
    kernel[0,0] = 1
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 25.4μs -> 24.3μs (4.57% faster)
    expected = np.zeros((5,5), dtype=np.uint8)

def test_edge_zero_kernel():
    # Kernel is all zeros, should not match anything
    arr = np.ones((3,3), dtype=np.uint8) * 255
    kernel = np.zeros((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 15.8μs -> 17.9μs (11.3% slower)

def test_edge_multiple_identical_kernels():
    # Multiple identical kernels, should only update once
    arr = np.zeros((3,3), dtype=np.uint8)
    arr[1,1] = 255
    kernel = np.zeros((3,3), dtype=np.uint8)
    kernel[1,1] = 1
    res, is_done = thin_one_time(arr.copy(), [kernel, kernel]) # 38.5μs -> 38.3μs (0.614% faster)
    expected = np.zeros((3,3), dtype=np.uint8)

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

def test_large_scale_no_update():
    # Large array, kernel does not match anything
    arr = np.zeros((1000,1000), dtype=np.uint8)
    kernel = np.ones((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 1.93ms -> 360μs (435% faster)

def test_large_scale_single_update():
    # Large array, kernel matches one pixel
    arr = np.zeros((1000,1000), dtype=np.uint8)
    arr[500,500] = 255
    kernel = np.zeros((3,3), dtype=np.uint8)
    kernel[1,1] = 1
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 1.89ms -> 421μs (349% faster)
    expected = np.zeros((1000,1000), dtype=np.uint8)

def test_large_scale_multiple_updates():
    # Large array, kernel matches many pixels
    arr = np.full((1000,1000), 255, dtype=np.uint8)
    kernel = np.ones((3,3), dtype=np.uint8)
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 7.59ms -> 708μs (972% faster)
    expected = np.zeros((1000,1000), dtype=np.uint8)

def test_large_scale_multiple_kernels():
    # Large array, multiple kernels matching different regions
    arr = np.zeros((1000,1000), dtype=np.uint8)
    arr[100,100] = 255
    arr[900,900] = 255
    k1 = np.zeros((3,3), dtype=np.uint8)
    k1[1,1] = 1
    k2 = np.zeros((3,3), dtype=np.uint8)
    k2[2,2] = 1
    res, is_done = thin_one_time(arr.copy(), [k1, k2]) # 3.90ms -> 824μs (373% faster)
    expected = np.zeros((1000,1000), dtype=np.uint8)

def test_large_scale_edge_pixels():
    # Large array, kernel matches only edge pixels
    arr = np.zeros((1000,1000), dtype=np.uint8)
    arr[0,0] = 255
    arr[0,999] = 255
    arr[999,0] = 255
    arr[999,999] = 255
    kernel = np.zeros((3,3), dtype=np.uint8)
    kernel[0,0] = 1
    kernel[0,2] = 1
    kernel[2,0] = 1
    kernel[2,2] = 1
    res, is_done = thin_one_time(arr.copy(), [kernel]) # 1.88ms -> 314μs (498% faster)
    expected = np.zeros((1000,1000), dtype=np.uint8)

# ---- Miscellaneous Test Cases ----

def test_no_kernels():
    # No kernels provided, should not update anything
    arr = np.ones((3,3), dtype=np.uint8) * 255
    res, is_done = thin_one_time(arr.copy(), []) # 562ns -> 580ns (3.10% slower)

def test_input_not_modified():
    # Ensure input array is not modified in-place
    arr = np.ones((3,3), dtype=np.uint8) * 255
    arr_copy = arr.copy()
    kernel = np.ones((3,3), dtype=np.uint8)
    thin_one_time(arr, [kernel]) # 32.2μs -> 34.9μs (7.71% slower)

def test_kernels_not_modified():
    # Ensure kernels are not modified in-place
    kernel = np.ones((3,3), dtype=np.uint8)
    kernels = [kernel.copy()]
    kernels_copy = [k.copy() for k in kernels]
    arr = np.ones((3,3), dtype=np.uint8) * 255
    thin_one_time(arr, kernels) # 22.2μs -> 25.8μs (14.1% slower)
    for k, k_copy in zip(kernels, kernels_copy):
        pass
# 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-thin_one_time-mhn8qh8w and push.