""" Milder mixer: keep light reds light, do not crush near-equal warms, legacy still importable, and post-reencode whole-image rescan catches new clashes. """ import numpy as np from pipeline.conflict import detect_conflicts from pipeline.reencoding import enforce_rg_separation, reencode from pipeline.reencoding_mild import ( MILD_GREEN_UP_CAP, MILD_MAX_DELTA_L, enforce_rg_separation_mild, reencode_legacy, reencode_mild, rescan_and_reencode_mild, ) def test_legacy_alias_is_current_reencode(): assert reencode_legacy is not reencode_mild red = np.array([70.0, 40.0, 20.0]) green = np.array([40.0, -40.0, 20.0]) centers = np.stack([red, green]) out_a = reencode(centers, [(0, 1)], 0.8, "deutan") out_b = reencode_legacy(centers, [(0, 1)], 0.8, "deutan") assert np.allclose(out_a, out_b) def test_light_red_dark_green_keeps_red_light(): # Pink-ish / light red vs dark green: polarity must keep red light. light_red = np.array([72.0, 42.0, 18.0]) dark_green = np.array([38.0, -36.0, 22.0]) centers = np.stack([light_red, dark_green]) out = reencode_mild(centers, [(0, 1)], 0.8, "deutan") assert out[0, 0] >= light_red[0] - 1.0, out[0, 0] assert out[1, 0] <= dark_green[0] + 1.0, out[1, 0] assert out[0, 0] > out[1, 0] def test_near_equal_warm_green_not_crushed(): # Color-wheel case: pink and green almost the same L*. pink = np.array([62.0, 38.0, 8.0]) green = np.array([60.0, -34.0, 18.0]) centers = np.stack([pink, green]) out = reencode_mild(centers, [(0, 1)], 0.8, "deutan") assert abs(out[0, 0] - pink[0]) <= MILD_MAX_DELTA_L + 1e-6 assert abs(out[1, 0] - green[0]) <= MILD_MAX_DELTA_L + 1e-6 # Must not apply the old 20+ L* crush on the warm side. assert (pink[0] - out[0, 0]) < 20.0 def test_mild_safety_net_caps_gap(): orig = np.array([ [62.0, 38.0, 8.0], [60.0, -34.0, 18.0], ]) out = enforce_rg_separation_mild( orig.copy(), target_gap=30.0, conflict_pairs=[(0, 1)], original_centers=orig, max_delta_l=38.0, ) assert abs(out[0, 0] - orig[0, 0]) <= MILD_MAX_DELTA_L + 1e-6 assert abs(out[1, 0] - orig[1, 0]) <= MILD_MAX_DELTA_L + 1e-6 def test_detect_conflicts_after_reencode_finds_new_pair(): """Original L* skip hides pink-brown; after_reencode=True must surface it.""" # 0: light pink, 1: green (near-equal L*), 2: darker warm/brown orig = np.array([ [72.0, 42.0, 12.0], [70.0, -36.0, 18.0], [44.0, 28.0, 22.0], ], dtype=np.float64) assert abs(orig[0, 0] - orig[2, 0]) >= 20.0 # CVD view of the originals: pink/green collapse; brown still far in L*. sim_orig = np.array([ [71.0, 4.0, 16.0], [70.5, 3.5, 16.5], [45.0, 8.0, 20.0], ], dtype=np.float64) found = detect_conflicts(orig, sim_orig, "deutan", after_reencode=False) assert (0, 2) not in found and (2, 0) not in found # After the mix darkens pink next to brown, simulated view collapses them. sim_moved = np.array([ [46.0, 5.0, 18.0], [70.5, 3.5, 16.5], [45.0, 6.0, 19.0], ], dtype=np.float64) found_after = detect_conflicts(orig, sim_moved, "deutan", after_reencode=True) assert (0, 2) in found_after or (2, 0) in found_after, found_after def test_resolution_rate_is_honest_when_pair_still_flagged(): """A pair still flagged after the mix must NOT count as resolved. Regression: the metric used to count a pair resolved on de_post >= 20 even when the same detector still flagged it, printing 100% while the colors still collapsed. """ from pipeline.metrics import compute_metrics from pipeline.cvd_simulation import get_simulation_matrix from pipeline.reencoding import _simulate_lab_center red = np.array([62.0, 45.0, 20.0]) green = np.array([60.0, -42.0, 20.0]) centers = np.stack([red, green]) sim = _simulate_lab_center(centers, get_simulation_matrix(0.8, "deutan")) img = np.zeros((40, 40, 3), dtype=np.float64) img[..., :] = centers[0] m = compute_metrics( img, img, 0.8, "deutan", centers_orig=centers, centers_sim=sim, centers_corr=centers, # unchanged: pair must still be flagged cluster_weights=np.array([0.5, 0.5]), ) assert m["n_conflicts_total"] == 1 assert m["conflict_resolution_rate"] == 0.0 assert m["conflict_diagnostics"]["unresolved_pairs"] == [[0, 1]] def test_rescan_and_reencode_mild_runs_second_pass(): """After fixing only pink-green, rescan should handle leftovers without exploding L*.""" orig = np.array([ [72.0, 42.0, 12.0], [70.0, -36.0, 18.0], [44.0, 28.0, 22.0], ], dtype=np.float64) # First mix: only the pink-green pair (what today's pipeline would re-encode). after_first = reencode_mild(orig, [(0, 1)], 0.8, "deutan") after_first = enforce_rg_separation_mild( after_first, conflict_pairs=[(0, 1)], original_centers=orig, severity=0.8, cvd_type="deutan", max_delta_l=38.0, ) mod, found = rescan_and_reencode_mild( orig, after_first, 0.8, "deutan", already_seen=[(0, 1)], max_delta_l=38.0, ) # Must not explode L* past the mild cap relative to centers entering the rescan. for i in range(3): assert abs(float(mod[i, 0]) - float(after_first[i, 0])) <= MILD_MAX_DELTA_L + 1e-6 assert isinstance(found, list) def test_green_naturalness_not_shifted_to_blue(): """Verify that reencode_mild never reduces b* for green clusters (preventing blue/cyan shift in normal vision).""" from pipeline.reencoding_mild import _is_any_green green_lab = np.array([55.0, -35.0, 20.0]) red_lab = np.array([53.0, 45.0, 25.0]) assert _is_any_green(green_lab) assert not _is_any_green(red_lab) # Red-green conflict pair centers = np.stack([red_lab, green_lab]) mod = reencode_mild(centers, [(0, 1)], 0.8, "deutan") # Green is index 1. Its b* must NOT have decreased. orig_b = green_lab[2] mod_b = mod[1, 2] assert mod_b >= orig_b - 1e-5, f"Green b* must not drop below original {orig_b}, got {mod_b}" # Its a* should also remain negative (green) assert mod[1, 1] < -2.0, f"Green a* must remain green, got {mod[1, 1]}" def test_green_not_washed_out_and_already_separated_rg_skipped(): """Green with >= 15 L* separation from red is not flagged, and conflicting green is capped at MILD_GREEN_UP_CAP.""" from pipeline.cvd_simulation import get_simulation_matrix from pipeline.reencoding import _simulate_lab_center # Ring-chart palette: light green (L=60.1), dark green (L=45.8), red (L=44.4) centers = np.array([ [79.5, 6.0, 9.3], # 0: background [60.1, -45.4, 48.0], # 1: light green (already +15.7 L* above red) [45.8, -41.6, 27.8], # 2: dark green (only +1.4 L* above red -> conflicts) [44.4, 69.0, 45.1], # 3: red ], dtype=np.float64) labels = ["background", "roi-color #1", "roi-object #1", "roi-object #2"] weights = np.array([0.85, 0.06, 0.04, 0.05], dtype=np.float64) pinned = {0} sim_mat = get_simulation_matrix(1.0, "deutan") sim_centers = _simulate_lab_center(centers, sim_mat) conflicts = detect_conflicts( centers, sim_centers, "deutan", cluster_weights=weights, cluster_labels=labels, pinned_indices=pinned, ) # Light green (1) has |60.1 - 44.4| = 15.7 >= 15.0, so it must NOT be flagged! assert (1, 3) not in conflicts and (3, 1) not in conflicts, f"Light green should not conflict: {conflicts}" assert (2, 3) in conflicts or (3, 2) in conflicts, f"Dark green vs red must conflict: {conflicts}" mod = reencode_mild(centers, conflicts, 1.0, "deutan", cluster_labels=labels, pinned_indices=pinned) mod = enforce_rg_separation_mild( mod, conflict_pairs=conflicts, cluster_labels=labels, pinned_indices=pinned, original_centers=centers, severity=1.0, cvd_type="deutan", ) mod, _ = rescan_and_reencode_mild( centers, mod, 1.0, "deutan", cluster_labels=labels, pinned_indices=pinned, cluster_weights=weights, already_seen=conflicts, ) # Light green (1) must stay completely untouched assert np.isclose(mod[1, 0], centers[1, 0]), f"Unconflicted light green moved: {centers[1, 0]} -> {mod[1, 0]}" # Dark green (2) upward shift must be capped at MILD_GREEN_UP_CAP (+5.0) even after rescan assert (mod[2, 0] - centers[2, 0]) <= MILD_GREEN_UP_CAP + 1e-6, ( f"Dark green pushed too light: {centers[2, 0]} -> {mod[2, 0]}" )