Spaces:
Sleeping
Sleeping
Download code/tests/test_mild_reencoding.py from acra-thesis/acra-backend: direct link, hf CLI and curl.
- Browser
- Download file 8.72 kB
-
https://huggingface.co/spaces/acra-thesis/acra-backend/resolve/main/code/tests/test_mild_reencoding.py
- Command line
-
hf download hf://spaces/acra-thesis/acra-backend/code/tests/test_mild_reencoding.py
-
curl -L -o test_mild_reencoding.py https://huggingface.co/spaces/acra-thesis/acra-backend/resolve/main/code/tests/test_mild_reencoding.py
8.72 kB
| """ | |
| 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]}" | |
| ) | |