fix: Resolve OCR left margin truncation issue

- Add safety padding (50px) around images before preprocessing to protect
  edge content during deskew rotation
- Fix _deskew() to expand canvas during rotation instead of using fixed
  canvas size with BORDER_REPLICATE (which lost edge content)
- Add fallback payment method patterns for truncated text detection
  (RD→CARD, ARD→CARD, MERAR→NUMERAR)

This fixes the issue where text near left edge was being cut off,
causing "CARD" to appear as "RD", "SUBTOTAL" as "UBTOTAL", etc.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

data-entry-app/backend/app/services/image_preprocessor.py

@@ -16,6 +16,25 @@ except ImportError:
 class ImagePreprocessor:
     """Preprocess receipt images for OCR."""
 
+    def _add_safety_padding(self, image: np.ndarray, padding: int = 50) -> np.ndarray:
+        """Add white padding around image to protect edge content during rotation.
+
+        This prevents left/right margin truncation in OCR by ensuring text near
+        edges isn't lost during deskew rotation.
+        """
+        if len(image.shape) == 2:
+            # Grayscale
+            return cv2.copyMakeBorder(
+                image, padding, padding, padding, padding,
+                cv2.BORDER_CONSTANT, value=255
+            )
+        else:
+            # Color (BGR)
+            return cv2.copyMakeBorder(
+                image, padding, padding, padding, padding,
+                cv2.BORDER_CONSTANT, value=(255, 255, 255)
+            )
+
     def load_image(self, path: Path) -> np.ndarray:
         """Load image from file."""
         image = cv2.imread(str(path))
@@ -48,16 +67,31 @@ class ImagePreprocessor:
         Light preprocessing for CLEAR images (PDFs, good scans).
         Preserves original quality, only enhances contrast.
         """
+        # 0. Add safety padding to protect edge content during deskew rotation
+        image = self._add_safety_padding(image)
+
         # 1. Grayscale
         if len(image.shape) == 3:
             gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         else:
             gray = image.copy()
 
-        # 2. Resize if too small
+        # 2a. Scale DOWN if any side exceeds 4000px (PaddleOCR limit)
         height, width = gray.shape
+        max_side = max(height, width)
+        if max_side > 4000:
+            scale = 4000 / max_side
+            gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
+            height, width = gray.shape
+
+        # 2b. Scale UP if too small
         if width < 1500:
             scale = 1500 / width
+            # Ensure we don't exceed 4000px after upscaling
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+            if max(new_width, new_height) > 4000:
+                scale = 4000 / max(new_width, new_height)
             gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
 
         # 3. Deskew
@@ -75,16 +109,31 @@ class ImagePreprocessor:
         Heavy preprocessing for FADED thermal receipts.
         Aggressive binarization to recover faded text.
         """
+        # 0. Add safety padding to protect edge content during deskew rotation
+        image = self._add_safety_padding(image)
+
         # 1. Grayscale
         if len(image.shape) == 3:
             gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         else:
             gray = image.copy()
 
-        # 2. Resize if too small (larger = better OCR)
+        # 2a. Scale DOWN if any side exceeds 4000px (PaddleOCR limit)
         height, width = gray.shape
+        max_side = max(height, width)
+        if max_side > 4000:
+            scale = 4000 / max_side
+            gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
+            height, width = gray.shape
+
+        # 2b. Scale UP if too small (larger = better OCR)
         if width < 1500:
             scale = 1500 / width
+            # Ensure we don't exceed 4000px after upscaling
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+            if max(new_width, new_height) > 4000:
+                scale = 4000 / max(new_width, new_height)
             gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
 
         # 3. Deskew
@@ -115,6 +164,51 @@ class ImagePreprocessor:
 
         return result
 
+    def preprocess_for_tesseract(self, image: np.ndarray) -> np.ndarray:
+        """
+        Tesseract-optimized preprocessing.
+        Tesseract works best with:
+        - Clean black text on white background (binarized)
+        - High DPI (scale up small images)
+        - Otsu thresholding (better than adaptive for clean documents)
+        """
+        # 0. Add safety padding to protect edge content during deskew rotation
+        image = self._add_safety_padding(image)
+
+        # 1. Grayscale
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image.copy()
+
+        # 2. Scale for optimal Tesseract (target ~2000px width for receipts)
+        height, width = gray.shape
+        if width < 2000:
+            scale = 2000 / width
+            gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
+        elif width > 3000:
+            scale = 3000 / width
+            gray = cv2.resize(gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
+
+        # 3. Deskew
+        gray = self._deskew(gray)
+
+        # 4. Strong contrast enhancement
+        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+        enhanced = clahe.apply(gray)
+
+        # 5. Denoise before binarization
+        denoised = cv2.fastNlMeansDenoising(enhanced, h=10, templateWindowSize=7, searchWindowSize=21)
+
+        # 6. Otsu binarization (better than adaptive for clean PDFs)
+        _, binary = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+        # 7. Light morphological cleanup
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 1))
+        cleaned = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
+
+        return cleaned
+
     def get_all_variants(self, image: np.ndarray) -> List[np.ndarray]:
         """
         Generate 2 preprocessing variants for OCR (fast mode).
@@ -126,7 +220,11 @@ class ImagePreprocessor:
         ]
 
     def _deskew(self, image: np.ndarray) -> np.ndarray:
-        """Correct image rotation/skew using Hough lines."""
+        """Correct image rotation/skew using Hough lines.
+
+        Uses expanded canvas to preserve all content during rotation,
+        preventing left/right margin truncation.
+        """
         edges = cv2.Canny(image, 50, 150, apertureSize=3)
         lines = cv2.HoughLinesP(
             edges, 1, np.pi / 180,
@@ -153,8 +251,20 @@ class ImagePreprocessor:
         h, w = image.shape[:2]
         center = (w // 2, h // 2)
         M = cv2.getRotationMatrix2D(center, median_angle, 1.0)
+
+        # Calculate new canvas size to fit entire rotated image (prevents edge truncation)
+        cos_angle = abs(np.cos(np.radians(median_angle)))
+        sin_angle = abs(np.sin(np.radians(median_angle)))
+        new_w = int(h * sin_angle + w * cos_angle)
+        new_h = int(h * cos_angle + w * sin_angle)
+
+        # Adjust rotation matrix for new canvas center
+        M[0, 2] += (new_w - w) / 2
+        M[1, 2] += (new_h - h) / 2
+
         return cv2.warpAffine(
-            image, M, (w, h),
+            image, M, (new_w, new_h),
             flags=cv2.INTER_CUBIC,
-            borderMode=cv2.BORDER_REPLICATE
+            borderMode=cv2.BORDER_CONSTANT,
+            borderValue=255  # White background (grayscale)
         )