Implement ChatGPT barcode improvements: ZXing hints, tiling fallback, GS1 parsing

app.py

@@ -852,6 +852,36 @@ import fitz  # PyMuPDF
 try:
     import zxingcpp; HAS_ZXING=True
 except Exception: HAS_ZXING=False
+
+def _zxing_hints_all():
+    if not HAS_ZXING:
+        return None
+    hints = zxingcpp.DecodeHints()
+    # Work harder + allow rotated orientations internally (keeps coords correct)
+    try: hints.try_harder = True
+    except Exception: pass
+    try: hints.try_rotate = True
+    except Exception: pass
+    # GS1 interpretation (FNC1)
+    try: hints.is_gs1 = True
+    except Exception: pass
+
+    # Enable as many formats as the wrapper exposes (covers GS1 DataBar incl. stacked/expanded)
+    BF = getattr(zxingcpp, "BarcodeFormat", None)
+    mask = 0
+    for nm in [
+        "QR_CODE", "AZTEC", "PDF417", "DATA_MATRIX", "MAXICODE",
+        "EAN_13", "EAN_8", "UPC_A", "UPC_E",
+        "CODE_39", "CODE_93", "CODE_128", "ITF", "CODABAR",
+        "RSS_14", "RSS_EXPANDED", "RSS_LIMITED",              # AKA GS1 DataBar family
+        "GS1_DATABAR", "GS1_DATABAR_EXPANDED", "GS1_DATABAR_LIMITED"  # some wheels expose these names
+    ]:
+        val = getattr(BF, nm, None)
+        if val is not None:
+            mask |= int(val)
+    if mask:
+        hints.formats = mask
+    return hints
 try:
     from pyzbar.pyzbar import decode as zbar_decode, ZBarSymbol; HAS_ZBAR=True
 except Exception: HAS_ZBAR=False; ZBarSymbol=None
@@ -891,47 +921,58 @@ def _validate(sym: str, payload: str) -> bool:
     s, norm = _normalize_upc_ean(sym, payload)
     return _ean_checksum_ok(norm) if s in ("EAN13","EAN-13","EAN8","EAN-8","UPCA","UPC-A") else bool(payload)
 
+def parse_gs1(text: str) -> Optional[dict]:
+    if not text: return None
+    # ZXing returns FNC1 as ASCII 29 (\x1D) for GS1-128/QR/DM
+    s = text.replace("\x1D", ")(")  # visual separator
+    # Very lightweight AI parser for common AIs; extend as needed
+    import re as _re
+    ai_pat = _re.compile(r"\((\d{2,4})\)([^()]+)")
+    out = {}
+    for m in ai_pat.finditer(s):
+        ai, val = m.group(1), m.group(2)
+        out[ai] = val
+    return out or None
+
 def _decode_zxing(pil: Image.Image) -> List[Dict[str,Any]]:
     if not HAS_ZXING: return []
     arr = np.asarray(pil.convert("L"))
     out=[]
-    for r in zxingcpp.read_barcodes(arr):  # try_harder is default True in recent builds; otherwise supply options
-        # zxingcpp.Position may be iterable (sequence of points) or an object with corner attributes
+    hints = _zxing_hints_all()
+    try:
+        res = zxingcpp.read_barcodes(arr, hints=hints) if hints is not None else zxingcpp.read_barcodes(arr)
+    except Exception:
+        res = []
+
+    for r in res or []:
         x1=y1=x2=y2=w=h=0
         pos = getattr(r, "position", None)
         pts: List[Any] = []
         if pos is not None:
             try:
-                pts = list(pos)  # works if iterable
+                pts = list(pos)
             except TypeError:
-                # Fall back to known corner attribute names across versions
                 corner_names = (
-                    "top_left", "topLeft",
-                    "top_right", "topRight",
-                    "bottom_left", "bottomLeft",
-                    "bottom_right", "bottomRight",
-                    "point1", "point2", "point3", "point4",
+                    "top_left","topLeft","top_right","topRight",
+                    "bottom_left","bottomLeft","bottom_right","bottomRight",
+                    "point1","point2","point3","point4",
                 )
                 seen=set()
                 for name in corner_names:
                     if hasattr(pos, name):
                         p = getattr(pos, name)
-                        # avoid duplicates
-                        if id(p) not in seen and hasattr(p, "x") and hasattr(p, "y"):
-                            pts.append(p)
-                            seen.add(id(p))
+                        if id(p) not in seen and hasattr(p,"x") and hasattr(p,"y"):
+                            pts.append(p); seen.add(id(p))
         if pts:
-            xs=[int(getattr(p, "x", 0)) for p in pts]
-            ys=[int(getattr(p, "y", 0)) for p in pts]
-            x1,x2=min(xs),max(xs); y1,y2=min(ys),max(ys)
-            w,h=x2-x1,y2-y1
+            xs=[int(getattr(p,"x",0)) for p in pts]
+            ys=[int(getattr(p,"y",0)) for p in pts]
+            x1,x2=min(xs),max(xs); y1,y2=min(ys),max(ys); w,h=x2-x1,y2-y1
+
+        fmt = getattr(getattr(r,"format",None),"name", None) or str(getattr(r,"format",""))
         out.append({
-            "type": str(r.format),
+            "type": fmt,
             "data": r.text or "",
-            "left": x1,
-            "top": y1,
-            "width": w,
-            "height": h,
+            "left": x1, "top": y1, "width": w, "height": h,
         })
     return out
 
@@ -971,38 +1012,62 @@ def _decode_cv2_qr(pil: Image.Image) -> List[Dict[str,Any]]:
 
 def _decode_variants(pil: Image.Image) -> List[Dict[str,Any]]:
     """
-    Try a few light variants. If we upscale, scale detections back to the original size.
-    We avoid rotations here to keep coordinates aligned with the original image.
+    Multi-variant decode with coord-safe upscales and a tiling fallback.
+    We rely on ZXing's internal rotation search via hints (so no manual rotate).
     """
-    variants = []
-    w, h = pil.size
-
-    # base variants @1.0x
-    variants.append(("orig", pil, 1.0))
-    variants.append(("gray", ImageOps.grayscale(pil).convert("RGB"), 1.0))
-    variants.append(("bin", _binarize(pil).convert("RGB"), 1.0))
-
-    # upsample small pages, then scale back coords
-    if max(w, h) < 1600:
-        up2 = pil.resize((w*2, h*2), resample=Image.NEAREST)
-        variants.append(("up2", up2, 2.0))
-        variants.append(("up2_bin", _binarize(up2).convert("RGB"), 2.0))
-
-    for tag, vimg, sc in variants:
-        # Prefer ZXing, then ZBar, then DMTX, then OpenCV-QR
-        res = _decode_zxing(vimg) or _decode_zbar(vimg) or _decode_dmtx(vimg) or _decode_cv2_qr(vimg)
-        if not res:
-            continue
-
-        # Scale results back to original size when needed
-        if sc != 1.0:
+    def _decode_and_rescale(img: Image.Image, scale: float) -> List[Dict[str,Any]]:
+        res = _decode_zxing(img) or _decode_zbar(img) or _decode_dmtx(img) or _decode_cv2_qr(img)
+        if not res: return []
+        if scale != 1.0:
             for r in res:
-                r["left"]   = int(round(r.get("left", 0) / sc))
-                r["top"]    = int(round(r.get("top",  0) / sc))
-                r["width"]  = int(round(r.get("width", 0) / sc))
-                r["height"] = int(round(r.get("height",0) / sc))
+                r["left"]   = int(round(r.get("left", 0) / scale))
+                r["top"]    = int(round(r.get("top",  0) / scale))
+                r["width"]  = int(round(r.get("width", 0) / scale))
+                r["height"] = int(round(r.get("height",0) / scale))
         return res
 
+    # 1) Whole-page variants
+    W,H = pil.size
+    variants = [
+        (pil, 1.0),
+        (ImageOps.grayscale(pil).convert("RGB"), 1.0),
+        (_binarize(pil).convert("RGB"), 1.0),
+    ]
+    if max(W,H) < 1800:
+        up2 = pil.resize((W*2, H*2), resample=Image.NEAREST)
+        variants += [
+            (up2, 2.0),
+            (_binarize(up2).convert("RGB"), 2.0),
+        ]
+    for vimg, sc in variants:
+        res = _decode_and_rescale(vimg, sc)
+        if res:
+            return res
+
+    # 2) Tiled fallback (helps tiny or stacked GS1)
+    # Overlapping 3x3 grid
+    grid = 3
+    step_x = W // grid
+    step_y = H // grid
+    ovx, ovy = step_x // 6, step_y // 6
+    hits: List[Dict[str,Any]] = []
+    for iy in range(grid):
+        for ix in range(grid):
+            x0 = max(ix*step_x - ovx, 0)
+            y0 = max(iy*step_y - ovy, 0)
+            x1 = min((ix+1)*step_x + ovx, W)
+            y1 = min((iy+1)*step_y + ovy, H)
+            tile = pil.crop((x0,y0,x1,y1))
+            # light variants per tile
+            for vimg, sc in [(tile,1.0), (_binarize(tile).convert("RGB"),1.0)]:
+                res = _decode_and_rescale(vimg, sc)
+                for r in res:
+                    r["left"]  += x0
+                    r["top"]   += y0
+                    # width/height already scaled
+                    hits.append(r)
+            if hits:
+                return hits
     return []
 
 def _pix_to_pil(pix) -> Image.Image:
@@ -1417,6 +1482,9 @@ def find_barcode_boxes_and_info_from_pdf(pdf_path: str, image_size: Optional[Tup
                     "page": page_idx + 1,
                     "source": f"page@dpi{int(effective_dpi)}"
                 })
+                # Add GS1 parsing if available
+                gs1 = parse_gs1(payload)
+                if gs1: infos[-1]["gs1"] = gs1
 
             y_offset += ph
         doc.close()