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