""" test_reencoding_review_fixes.py -------------------------------- Regression tests verifying the 21 findings addressed from the Re-Encoding Module Review (https://claude.ai/code/artifact/b6cb1d7b-b8cd-4363-8992-e6602e88d670). """ import numpy as np import pytest from pipeline.__init__ import ( _linear_to_lab_f32, _srgb_to_linear_f32, run_full_pipeline, ) from pipeline.conflict import ( detect_conflicts, _rg_a_min, _rg_chroma_min, ) from pipeline.reencoding import ( _candidate_center, _effective_target_gap, _is_red, _is_green, _classify_pair, enforce_rg_separation, reencode, ORTHOGONAL_DIRECTIONS, ) def _srgb_to_lab(rgb: list) -> np.ndarray: u = np.array([[rgb]], dtype=np.uint8) return _linear_to_lab_f32(_srgb_to_linear_f32(u))[0, 0] def test_r1_saturated_primaries_not_clamped_to_80(): """R1: Verify saturated colors outside [-80, 80] are not snapped to +-80.""" # Pure sRGB blue has b* around -107.8 pure_blue_lab = _srgb_to_lab([0, 0, 255]) assert pure_blue_lab[2] < -90.0, f"Expected blue b* < -90, got {pure_blue_lab[2]}" ortho_dir = ORTHOGONAL_DIRECTIONS["deutan"] # Candidate center with small ortho step cand = _candidate_center( pure_blue_lab, delta_l=0.0, chroma_scale=1.0, max_delta_chroma=10.0, ortho_dir=ortho_dir, ortho_step=0.5, ) # The b* shift should be small (~2-3), NOT a giant snap to -80 b_shift = abs(float(cand[2]) - float(pure_blue_lab[2])) assert b_shift < 8.0, f"b* must not snap to -80.0! Shift was {b_shift}" assert cand[2] < -90.0, f"Expected b* to remain < -90, got {cand[2]}" def test_r2_enforce_rg_separation_respects_max_delta_l(): """R2: Safety net enforce_rg_separation must respect max_delta_l from original_centers.""" orig_centers = np.array([ [40.0, 30.0, 15.0], # red [42.0, -30.0, 15.0], # green ]) # Suppose re-encoder already moved red to 35.0 (shift = 5.0) and green to 47.0 (shift = 5.0) mod_centers = np.array([ [35.0, 30.0, 15.0], [47.0, -30.0, 15.0], ]) # Gap is 12, target gap is 32 -> shortfall is 20. # If max_delta_l is 10.0, red can only go down to 40.0 - 10.0 = 30.0 (headroom 5.0 from 35.0) # and green can only go up to 42.0 + 10.0 = 52.0 (headroom 5.0 from 47.0). out = enforce_rg_separation( mod_centers, target_gap=32.0, conflict_pairs=[(0, 1)], original_centers=orig_centers, max_delta_l=10.0, ) red_l = out[0, 0] green_l = out[1, 0] # Red must not exceed max_delta_l from orig (40.0 - 10.0 = 30.0) assert red_l >= 30.0 - 1e-5, f"Red drifted too far: orig=40, out={red_l}, max_delta_l=10" # Green must not exceed max_delta_l from orig (42.0 + 10.0 = 52.0) assert green_l <= 52.0 + 1e-5, f"Green drifted too far: orig=42, out={green_l}, max_delta_l=10" def test_r8_effective_target_gap_zero_at_zero_severity(): """R8: Normal vision (severity=0) must have 0 target gap.""" gap_deutan = _effective_target_gap(0.0, "deutan") gap_protan = _effective_target_gap(0.0, "protan") assert gap_deutan == 0.0, f"Expected 0.0 at severity=0, got {gap_deutan}" assert gap_protan == 0.0, f"Expected 0.0 at severity=0, got {gap_protan}" def test_r10_dark_red_green_recognized(): """R10: Dark red/green at L*=18 must be recognized consistently across modules.""" dark_red = np.array([18.0, 4.0, 2.0]) dark_green = np.array([18.0, -4.0, 2.0]) # In conflict.py: a_min = _rg_a_min(18.0) c_min = _rg_chroma_min(18.0) assert abs(dark_red[1]) > a_min, "Dark red a* should exceed luminance-scaled a_min" assert abs(dark_green[1]) > a_min, "Dark green a* should exceed luminance-scaled a_min" # In reencoding.py: assert _is_red(dark_red), "reencoding._is_red must recognize dark red" assert _is_green(dark_green), "reencoding._is_green must recognize dark green" def test_r11_polarity_preservation_from_original_centers(): """R11: Polarity in enforce_rg_separation must be dictated by original centers.""" # Orig: red is darker (35) than green (45) orig_centers = np.array([ [35.0, 30.0, 15.0], # 0: red [45.0, -30.0, 15.0], # 1: green ]) # Suppose modified centers had an anomalous swap (e.g. green at 38, red at 39) mod_centers = np.array([ [39.0, 30.0, 15.0], [38.0, -30.0, 15.0], ]) out = enforce_rg_separation( mod_centers, target_gap=30.0, conflict_pairs=[(0, 1)], original_centers=orig_centers, max_delta_l=30.0, ) # Red (0) must remain darker than green (1) assert out[0, 0] < out[1, 0], f"Expected red < green, got red={out[0, 0]}, green={out[1, 0]}" def test_r15_centers_delivered_matches_shifts(): """R15: Metrics receive delivered centers (centers + shifts).""" img = np.zeros((60, 60, 3), dtype=np.uint8) img[:30, :] = [220, 40, 40] # red img[30:, :] = [40, 200, 40] # green _, metrics = run_full_pipeline( img, severity=1.0, cvd_type="deutan", use_segmentation=False, compute_validation_metrics=True, ) # The pipeline must complete and metrics should be computed honestly assert "de_improvement" in metrics assert "conflict_resolution_rate" in metrics assert metrics["conflict_resolution_rate"] > 0.5 def test_r16_chromatic_roi_text_not_silently_dropped(): """R16: Colored text (roi-text with high chroma) is not dropped by conflict detection.""" red_text = np.array([50.0, 45.0, 20.0]) # colored text green_bg = np.array([52.0, -40.0, 25.0]) # colored bg centers = np.array([red_text, green_bg]) sim_centers = np.array([[51.0, 0.0, 15.0], [51.0, 0.0, 15.0]]) conflicts = detect_conflicts( centers, sim_centers, cvd_type="deutan", cluster_labels=["roi-text #1", "roi-color #2"], ) assert (0, 1) in conflicts or (1, 0) in conflicts, ( f"Chromatic text must be flagged for conflict resolution, got {conflicts}" ) def test_r18_subsampling_pinned_indices_remapped(): """R18: max_clusters subsampling correctly remaps pinned_indices.""" centers_orig = np.zeros((10, 3)) centers_orig[:, 0] = np.linspace(10, 90, 10) centers_sim = centers_orig.copy() # Suppose cluster 9 was pinned pinned = {9} conflicts = detect_conflicts( centers_orig, centers_sim, cvd_type="deutan", max_clusters=5, pinned_indices=pinned, ) # Should run without error and not crash on reindexed arrays assert isinstance(conflicts, list) def test_chapter_3_parameter_alignment(): """Verify all 5 parameters match the locked Chapter 3 manuscript values.""" import inspect from pipeline.__init__ import run_full_pipeline from pipeline.conflict import detect_conflicts from pipeline.reencoding import reencode import pipeline.__init__ as pipe_mod # 1. target_de == 24.0 sig_pipe = inspect.signature(run_full_pipeline) sig_reenc = inspect.signature(reencode) assert sig_pipe.parameters["target_de"].default == 24.0 assert sig_reenc.parameters["target_de"].default == 24.0 # 2. target_rg_l_gap == 30.0 assert sig_pipe.parameters["target_rg_l_gap"].default == 30.0 assert sig_reenc.parameters["target_rg_l_gap"].default == 30.0 # 3. max_delta_l == 38.0 assert sig_pipe.parameters["max_delta_l"].default == 38.0 assert sig_reenc.parameters["max_delta_l"].default == 38.0 # 4. rg_separation_threshold == 35.0 sig_conf = inspect.signature(detect_conflicts) assert sig_conf.parameters["rg_separation_threshold"].default == 35.0 # 5. Chroma retention == 15%, on the legacy path that reproduces Chapter 3. # # This assertion used to grep the source for a literal line. It broke on # BOTH merges from milder-dynamic-reencoding, because each one moved the # constant -- module level, then inline, then module level again under a # new name -- while the VALUE never changed once. A text search cannot tell # a rename from a regression, so it cries wolf on the refactors and would # stay silent if someone assigned 0.15 in dead code. # # Reading the constants instead ties the test to what Chapter 3 actually # claims: the legacy mixer keeps 15% of the chroma shift, and the milder # mixer that replaced it as the default keeps 45%. from pipeline.__init__ import _CHROMA_SHIFT_RETAIN from pipeline.reencoding_mild import MILD_CHROMA_RETAIN assert _CHROMA_SHIFT_RETAIN == 0.15, ( f"Chapter 3 locks legacy chroma retention at 0.15, got {_CHROMA_SHIFT_RETAIN}" ) assert MILD_CHROMA_RETAIN == 0.45, ( f"the milder mixer is documented at 0.45, got {MILD_CHROMA_RETAIN}" ) # And the legacy branch must actually USE the legacy constant -- the value # existing somewhere proves nothing if the code path ignores it. with open(pipe_mod.__file__, "r", encoding="utf-8") as f: content = f.read() assert "chroma_retain = _CHROMA_SHIFT_RETAIN" in content, ( "the legacy path no longer reads _CHROMA_SHIFT_RETAIN" )