acra-backend / code /tests /test_mild_reencoding.py
Davionnic
fix(pipeline): prevent excessive green lightness shift and unneeded re-encoding
b13e551
Raw History Blame Contribute Delete
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]}"
)