Spaces:
Sleeping
Sleeping
| import pytest | |
| import numpy as np | |
| import cv2 | |
| from app.services.image_processing.quality import analyze_image_quality | |
| from app.services.image_processing.geometry import ( | |
| estimate_skew_angle, deskew_image, rotate_cardinal, correct_perspective | |
| ) | |
| from app.services.image_processing.preprocessor import ( | |
| AdaptivePreprocessor, preprocess_for_ocr | |
| ) | |
| # --------------------------------------------------------- | |
| # 1. Clean Scan (Preservation of Quality & Minimal Ops) | |
| # --------------------------------------------------------- | |
| def test_clean_scan_preprocessing(): | |
| # Clean high contrast image (like a digital PDF export) | |
| clean_img = np.ones((1000, 800, 3), dtype=np.uint8) * 255 | |
| # Add clear black text lines | |
| cv2.putText(clean_img, "Official Invoice INV-2024", (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| cv2.putText(clean_img, "Total: 15000.00 EGP", (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| quality = analyze_image_quality(clean_img) | |
| assert quality.is_blurry is False | |
| assert quality.resolution_ok is True | |
| assert quality.skew_angle == 0.0 | |
| primary, variants = AdaptivePreprocessor.preprocess_adaptive(clean_img, quality) | |
| assert "primary" in variants | |
| assert "original" in variants | |
| assert primary.shape == clean_img.shape | |
| # --------------------------------------------------------- | |
| # 2. Tilted / Skewed Document (Deskew) | |
| # --------------------------------------------------------- | |
| def test_skew_estimation_and_deskew(): | |
| # Create an image with tilted text lines (+5 degrees) | |
| img = np.ones((600, 800, 3), dtype=np.uint8) * 255 | |
| cv2.putText(img, "Contract Agreement First Party", (100, 200), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| cv2.putText(img, "Second Party Terms and Conditions", (100, 300), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| cv2.putText(img, "Articles 1 2 3 4 5 6 7", (100, 400), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| # Rotate by 5 degrees | |
| center = (400, 300) | |
| matrix = cv2.getRotationMatrix2D(center, 5.0, 1.0) | |
| tilted = cv2.warpAffine(img, matrix, (800, 600), borderValue=(255, 255, 255)) | |
| skew = estimate_skew_angle(tilted) | |
| assert abs(skew) > 1.0 # Successfully detected tilt | |
| deskewed = deskew_image(tilted, skew) | |
| assert deskewed is not None | |
| assert deskewed.shape[0] >= tilted.shape[0] | |
| # --------------------------------------------------------- | |
| # 3. Cardinal Rotation (90, 180, 270) | |
| # --------------------------------------------------------- | |
| def test_cardinal_rotations(): | |
| img = np.zeros((400, 600, 3), dtype=np.uint8) | |
| r90 = rotate_cardinal(img, 90) | |
| assert r90.shape == (600, 400, 3) | |
| r180 = rotate_cardinal(img, 180) | |
| assert r180.shape == (400, 600, 3) | |
| r270 = rotate_cardinal(img, 270) | |
| assert r270.shape == (600, 400, 3) | |
| # --------------------------------------------------------- | |
| # 4. Low-Resolution Upscaling & Massive Downscaling | |
| # --------------------------------------------------------- | |
| def test_resolution_adaptive_scaling(): | |
| # Low-res image (e.g. 300x200 cropped label) | |
| low_res = np.ones((200, 300, 3), dtype=np.uint8) * 255 | |
| q_low = analyze_image_quality(low_res) | |
| assert q_low.resolution_ok is False | |
| primary_up, _ = AdaptivePreprocessor.preprocess_adaptive(low_res, q_low) | |
| # Upscaled | |
| assert primary_up.shape[0] > low_res.shape[0] | |
| assert primary_up.shape[1] > low_res.shape[1] | |
| # Massive image (e.g. 4000x3500) | |
| massive = np.ones((4000, 3500, 3), dtype=np.uint8) * 255 | |
| q_massive = analyze_image_quality(massive) | |
| primary_down, _ = AdaptivePreprocessor.preprocess_adaptive(massive, q_massive) | |
| assert max(primary_down.shape[:2]) <= AdaptivePreprocessor.MAX_DIM | |
| # --------------------------------------------------------- | |
| # 5. Blur Detection & Controlled Sharpening | |
| # --------------------------------------------------------- | |
| def test_blurry_image_sharpening(): | |
| # Blurred image (800x800 so optimal resolution) | |
| sharp = np.ones((800, 800, 3), dtype=np.uint8) * 255 | |
| cv2.putText(sharp, "Blurred Text Test", (50, 250), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| blurry = cv2.GaussianBlur(sharp, (15, 15), 0) | |
| quality = analyze_image_quality(blurry) | |
| assert quality.is_blurry is True | |
| primary, _ = AdaptivePreprocessor.preprocess_adaptive(blurry, quality) | |
| assert primary.shape == blurry.shape | |
| assert primary is not None | |
| def test_clean_sharp_image_is_not_smoothed_by_denoising_branch(): | |
| img = np.full((800, 800, 3), 255, dtype=np.uint8) | |
| cv2.putText(img, "SHARP", (50, 250), cv2.FONT_HERSHEY_SIMPLEX, 2.0, (0, 0, 0), 3) | |
| quality = analyze_image_quality(img) | |
| # The fixture is sparse text; page-wide variance is not a fixed >300. | |
| assert quality.is_blurry is False | |
| primary, _ = AdaptivePreprocessor.preprocess_adaptive(img, quality) | |
| gray = cv2.cvtColor(primary, cv2.COLOR_BGR2GRAY) | |
| # Primary does grayscale conversion, but the clean high-contrast branch | |
| # should not run bilateral smoothing or thresholding. | |
| assert np.mean(np.abs(gray.astype(np.int16) - cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.int16))) == 0 | |
| # --------------------------------------------------------- | |
| # 6. Uneven Lighting & Shadow Flattening | |
| # --------------------------------------------------------- | |
| def test_shadow_gradient_removal(): | |
| # Create image with harsh shadow gradient from left (dark) to right (bright) | |
| img = np.ones((800, 800, 3), dtype=np.uint8) * 200 | |
| for x in range(400): | |
| img[:, x] = img[:, x] - 140 # Dark shadow on left half | |
| cv2.putText(img, "Payment Receipt", (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| quality = analyze_image_quality(img) | |
| primary, variants = AdaptivePreprocessor.preprocess_adaptive(img, quality) | |
| assert primary is not None | |
| assert "primary" in variants | |
| def test_preprocessor_does_not_build_unused_threshold_variant(): | |
| img = np.full((800, 800, 3), 255, dtype=np.uint8) | |
| img[:, :400] = 80 | |
| quality = analyze_image_quality(img) | |
| _, variants = AdaptivePreprocessor.preprocess_adaptive(img, quality) | |
| assert "primary" in variants | |
| assert "original" in variants | |
| assert "enhanced" not in variants | |
| # --------------------------------------------------------- | |
| # 7. Arabic Dots and Diacritics Preservation | |
| # --------------------------------------------------------- | |
| def test_arabic_dots_and_thin_strokes_preservation(): | |
| # Create image with simulated fine dots (800x800 so no scaling shift) | |
| img = np.ones((800, 800, 3), dtype=np.uint8) * 255 | |
| # Simulate dots as tiny black squares (3x3 pixels) | |
| img[150:154, 150:154] = 0 | |
| img[150:154, 158:162] = 0 | |
| # Simulate a thin stroke (2px width) | |
| img[170:172, 140:180] = 0 | |
| quality = analyze_image_quality(img) | |
| primary, _ = AdaptivePreprocessor.preprocess_adaptive(img, quality) | |
| # Convert primary to gray and verify the dots are not smoothed out/erased | |
| gray = cv2.cvtColor(primary, cv2.COLOR_BGR2GRAY) | |
| dot1_val = np.min(gray[150:154, 150:154]) | |
| stroke_val = np.min(gray[170:172, 140:180]) | |
| # Text pixels should remain dark (< 100), not washed out into background (255) | |
| assert dot1_val < 120, "Arabic dot was destroyed by preprocessing!" | |
| assert stroke_val < 120, "Thin stroke was destroyed by preprocessing!" | |
| # --------------------------------------------------------- | |
| # 8. Perspective Correction Detection | |
| # --------------------------------------------------------- | |
| def test_perspective_detection(): | |
| # Create a white document rectangle inside a dark background | |
| bg = np.zeros((800, 800, 3), dtype=np.uint8) | |
| # Tilted 4-corner document inside the background | |
| doc_pts = np.array([[120, 150], [680, 120], [700, 680], [100, 650]], dtype=np.int32) | |
| cv2.fillPoly(bg, [doc_pts], (255, 255, 255)) | |
| cv2.putText(bg, "Sample Contract", (200, 400), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2) | |
| warped, applied = correct_perspective(bg) | |
| assert applied is True | |
| assert warped.shape[0] > 300 | |
| assert warped.shape[1] > 300 | |