Final barcode reader implementation: ZXing-CPP with exact versions and improved robustness

app.py

@@ -1124,7 +1124,7 @@ def compare_pdfs(file_a, file_b):
                 
                 # Convert to old format for compatibility
                 bar_a, info_a = [], []
-                bar_b, info_b = []
+                bar_b, info_b = [], []
                 
                 for code in codes_a:
                     if "error" not in code:
@@ -1144,7 +1144,8 @@ def compare_pdfs(file_a, file_b):
                                 "height": int(y2-y1),
                                 "valid": True,
                                 "page": code.get("page", 0) + 1,
-                                "source": code.get("source", "")
+                                "source": code.get("source", ""),
+                                "engine": code.get("engine", "")
                             })
                 
                 for code in codes_b:
@@ -1165,7 +1166,8 @@ def compare_pdfs(file_a, file_b):
                                 "height": int(y2-y1),
                                 "valid": True,
                                 "page": code.get("page", 0) + 1,
-                                "source": code.get("source", "")
+                                "source": code.get("source", ""),
+                                "engine": code.get("engine", "")
                             })
                 
                 # Debug: Print barcode detection results

barcode_reader.py

@@ -1,17 +1,13 @@
 """
-Robust barcode reader for images and PDFs.
+Robust, HF-friendly barcode reader for images & PDFs.
 
-Strategy (in order):
-1) PDF -> extract embedded image XObjects at native resolution (no raster loss) and decode.
-2) If nothing found, rasterize PDF page(s) at high DPI (400/600/900) and decode.
-3) For plain images, decode directly.
+Order of operations:
+1) PDF -> extract embedded image XObjects (native pixels), decode (ZXing-CPP preferred)
+2) If none found, rasterize the PDF at 400/600/900 DPI and decode
+3) For plain images, decode directly
 
-Engines:
-- Primary: ZXing-CPP (zxingcpp)  -> no system packages required
-- Fallback: OpenCV contrib barcode (if available)
-
-Outputs are normalized dicts:
-{ 'engine', 'source', 'page', 'type', 'text', 'polygon': [[x,y] * 4] }
+Outputs: list of dicts:
+{engine, source, page, type, text, polygon: [[x,y]*4]}
 """
 
 from __future__ import annotations
@@ -24,23 +20,23 @@ from PIL import Image
 import cv2
 
 # ---------- Engines ----------
-HAS_ZXING = False
+_HAS_ZXING = False
 try:
     import zxingcpp  # pip install zxing-cpp
-    HAS_ZXING = True
+    _HAS_ZXING = True
 except Exception:
     zxingcpp = None
-    HAS_ZXING = False
+    _HAS_ZXING = False
 
-HAS_OCV_BARCODE = hasattr(cv2, "barcode") and hasattr(getattr(cv2, "barcode"), "BarcodeDetector")
+_HAS_OCV_BARCODE = hasattr(cv2, "barcode") and hasattr(getattr(cv2, "barcode"), "BarcodeDetector")
 
 # ---------- PDF (PyMuPDF) ----------
 try:
     import fitz  # PyMuPDF
-    HAS_PYMUPDF = True
+    _HAS_PYMUPDF = True
 except Exception:
     fitz = None
-    HAS_PYMUPDF = False
+    _HAS_PYMUPDF = False
 
 
 # =========================
@@ -56,25 +52,25 @@ def _as_gray(arr_bgr: np.ndarray) -> np.ndarray:
 
 def _preprocess_candidates(bgr: np.ndarray) -> List[np.ndarray]:
     """
-    Generate a small set of preprocess variants to improve 1D and 2D decoding.
-    Keep this list short—HF Spaces need to stay responsive.
+    Generate a tiny set of preprocess variants to improve robustness
+    without slowing HF Spaces too much.
     """
     out = [bgr]
     h, w = bgr.shape[:2]
 
-    # Slight sharpening helps thin 1D bars
+    # mild sharpen
     k = np.array([[0, -1, 0],
                   [-1, 5, -1],
                   [0, -1, 0]], dtype=np.float32)
     sharp = cv2.filter2D(bgr, -1, k)
     out.append(sharp)
 
-    # CLAHE on gray
+    # CLAHE on gray (helps low-contrast/photographed codes)
     g = _as_gray(bgr)
     clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8, 8)).apply(g)
     out.append(cv2.cvtColor(clahe, cv2.COLOR_GRAY2BGR))
 
-    # Slight upscale for tiny barcodes
+    # slight upscale for tiny codes
     if max(h, w) < 1600:
         up = cv2.resize(bgr, (0, 0), fx=1.5, fy=1.5, interpolation=cv2.INTER_CUBIC)
         out.append(up)
@@ -83,15 +79,14 @@ def _preprocess_candidates(bgr: np.ndarray) -> List[np.ndarray]:
 
 def _norm_polygon(pts: Any, w: int, h: int) -> List[List[float]]:
     """
-    Normalize whatever the engine returns into 4 point polygon [[x,y],...].
-    If fewer than 4 points are given, approximate with a bounding box.
+    Normalize whatever the engine returns into a 4-point polygon [[x,y], ...].
+    If fewer points are given, approximate with a bbox.
     """
     try:
         p = np.array(pts, dtype=np.float32).reshape(-1, 2)
         if p.shape[0] >= 4:
             p = p[:4]
         else:
-            # make a box
             x1, y1 = p.min(axis=0)
             x2, y2 = p.max(axis=0)
             p = np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]], dtype=np.float32)
@@ -133,13 +128,12 @@ def _dedupe(results: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
 # =========================
 
 def _decode_zxing(bgr: np.ndarray) -> List[Dict[str, Any]]:
-    if not HAS_ZXING:
+    if not _HAS_ZXING:
         return []
     hits: List[Dict[str, Any]] = []
-    # ZXing works on gray or color; we'll try a couple of variants
     for candidate in _preprocess_candidates(bgr):
         try:
-            res = zxingcpp.read_barcodes(candidate)  # returns list
+            res = zxingcpp.read_barcodes(candidate)  # list
         except Exception:
             continue
         for r in res or []:
@@ -161,12 +155,12 @@ def _decode_zxing(bgr: np.ndarray) -> List[Dict[str, Any]]:
                 "polygon": poly,
             })
         if hits:
-            break  # good enough
+            break
     return hits
 
 
 def _decode_opencv(bgr: np.ndarray) -> List[Dict[str, Any]]:
-    if not HAS_OCV_BARCODE:
+    if not _HAS_OCV_BARCODE:
         return []
     det = cv2.barcode.BarcodeDetector()
     hits: List[Dict[str, Any]] = []
@@ -207,7 +201,7 @@ def _pdf_extract_xobject_images(path: str, page_index: Optional[int] = None) ->
     """
     Return (page, image_bgr) tuples for image XObjects extracted at native resolution.
     """
-    if not HAS_PYMUPDF:
+    if not _HAS_PYMUPDF:
         return []
     out: List[Tuple[int, np.ndarray]] = []
     doc = fitz.open(path)
@@ -217,8 +211,7 @@ def _pdf_extract_xobject_images(path: str, page_index: Optional[int] = None) ->
         for info in page.get_images(full=True):
             xref = info[0]
             pix = fitz.Pixmap(doc, xref)
-            # Convert to RGB if not already
-            if pix.n >= 4:  # includes alpha or CMYK+alpha
+            if pix.n >= 4:  # RGBA or CMYK+alpha -> convert to RGB
                 pix = fitz.Pixmap(fitz.csRGB, pix)
             pil = Image.open(io.BytesIO(pix.tobytes("png"))).convert("RGB")
             out.append((pno, _to_bgr(pil)))
@@ -228,9 +221,9 @@ def _pdf_extract_xobject_images(path: str, page_index: Optional[int] = None) ->
 
 def _pdf_render_page(path: str, page: int, dpi: int) -> np.ndarray:
     """
-    Rasterize one page at the given DPI (for vector codes).
+    Rasterize one page at the given DPI (for vector-only codes).
     """
-    if not HAS_PYMUPDF:
+    if not _HAS_PYMUPDF:
         raise RuntimeError("PyMuPDF not available; cannot rasterize PDF.")
     doc = fitz.open(path)
     if page >= len(doc):
@@ -256,7 +249,8 @@ def _decode_image_path(path: str) -> List[Dict[str, Any]]:
 
 def _decode_pdf_path(path: str, max_pages: int = 8, raster_dpis: Tuple[int, ...] = (400, 600, 900)) -> List[Dict[str, Any]]:
     results: List[Dict[str, Any]] = []
-    # 1) Try original embedded images first
+
+    # 1) try embedded images first
     for pno, img_bgr in _pdf_extract_xobject_images(path):
         hits = _decode_any(img_bgr)
         for h in hits:
@@ -265,9 +259,8 @@ def _decode_pdf_path(path: str, max_pages: int = 8, raster_dpis: Tuple[int, ...]
     if results:
         return _dedupe(results)
 
-    # 2) Fallback: rasterize pages at increasing DPIs
-    if not HAS_PYMUPDF:
-        # No way to rasterize; return empty
+    # 2) rasterize a handful of pages at increasing DPI
+    if not _HAS_PYMUPDF:
         return []
     doc = fitz.open(path)
     n = min(len(doc), max_pages)
@@ -303,7 +296,7 @@ def read_barcodes_from_path(path: str,
 
 
 # =========================
-# Optional: drawing helper
+# Optional helpers for UI
 # =========================
 
 def draw_barcodes(bgr: np.ndarray, detections: List[Dict[str, Any]]) -> np.ndarray:
@@ -315,3 +308,13 @@ def draw_barcodes(bgr: np.ndarray, detections: List[Dict[str, Any]]) -> np.ndarr
         x, y = poly[0, 0, 0], poly[0, 0, 1]
         cv2.putText(out, txt[:48], (x, max(15, y - 6)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 50, 255), 1, cv2.LINE_AA)
     return out
+
+def render_preview_bgr(path: str, page: int = 0, dpi: int = 220) -> np.ndarray:
+    """
+    For UI preview only (small DPI). For PDFs, render one page; for images, just load.
+    """
+    ext = os.path.splitext(path.lower())[1]
+    if ext == ".pdf":
+        return _pdf_render_page(path, page=page, dpi=dpi)
+    pil = Image.open(path).convert("RGB")
+    return _to_bgr(pil)

requirements.txt

@@ -1,10 +1,11 @@
-numpy
-pillow
-pymupdf
+numpy==1.26.4
+pillow>=10.3
+pymupdf>=1.24.9
 opencv-contrib-python-headless==4.10.0.84
-zxing-cpp>=2.2.0
+zxing-cpp==2.2.0
+gradio>=4.44.0
+qrcode>=7.4
 pdf2image
-gradio
 pytesseract
 pyspellchecker
 regex