fix: alle Post-Crop-Schritte nutzen cropped statt dewarped Bild

Spalten-, Zeilen-, Woerter-Overlay und alle nachfolgenden Steps
(LLM-Review, Rekonstruktion) lesen jetzt image/cropped mit Fallback
auf image/dewarped. Tests fuer page_crop.py hinzugefuegt (25 Tests).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

klausur-service/backend/tests/test_page_crop.py

@@ -0,0 +1,327 @@
+"""
+Tests for page_crop.py — content-based crop algorithm.
+
+Tests cover:
+- Edge detection via ink projections
+- Spine shadow detection for book scans
+- Narrow run filtering
+- Paper format detection
+- Sanity checks (min area, min border)
+- End-to-end crop on synthetic images
+"""
+
+import numpy as np
+import pytest
+
+from page_crop import (
+    detect_and_crop_page,
+    _detect_format,
+    _detect_edge_projection,
+    _detect_left_edge_shadow,
+    _filter_narrow_runs,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helper: create synthetic images
+# ---------------------------------------------------------------------------
+
+def _make_white_image(h: int, w: int) -> np.ndarray:
+    """Create a white BGR image."""
+    return np.full((h, w, 3), 255, dtype=np.uint8)
+
+
+def _make_image_with_content(
+    h: int, w: int,
+    content_rect: tuple,  # (y1, y2, x1, x2)
+    bg_color: int = 255,
+    content_color: int = 0,
+) -> np.ndarray:
+    """Create an image with a dark content rectangle on a light background."""
+    img = np.full((h, w, 3), bg_color, dtype=np.uint8)
+    y1, y2, x1, x2 = content_rect
+    img[y1:y2, x1:x2] = content_color
+    return img
+
+
+def _make_book_scan(h: int = 1000, w: int = 800) -> np.ndarray:
+    """Create a synthetic book scan with spine shadow on the left.
+
+    Left 10%: gradient from dark (50) to white (255)
+    Top 5%: white (empty scanner border)
+    Bottom 5%: white (empty scanner border)
+    Center: text-like content (dark pixels scattered)
+    """
+    img = np.full((h, w, 3), 255, dtype=np.uint8)
+
+    # Spine shadow: left 10% has gradient from dark to bright
+    shadow_w = w // 10
+    for x in range(shadow_w):
+        brightness = int(50 + (255 - 50) * x / shadow_w)
+        img[:, x] = brightness
+
+    # Content area: scatter some dark pixels (simulate text)
+    content_top = h // 20      # 5% top margin
+    content_bottom = h - h // 20  # 5% bottom margin
+    content_left = shadow_w + w // 20  # past shadow + small margin
+    content_right = w - w // 20  # 5% right margin
+
+    rng = np.random.RandomState(42)
+    for _ in range(500):
+        y = rng.randint(content_top, content_bottom)
+        x = rng.randint(content_left, content_right)
+        # Small text-like blob
+        y2 = min(y + 3, h)
+        x2 = min(x + 10, w)
+        img[y:y2, x:x2] = 20
+
+    return img
+
+
+# ---------------------------------------------------------------------------
+# Tests: _filter_narrow_runs
+# ---------------------------------------------------------------------------
+
+class TestFilterNarrowRuns:
+    def test_removes_short_runs(self):
+        mask = np.array([False, True, True, False, False, True, False])
+        result = _filter_narrow_runs(mask, min_run=3)
+        # The run [True, True] (length 2) and [True] (length 1) should be removed
+        assert not result.any()
+
+    def test_keeps_long_runs(self):
+        mask = np.array([False, True, True, True, True, False])
+        result = _filter_narrow_runs(mask, min_run=3)
+        expected = np.array([False, True, True, True, True, False])
+        np.testing.assert_array_equal(result, expected)
+
+    def test_min_run_1_keeps_all(self):
+        mask = np.array([True, False, True])
+        result = _filter_narrow_runs(mask, min_run=1)
+        np.testing.assert_array_equal(result, mask)
+
+    def test_empty_mask(self):
+        mask = np.array([], dtype=bool)
+        result = _filter_narrow_runs(mask, min_run=5)
+        assert len(result) == 0
+
+    def test_mixed_runs(self):
+        mask = np.array([True, False, True, True, True, True, True, False, True, True])
+        result = _filter_narrow_runs(mask, min_run=3)
+        # Run of 1 at [0]: removed
+        # Run of 5 at [2:7]: kept
+        # Run of 2 at [8:10]: removed
+        expected = np.array([False, False, True, True, True, True, True, False, False, False])
+        np.testing.assert_array_equal(result, expected)
+
+
+# ---------------------------------------------------------------------------
+# Tests: _detect_format
+# ---------------------------------------------------------------------------
+
+class TestDetectFormat:
+    def test_a4_portrait(self):
+        fmt, conf = _detect_format(210, 297)
+        assert fmt == "A4"
+        assert conf > 0.8
+
+    def test_a4_landscape(self):
+        fmt, conf = _detect_format(297, 210)
+        assert fmt == "A4"
+        assert conf > 0.8
+
+    def test_letter(self):
+        fmt, conf = _detect_format(850, 1100)
+        assert fmt == "Letter"
+        assert conf > 0.5
+
+    def test_unknown_square(self):
+        fmt, conf = _detect_format(100, 100)
+        # Aspect ratio 1.0 doesn't match any paper format well
+        assert fmt == "unknown" or conf < 0.5
+
+    def test_zero_dimensions(self):
+        fmt, conf = _detect_format(0, 100)
+        assert fmt == "unknown"
+        assert conf == 0.0
+
+
+# ---------------------------------------------------------------------------
+# Tests: _detect_edge_projection
+# ---------------------------------------------------------------------------
+
+class TestDetectEdgeProjection:
+    def test_finds_first_ink_column(self):
+        """Binary image with ink starting at column 50."""
+        binary = np.zeros((100, 200), dtype=np.uint8)
+        binary[10:90, 50:180] = 255  # Content from x=50 to x=180
+
+        edge = _detect_edge_projection(binary, axis=0, from_start=True, dim=200)
+        assert edge == 50
+
+    def test_finds_last_ink_column(self):
+        binary = np.zeros((100, 200), dtype=np.uint8)
+        binary[10:90, 50:180] = 255
+
+        edge = _detect_edge_projection(binary, axis=0, from_start=False, dim=200)
+        assert edge == 179  # last column with ink
+
+    def test_finds_first_ink_row(self):
+        binary = np.zeros((200, 100), dtype=np.uint8)
+        binary[30:170, 10:90] = 255
+
+        edge = _detect_edge_projection(binary, axis=1, from_start=True, dim=200)
+        assert edge == 30
+
+    def test_finds_last_ink_row(self):
+        binary = np.zeros((200, 100), dtype=np.uint8)
+        binary[30:170, 10:90] = 255
+
+        edge = _detect_edge_projection(binary, axis=1, from_start=False, dim=200)
+        assert edge == 169
+
+    def test_empty_image_returns_boundary(self):
+        binary = np.zeros((100, 100), dtype=np.uint8)
+        assert _detect_edge_projection(binary, axis=0, from_start=True, dim=100) == 0
+        assert _detect_edge_projection(binary, axis=0, from_start=False, dim=100) == 100
+
+
+# ---------------------------------------------------------------------------
+# Tests: _detect_left_edge_shadow
+# ---------------------------------------------------------------------------
+
+class TestDetectLeftEdgeShadow:
+    def test_detects_shadow_gradient(self):
+        """Synthetic image with left-side shadow gradient."""
+        h, w = 500, 400
+        gray = np.full((h, w), 255, dtype=np.uint8)
+        binary = np.zeros((h, w), dtype=np.uint8)
+
+        # Shadow: left 15% gradually darkens
+        shadow_w = w * 15 // 100
+        for x in range(shadow_w):
+            brightness = int(50 + (255 - 50) * x / shadow_w)
+            gray[:, x] = brightness
+
+        # Content starts after shadow
+        binary[:, shadow_w + 10:w - 10] = 255
+
+        edge = _detect_left_edge_shadow(gray, binary, w, h)
+        # Edge should be within the shadow transition zone
+        # The 60% threshold fires before the actual shadow boundary
+        assert 0 < edge < shadow_w + 20
+
+    def test_no_shadow_uses_binary_fallback(self):
+        """When shadow range is small, falls back to binary projection."""
+        h, w = 400, 400
+        gray = np.full((h, w), 200, dtype=np.uint8)
+        binary = np.zeros((h, w), dtype=np.uint8)
+        # Content block from x=80 onward (large enough to survive noise filtering)
+        binary[50:350, 80:380] = 255
+
+        edge = _detect_left_edge_shadow(gray, binary, w, h)
+        # Should find content start via projection fallback (near x=80)
+        assert edge <= 85
+
+
+# ---------------------------------------------------------------------------
+# Tests: detect_and_crop_page (end-to-end)
+# ---------------------------------------------------------------------------
+
+class TestDetectAndCropPage:
+    def test_no_crop_needed_all_content(self):
+        """Image that is all content — no borders to crop."""
+        img = np.full((100, 80, 3), 40, dtype=np.uint8)  # Dark content everywhere
+        cropped, result = detect_and_crop_page(img)
+        # Should return original (all borders < 2%)
+        assert not result["crop_applied"]
+        assert result["cropped_size"] == {"width": 80, "height": 100}
+
+    def test_crops_white_borders(self):
+        """Image with wide white borders around dark content."""
+        h, w = 400, 300
+        img = _make_image_with_content(h, w, (80, 320, 60, 240))
+
+        cropped, result = detect_and_crop_page(img)
+        assert result["crop_applied"]
+        # Cropped size should be close to the content area (with margin)
+        assert result["cropped_size"]["width"] < w
+        assert result["cropped_size"]["height"] < h
+        # Content should be roughly 180x240 + margins (adaptive threshold may widen slightly)
+        assert 160 <= result["cropped_size"]["width"] <= 260
+        assert 220 <= result["cropped_size"]["height"] <= 300
+
+    def test_book_scan_detects_spine_shadow(self):
+        """Synthetic book scan with spine shadow on left."""
+        img = _make_book_scan(1000, 800)
+        cropped, result = detect_and_crop_page(img)
+
+        # Should crop the spine shadow area
+        left_border = result["border_fractions"]["left"]
+        # Spine shadow is ~10% of width, plus some margin
+        assert left_border > 0.05  # At least 5% left border detected
+
+    def test_sanity_check_too_small_crop(self):
+        """If detected content area is too small, skip crop."""
+        h, w = 500, 500
+        # Tiny content area (5x5 pixels) — should fail sanity check
+        img = _make_white_image(h, w)
+        # Add tiny dark spot
+        img[248:253, 248:253] = 0
+
+        cropped, result = detect_and_crop_page(img)
+        # Should either not crop or crop is too small (< 40%)
+        if result["crop_applied"]:
+            crop_area = result["cropped_size"]["width"] * result["cropped_size"]["height"]
+            assert crop_area >= 0.4 * h * w
+
+    def test_crop_preserves_content(self):
+        """Verify that content is preserved after cropping."""
+        h, w = 300, 200
+        img = _make_image_with_content(h, w, (50, 250, 40, 160))
+        cropped, result = detect_and_crop_page(img)
+
+        if result["crop_applied"]:
+            # Cropped image should contain dark pixels (content)
+            gray = np.mean(cropped, axis=2)
+            assert np.min(gray) < 50  # Content is dark
+
+    def test_result_structure(self):
+        """Verify all expected keys are present in result dict."""
+        img = _make_white_image(100, 100)
+        _, result = detect_and_crop_page(img)
+
+        assert "crop_applied" in result
+        assert "original_size" in result
+        assert "cropped_size" in result
+        assert "border_fractions" in result
+        assert "detected_format" in result
+        assert "format_confidence" in result
+        assert "aspect_ratio" in result
+
+    def test_margin_parameter(self):
+        """Custom margin_frac should affect crop bounds."""
+        h, w = 400, 300
+        img = _make_image_with_content(h, w, (80, 320, 60, 240))
+
+        _, result_small = detect_and_crop_page(img, margin_frac=0.005)
+        _, result_large = detect_and_crop_page(img, margin_frac=0.05)
+
+        if result_small["crop_applied"] and result_large["crop_applied"]:
+            # Larger margin should produce a larger crop
+            small_area = result_small["cropped_size"]["width"] * result_small["cropped_size"]["height"]
+            large_area = result_large["cropped_size"]["width"] * result_large["cropped_size"]["height"]
+            assert large_area >= small_area
+
+    def test_crop_rect_pct_values(self):
+        """crop_rect_pct values should be in 0-100 range."""
+        h, w = 400, 300
+        img = _make_image_with_content(h, w, (80, 320, 60, 240))
+        _, result = detect_and_crop_page(img)
+
+        if result["crop_applied"] and result["crop_rect_pct"]:
+            pct = result["crop_rect_pct"]
+            assert 0 <= pct["x"] <= 100
+            assert 0 <= pct["y"] <= 100
+            assert 0 < pct["width"] <= 100
+            assert 0 < pct["height"] <= 100