mirror of
https://github.com/ChuckBuilds/LEDMatrix.git
synced 2026-08-01 08:48:05 +00:00
ChuckBuildsandClaude
105c6df019
A cut position after the last column is legitimate — _crop_to_budget asks for min(start + budget, img.width), which equals the width whenever the remaining strip is shorter than the budget. find_blank_cut clamped target to width but then walked leftwards starting at target itself, so ink[width] raised IndexError. Caught on hardware: it killed the ledmatrix-stocks fetch, and because _fetch_plugin_content catches broadly that surfaced as the plugin silently contributing nothing for the cycle. Only reachable on the second or later pass of the rotating window over a single oversized image, which is why the existing tests missed it — they all exercised the first pass, where start is 0 and start + budget is comfortably inside the image. Added TestRotationAcrossMultipleCycles, which walks the window round several times and asserts content is never lost, plus direct coverage of find_blank_cut at and beyond the image edge. Both bounds now stop at width - 1 so neither direction can index past the end. Co-Authored-By: Claude <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KEZK1P1Q1fu5pcuVrkrCFZ
371 lines
15 KiB
Python
371 lines
15 KiB
Python
"""Tests for Vegas mode geometry primitives."""
|
|
|
|
import numpy as np
|
|
import pytest
|
|
from PIL import Image
|
|
|
|
from src.vegas_mode.geometry import (
|
|
DEFAULT_INK_THRESHOLD,
|
|
column_has_ink,
|
|
content_bounds,
|
|
dead_window_stats,
|
|
edge_blank,
|
|
find_blank_cut,
|
|
separation_gap,
|
|
trim_to_content,
|
|
window_coverage_stats,
|
|
)
|
|
|
|
|
|
def make_img(width, height=8, fill=(0, 0, 0)):
|
|
return Image.new('RGB', (width, height), fill)
|
|
|
|
|
|
def paint(img, x0, x1, color=(255, 255, 255)):
|
|
"""Fill columns [x0, x1) with a colour."""
|
|
block = Image.new('RGB', (x1 - x0, img.height), color)
|
|
img.paste(block, (x0, 0))
|
|
return img
|
|
|
|
|
|
class TestColumnHasInk:
|
|
def test_all_black_has_no_ink(self):
|
|
assert not column_has_ink(make_img(16)).any()
|
|
|
|
def test_marks_only_painted_columns(self):
|
|
img = paint(make_img(16), 4, 8)
|
|
ink = column_has_ink(img)
|
|
assert ink.tolist() == [False] * 4 + [True] * 4 + [False] * 8
|
|
|
|
def test_threshold_is_exclusive(self):
|
|
# A pixel exactly at the threshold is not ink; one above it is.
|
|
at = paint(make_img(4), 0, 4, (DEFAULT_INK_THRESHOLD,) * 3)
|
|
above = paint(make_img(4), 0, 4, (DEFAULT_INK_THRESHOLD + 1,) * 3)
|
|
assert not column_has_ink(at).any()
|
|
assert column_has_ink(above).all()
|
|
|
|
def test_single_bright_channel_counts(self):
|
|
img = paint(make_img(4), 1, 2, (0, 0, 200))
|
|
assert column_has_ink(img).tolist() == [False, True, False, False]
|
|
|
|
def test_one_lit_pixel_lights_the_column(self):
|
|
img = make_img(4, height=8)
|
|
img.putpixel((2, 5), (255, 255, 255))
|
|
assert column_has_ink(img).tolist() == [False, False, True, False]
|
|
|
|
|
|
class TestContentBounds:
|
|
def test_blank_returns_none(self):
|
|
assert content_bounds(make_img(16)) is None
|
|
|
|
def test_finds_inclusive_bounds(self):
|
|
assert content_bounds(paint(make_img(20), 5, 12)) == (5, 11)
|
|
|
|
def test_full_width_content(self):
|
|
assert content_bounds(paint(make_img(10), 0, 10)) == (0, 9)
|
|
|
|
def test_spans_interior_gap(self):
|
|
img = paint(make_img(30), 2, 5)
|
|
paint(img, 20, 25)
|
|
assert content_bounds(img) == (2, 24)
|
|
|
|
|
|
class TestTrimToContent:
|
|
def test_blank_image_reports_blank(self):
|
|
result = trim_to_content(make_img(512))
|
|
assert result.is_blank
|
|
assert result.image is None
|
|
assert result.width == 0
|
|
assert result.original_width == 512
|
|
|
|
def test_trims_both_edges(self):
|
|
result = trim_to_content(paint(make_img(512), 100, 150))
|
|
assert not result.is_blank
|
|
assert result.width == 50
|
|
assert result.trimmed_left == 100
|
|
assert result.trimmed_right == 362
|
|
assert result.removed == 462
|
|
|
|
def test_preserves_interior_gap(self):
|
|
# Two content blocks with a wide blank between them: the gap is the
|
|
# plugin's layout and must survive trimming.
|
|
img = paint(make_img(400), 50, 80)
|
|
paint(img, 300, 330)
|
|
result = trim_to_content(img)
|
|
assert result.width == 280 # 50..329 inclusive
|
|
assert column_has_ink(result.image).sum() == 60
|
|
|
|
def test_full_width_content_is_returned_unchanged(self):
|
|
img = paint(make_img(128), 0, 128)
|
|
result = trim_to_content(img)
|
|
assert result.image is img
|
|
assert result.removed == 0
|
|
|
|
def test_non_black_background_is_never_trimmed(self):
|
|
# A plugin drawing on a dark-but-not-black background fills every
|
|
# column with ink, so there is nothing to reclaim.
|
|
result = trim_to_content(make_img(256, fill=(0, 0, 40)))
|
|
assert result.removed == 0
|
|
assert result.width == 256
|
|
|
|
def test_padding_keeps_margin_up_to_what_exists(self):
|
|
result = trim_to_content(paint(make_img(512), 100, 150), padding=8)
|
|
assert result.trimmed_left == 92
|
|
assert result.width == 66 # 50 content + 8 each side
|
|
|
|
def test_padding_cannot_widen_beyond_original(self):
|
|
# Content starts 2px in; padding of 8 can only reclaim the 2 available.
|
|
result = trim_to_content(paint(make_img(64), 2, 60), padding=8)
|
|
assert result.trimmed_left == 0
|
|
assert result.trimmed_right == 0
|
|
assert result.width == 64
|
|
|
|
def test_height_is_preserved(self):
|
|
result = trim_to_content(paint(make_img(200, height=64), 10, 20))
|
|
assert result.image.height == 64
|
|
|
|
def test_real_world_of_the_day_case(self):
|
|
# Measured on devpi: "No Data" occupying 35px of a 512px canvas.
|
|
result = trim_to_content(paint(make_img(512, height=64), 4, 39))
|
|
assert result.width == 35
|
|
assert result.removed == 477
|
|
|
|
|
|
class TestDeadWindowStats:
|
|
def test_fully_inked_ticker_has_no_dead_windows(self):
|
|
stats = dead_window_stats(paint(make_img(400), 0, 400), viewport_width=100)
|
|
assert stats.dead_windows == 0
|
|
assert stats.dead_ratio == 0.0
|
|
assert stats.longest_dead_run == 0
|
|
|
|
def test_fully_blank_ticker_is_all_dead(self):
|
|
stats = dead_window_stats(make_img(400), viewport_width=100)
|
|
assert stats.total_windows == 301
|
|
assert stats.dead_windows == 301
|
|
assert stats.dead_ratio == 1.0
|
|
assert stats.longest_dead_run == 301
|
|
|
|
def test_leading_blank_run_is_measured(self):
|
|
# 512px of black then solid content: windows fully inside the black
|
|
# stretch are dead. With a 100px viewport, starts 0..412 exist and a
|
|
# window is dead while it holds >=95 blank columns.
|
|
img = paint(make_img(1024), 512, 1024)
|
|
stats = dead_window_stats(img, viewport_width=100)
|
|
assert stats.dead_windows == 418 # starts 0..417 keep >=95 blank cols
|
|
assert stats.longest_dead_run == 418
|
|
|
|
def test_narrow_content_island_still_leaves_dead_windows(self):
|
|
# 35px of content in a 512px field, viewed 100px at a time: no window
|
|
# can be 95% blank once it overlaps 35 lit columns, but the windows
|
|
# clear of it are dead.
|
|
img = paint(make_img(512), 100, 135)
|
|
stats = dead_window_stats(img, viewport_width=100)
|
|
assert stats.dead_windows > 0
|
|
assert stats.dead_ratio == pytest.approx(
|
|
stats.dead_windows / stats.total_windows
|
|
)
|
|
|
|
def test_step_reduces_sampling(self):
|
|
img = paint(make_img(1000), 500, 1000)
|
|
exact = dead_window_stats(img, viewport_width=100, step=1)
|
|
strided = dead_window_stats(img, viewport_width=100, step=10)
|
|
assert strided.total_windows < exact.total_windows
|
|
# Same underlying shape, so the ratios should stay close.
|
|
assert strided.dead_ratio == pytest.approx(exact.dead_ratio, abs=0.02)
|
|
|
|
def test_image_narrower_than_viewport_is_one_window(self):
|
|
stats = dead_window_stats(make_img(50), viewport_width=100)
|
|
assert stats.total_windows == 1
|
|
assert stats.dead_windows == 1
|
|
|
|
def test_zero_viewport_is_handled(self):
|
|
stats = dead_window_stats(make_img(50), viewport_width=0)
|
|
assert stats.total_windows == 0
|
|
assert stats.dead_ratio == 0.0
|
|
|
|
def test_longest_run_picks_the_larger_of_two_gaps(self):
|
|
# Short blank gap, content, then a long blank gap.
|
|
img = make_img(1000)
|
|
paint(img, 150, 400)
|
|
paint(img, 500, 520)
|
|
stats = dead_window_stats(img, viewport_width=100)
|
|
# The 400..500 gap is only 100 wide; the tail from 520 is 480 wide.
|
|
assert stats.longest_dead_run >= 380
|
|
|
|
|
|
class TestWindowCoverageStats:
|
|
def test_solid_content_is_fully_covered(self):
|
|
stats = window_coverage_stats(paint(make_img(600), 0, 600), viewport_width=100)
|
|
assert stats.mean_ink_ratio == 1.0
|
|
assert stats.min_ink_ratio == 1.0
|
|
assert stats.sparse_windows == 0
|
|
|
|
def test_blank_strip_is_entirely_sparse(self):
|
|
stats = window_coverage_stats(make_img(600), viewport_width=100)
|
|
assert stats.mean_ink_ratio == 0.0
|
|
assert stats.sparse_ratio == 1.0
|
|
|
|
def test_catches_sliver_windows_that_dead_ratio_misses(self):
|
|
# Narrow content islands separated by more than the viewport. A window
|
|
# holding one whole 40px island carries 472 blank columns — under the
|
|
# 486 needed to count as "dead" — yet only 7.8% ink, so it still reads
|
|
# as an empty panel. Coverage must flag strictly more positions than
|
|
# the dead-window scan does.
|
|
img = paint(make_img(2000), 0, 40)
|
|
paint(img, 1000, 1040)
|
|
dead = dead_window_stats(img, viewport_width=512)
|
|
cover = window_coverage_stats(img, viewport_width=512, sparse_ink_ratio=0.10)
|
|
assert cover.sparse_windows > dead.dead_windows
|
|
assert cover.min_ink_ratio == 0.0
|
|
|
|
def test_adjacent_full_width_segments_stay_partially_covered(self):
|
|
# Documents why the dead-window scan alone understated the problem:
|
|
# two 512px segments with mid-canvas content never fully blank the
|
|
# viewport, they just hold it at a thin ~28%.
|
|
img = paint(make_img(1024), 185, 330)
|
|
paint(img, 697, 842)
|
|
dead = dead_window_stats(img, viewport_width=512)
|
|
cover = window_coverage_stats(img, viewport_width=512)
|
|
assert dead.dead_windows == 0
|
|
assert cover.mean_ink_ratio == pytest.approx(0.283, abs=0.01)
|
|
|
|
def test_min_ink_ratio_finds_the_worst_position(self):
|
|
# A wide blank tail guarantees at least one totally empty viewport.
|
|
img = paint(make_img(1200), 0, 200)
|
|
stats = window_coverage_stats(img, viewport_width=200)
|
|
assert stats.min_ink_ratio == 0.0
|
|
assert stats.mean_ink_ratio > 0.0
|
|
|
|
def test_sparse_threshold_is_respected(self):
|
|
# 40 inked columns in a 200px viewport = 20% coverage everywhere the
|
|
# island is fully inside the window.
|
|
img = paint(make_img(400), 100, 140)
|
|
lenient = window_coverage_stats(img, viewport_width=200, sparse_ink_ratio=0.05)
|
|
strict = window_coverage_stats(img, viewport_width=200, sparse_ink_ratio=0.50)
|
|
assert strict.sparse_windows > lenient.sparse_windows
|
|
|
|
def test_step_approximates_exact_scan(self):
|
|
img = paint(make_img(2000), 300, 500)
|
|
paint(img, 1200, 1400)
|
|
exact = window_coverage_stats(img, viewport_width=512, step=1)
|
|
strided = window_coverage_stats(img, viewport_width=512, step=4)
|
|
assert strided.mean_ink_ratio == pytest.approx(exact.mean_ink_ratio, abs=0.01)
|
|
|
|
def test_zero_viewport_is_handled(self):
|
|
stats = window_coverage_stats(make_img(50), viewport_width=0)
|
|
assert stats.total_windows == 0
|
|
assert stats.sparse_ratio == 0.0
|
|
|
|
def test_image_narrower_than_viewport(self):
|
|
stats = window_coverage_stats(paint(make_img(50), 0, 50), viewport_width=100)
|
|
assert stats.total_windows == 1
|
|
assert stats.mean_ink_ratio == pytest.approx(0.5)
|
|
|
|
|
|
class TestLongestRunHelper:
|
|
@pytest.mark.parametrize("flags,expected", [
|
|
([], 0),
|
|
([False, False], 0),
|
|
([True], 1),
|
|
([True, True, False, True], 2),
|
|
([False, True, True, True, False, True], 3),
|
|
([True, True, True], 3),
|
|
])
|
|
def test_run_lengths(self, flags, expected):
|
|
from src.vegas_mode.geometry import _longest_true_run
|
|
assert _longest_true_run(np.array(flags, dtype=bool)) == expected
|
|
|
|
|
|
class TestEdgeBlank:
|
|
def test_measures_both_edges(self):
|
|
assert edge_blank(paint(make_img(100), 20, 60)) == (20, 40)
|
|
|
|
def test_flush_content_has_no_blank(self):
|
|
assert edge_blank(paint(make_img(50), 0, 50)) == (0, 0)
|
|
|
|
def test_blank_image_reports_full_width_both_sides(self):
|
|
# No ink means nothing to be close to.
|
|
assert edge_blank(make_img(64)) == (64, 64)
|
|
|
|
|
|
class TestSeparationGap:
|
|
def test_flush_edges_get_the_full_target(self):
|
|
a = paint(make_img(50), 0, 50)
|
|
b = paint(make_img(50), 0, 50)
|
|
assert separation_gap(a, b, target=24) == 24
|
|
|
|
def test_existing_margins_reduce_the_added_gap(self):
|
|
# 8px blank on each facing edge already covers 16 of the 24 target.
|
|
a = paint(make_img(50), 0, 42)
|
|
b = paint(make_img(50), 8, 50)
|
|
assert separation_gap(a, b, target=24) == 8
|
|
|
|
def test_ample_existing_margin_adds_nothing(self):
|
|
a = paint(make_img(100), 0, 60)
|
|
b = paint(make_img(100), 40, 100)
|
|
assert separation_gap(a, b, target=24) == 0
|
|
|
|
def test_minimum_is_a_floor(self):
|
|
a = paint(make_img(100), 0, 60)
|
|
b = paint(make_img(100), 40, 100)
|
|
assert separation_gap(a, b, target=24, minimum=4) == 4
|
|
|
|
def test_never_negative(self):
|
|
a = paint(make_img(200), 0, 10)
|
|
b = paint(make_img(200), 190, 200)
|
|
assert separation_gap(a, b, target=8) == 0
|
|
|
|
def test_sports_card_case_gets_real_separation(self):
|
|
# The reported problem: cards drawn edge to edge sat 8px apart under a
|
|
# flat gap; measured separation lifts them to the 24px target.
|
|
card = paint(make_img(150), 0, 150)
|
|
assert separation_gap(card, card, target=24, minimum=8) == 24
|
|
|
|
|
|
class TestFindBlankCut:
|
|
def test_snaps_to_the_nearest_gap(self):
|
|
img = paint(make_img(200), 0, 90)
|
|
paint(img, 110, 200)
|
|
# 100 is inside the 90..110 gap already.
|
|
assert find_blank_cut(img, 100, 20) == 100
|
|
|
|
def test_walks_outwards_to_find_a_gap(self):
|
|
img = paint(make_img(200), 0, 95)
|
|
paint(img, 105, 200)
|
|
cut = find_blank_cut(img, 90, 20)
|
|
assert 95 <= cut < 105
|
|
|
|
def test_solid_ink_returns_the_target(self):
|
|
assert find_blank_cut(paint(make_img(200), 0, 200), 100, 20) == 100
|
|
|
|
def test_target_at_image_width_does_not_index_past_the_end(self):
|
|
# A cut after the last column is legal. Indexing ink[width] raised
|
|
# IndexError in the field, losing that plugin's content for the cycle.
|
|
# Reached once the rotation offset advances so start + budget lands
|
|
# exactly on the image width.
|
|
img = paint(make_img(1840), 0, 1840)
|
|
assert find_blank_cut(img, 1840, 32) == 1840
|
|
|
|
def test_target_past_image_width_is_clamped(self):
|
|
img = paint(make_img(100), 0, 100)
|
|
assert find_blank_cut(img, 500, 32) == 100
|
|
|
|
def test_target_at_width_with_a_trailing_gap_snaps_back(self):
|
|
# Content 0..179, blank 180..199. The nearest blank column to 200 is
|
|
# 199, not the start of the gap — nearest is what keeps the cut as
|
|
# close as possible to the requested budget.
|
|
img = paint(make_img(200), 0, 180)
|
|
assert find_blank_cut(img, 200, 32) == 199
|
|
|
|
def test_zero_radius_returns_the_target(self):
|
|
assert find_blank_cut(paint(make_img(100), 0, 100), 50, 0) == 50
|
|
|
|
def test_negative_target_is_clamped_to_zero(self):
|
|
assert find_blank_cut(paint(make_img(100), 0, 100), -20, 8) == 0
|
|
|
|
@pytest.mark.parametrize("target", [0, 1, 50, 99, 100])
|
|
def test_never_raises_across_the_range(self, target):
|
|
img = paint(make_img(100), 0, 100)
|
|
cut = find_blank_cut(img, target, 16)
|
|
assert 0 <= cut <= 100
|