Add ChatGPT-recommended barcode debug function

- Add debug_scan_pdf() function for comprehensive barcode detection diagnostics
- Renders PDF pages at 600/900/1200 DPI for resolution analysis
- Tests multiple variants: original, grayscale, binarized, and rotations
- Scans embedded images (XObjects) for barcodes
- Saves debug PNGs to inspect bar width and quality
- Helps identify if barcodes are too thin/low resolution
- Includes helper functions _binarize() and _decode_once()
- Comprehensive diagnostic tool for troubleshooting barcode detection issues

pdf_comparator.py

@@ -548,240 +548,150 @@ def find_misspell_boxes(
     return boxes
 
 
-# -------------------- Barcode / QR -----------------
-def ean_like_checksum_ok(digits: str) -> bool:
-    if not digits.isdigit():
-        return False
-    n = len(digits)
-    if n not in (8, 12, 13):
-        return True
-    nums = [int(c) for c in digits]
-    if n == 8:
-        body, check = nums[:7], nums[7]
-        s = sum(body[i] * (3 if i % 2 == 0 else 1) for i in range(7))
-        return (10 - (s % 10)) % 10 == check
-    if n == 12:
-        body, check = nums[:11], nums[11]
-        s = sum(body[i] * (3 if i % 2 == 0 else 1) for i in range(11))
-        return (10 - (s % 10)) % 10 == check
-    if n == 13:
-        body, check = nums[:12], nums[12]
-        s = sum(body[i] * (1 if i % 2 == 0 else 3) for i in range(12))
-        return (10 - (s % 10)) % 10 == check
-    return True
-
-def validate_symbology(symbology: str, data: bytes) -> bool:
-    """Validate barcode symbology with improved UPC-A/EAN-13 handling"""
-    try:
-        text = data.decode('utf-8', errors='ignore')
-    except Exception:
-        return False
-    
-    sym = (symbology or '').upper()
-    
-    if sym in ("EAN13", "EAN-13", "EAN8", "EAN-8", "UPCA", "UPC-A"):
-        # Extract digits only
-        digits = re.sub(r"\D", "", text)
-        
-        # Handle UPC-A reported as EAN-13 with leading 0
-        if sym in ("EAN13", "EAN-13") and len(digits) == 13 and digits.startswith('0'):
-            # Remove leading 0 to get UPC-A format
-            digits = digits[1:]
-        
-        return ean_like_checksum_ok(digits)
-    
-    if sym in ("QRCODE", "QRCODEMODEL2", "QR-CODE"):
-        return len(text) > 0
-    
-    # Default validation for other symbologies
-    return len(text) > 0
+# --- Robust PDF barcode scan (page render + embedded images) ---
+from typing import List, Tuple, Optional
+from PIL import Image, ImageOps
+import io, regex as re
+
+try:
+    from pyzbar.pyzbar import decode as zbar_decode, ZBarSymbol
+    HAS_BARCODE = True
+except Exception:
+    HAS_BARCODE = False
+    ZBarSymbol = None
+
+try:
+    import fitz  # PyMuPDF
+    HAS_PYMUPDF = True
+except Exception:
+    HAS_PYMUPDF = False
+
+try:
+    from pylibdmtx.pylibdmtx import decode as dmtx_decode  # DataMatrix
+    HAS_DMTX = True
+except Exception:
+    HAS_DMTX = False
+
+# assumes you already have: class Box(y1, x1, y2, x2, area)
 
-def boxes_from_rect(x: int, y: int, w: int, h: int) -> Box:
-    return Box(y, x, y + h, x + w, w * h)
+def _binarize(pil_img: Image.Image) -> Image.Image:
+    g = ImageOps.grayscale(pil_img)
+    g = ImageOps.autocontrast(g)
+    # simple global threshold around midtone; adjust if needed
+    return g.point(lambda x: 255 if x > 140 else 0, mode='1').convert('L')
 
-def decode_with_variants(img: Image.Image):
-    """Robust barcode/QR code detection with multiple variants"""
+def _decode_pyzbar(img: Image.Image) -> list:
     if not HAS_BARCODE:
         return []
-    
-    results = []
-    
-    def do_decode(pil_img):
+    symbols = [ZBarSymbol.QRCODE, ZBarSymbol.EAN13, ZBarSymbol.EAN8, ZBarSymbol.UPCA, ZBarSymbol.CODE128] if ZBarSymbol else None
+    res = zbar_decode(img, symbols=symbols) if symbols else zbar_decode(img)
+    if res:
+        return res
+    # try grayscale, binarized, rotations, and 2x upscale
+    variants = [ImageOps.grayscale(img), _binarize(img)]
+    for v in variants:
+        res = zbar_decode(v, symbols=symbols) if symbols else zbar_decode(v)
+        if res: return res
+        for angle in (90, 180, 270):
+            r = v.rotate(angle, expand=True)
+            res = zbar_decode(r, symbols=symbols) if symbols else zbar_decode(r)
+            if res: return res
+    w, h = img.size
+    if max(w, h) < 1600:
         try:
-            dec = zbar_decode(pil_img)
-            if dec: 
-                results.extend(dec)
+            from PIL import Image as _PIL
+            u = img.resize((w*2, h*2), resample=_PIL.Resampling.BICUBIC)
         except Exception:
-            pass
-    
-    # Try original image
-    do_decode(img)
-    
-    # Try grayscale conversion
-    if not results:
-        do_decode(img.convert('L'))
-    
-    # Try scaling up (better for small barcodes)
-    if not results:
-        try:
-            # Use LANCZOS for better quality in newer Pillow versions
-            scaled_img = img.resize((img.width*2, img.height*2), Image.LANCZOS)
-            do_decode(scaled_img)
-        except AttributeError:
-            # Fallback for older Pillow versions
-            scaled_img = img.resize((img.width*2, img.height*2), Image.BICUBIC)
-            do_decode(scaled_img)
-    
-    # Try different color modes
-    if not results and img.mode != 'RGB':
-        do_decode(img.convert('RGB'))
-    
-    # Try rotated versions (common for QR codes)
-    if not results:
-        for angle in [90, 180, 270]:
-            try:
-                rotated = img.rotate(angle, expand=True)
-                do_decode(rotated)
-                if results:
-                    break
-            except Exception:
-                continue
-    
-    return results
-    
-def extract_pdf_images(pdf_path: str, max_pages: int = 5, dpi: int = 300) -> List[Image.Image]:
-    """Extract images directly from PDF using PyMuPDF"""
-    if not HAS_PYMUPDF:
+            u = img.resize((w*2, h*2), resample=Image.BICUBIC)
+        res = zbar_decode(u, symbols=symbols) if symbols else zbar_decode(u)
+        if res: return res
+    return []
+
+def _decode_datamatrix(img: Image.Image) -> list:
+    if not HAS_DMTX:
         return []
-    
     try:
-        doc = fitz.open(pdf_path)
-        images = []
-        
-        for page_num in range(min(len(doc), max_pages)):
-            page = doc[page_num]
-            
-            # Get images from the page
-            image_list = page.get_images()
-            
-            for img_index, img in enumerate(image_list):
-                # Get the image data
-                xref = img[0]
-                pix = fitz.Pixmap(doc, xref)
-                
-                # Convert to PIL Image
-                if pix.n - pix.alpha < 4:  # GRAY or RGB
-                    img_data = pix.tobytes("ppm")
-                    pil_img = Image.open(io.BytesIO(img_data))
-                    images.append(pil_img)
-                else:  # CMYK: convert to RGB first
-                    pix1 = fitz.Pixmap(fitz.csRGB, pix)
-                    img_data = pix1.tobytes("ppm")
-                    pil_img = Image.open(io.BytesIO(img_data))
-                    images.append(pil_img)
-                    pix1 = None
-                pix = None
-        
-        doc.close()
-        return images
+        res = dmtx_decode(ImageOps.grayscale(img))
+        # shape into pyzbar-like objects
+        outs = []
+        for r in res:
+            rect = r.rect  # (left, top, width, height)
+            outs.append(type("DM", (), {
+                "type": "DATAMATRIX",
+                "data": r.data,
+                "rect": type("R", (), {"left": rect.left, "top": rect.top, "width": rect.width, "height": rect.height})
+            }))
+        return outs
     except Exception:
         return []
 
-def find_barcode_boxes_and_info_from_pdf(
-    pdf_path: str,
-    *,
-    max_pages: int = 5,
-    image_size: Optional[Tuple[int, int]] = None,
-    dpi: int = 300
-) -> Tuple[List[Box], List[dict]]:
-    """Find barcodes/QR codes by analyzing extracted PDF images directly"""
-    if not HAS_BARCODE:
+def _decode_all(img: Image.Image) -> list:
+    out = _decode_pyzbar(img)
+    if not out:
+        out = _decode_datamatrix(img) or out
+    return out
+
+def _pix_to_pil(pix) -> Image.Image:
+    # pix: fitz.Pixmap
+    if pix.alpha:  # drop alpha; reduces zbar confusion
+        pix = fitz.Pixmap(pix, 0)  # copy without alpha
+    # use grayscale to avoid color AA artifacts
+    try:
+        pix = fitz.Pixmap(fitz.csGRAY, pix)
+    except Exception:
+        pass
+    return Image.open(io.BytesIO(pix.tobytes("ppm")))
+
+def find_barcode_boxes_and_info_from_pdf(pdf_path: str, *, max_pages: int = 5, dpi: int = 600) -> Tuple[List["Box"], List[dict]]:
+    """Render each page at high DPI + scan embedded images. Return (boxes, infos)."""
+    if not HAS_PYMUPDF:
         return [], []
-    
-    boxes: List[Box] = []
-    infos = []
-    
+    boxes: List["Box"] = []
+    infos: List[dict] = []
     try:
         doc = fitz.open(pdf_path)
-        
-        for page_num in range(min(len(doc), max_pages)):
-            page = doc[page_num]
-            
-            # Get page dimensions for coordinate conversion
-            page_rect = page.rect
-            pdf_width = page_rect.width
-            pdf_height = page_rect.height
-            
-            # Render page to image for barcode detection
-            mat = fitz.Matrix(dpi/72, dpi/72)  # Scale factor for DPI
-            pix = page.get_pixmap(matrix=mat)
-            img_data = pix.tobytes("ppm")
-            pil_img = Image.open(io.BytesIO(img_data))
-            
-            # Detect barcodes in the page image
-            decodes = decode_with_variants(pil_img)
-            
-            for d in decodes:
+        n_pages = min(len(doc), max_pages)
+        scale = dpi / 72.0
+        mat = fitz.Matrix(scale, scale)
+        for page_idx in range(n_pages):
+            page = doc[page_idx]
+
+            # A) Render the page raster (grayscale, high DPI)
+            pix = page.get_pixmap(matrix=mat, alpha=False)
+            img = _pix_to_pil(pix)
+            decs = _decode_all(img)
+
+            # B) Also try each embedded image/XObject as-is (often barcodes are placed as images)
+            for xref, *_rest in page.get_images(full=True):
+                try:
+                    ipix = fitz.Pixmap(doc, xref)
+                    pil = _pix_to_pil(ipix)
+                    decs += _decode_all(pil)
+                except Exception:
+                    pass
+
+            # Collect results
+            for d in decs:
                 rect = d.rect
-                
-                # Convert coordinates if image_size is provided
-                if image_size:
-                    img_width, img_height = image_size
-                    scale_x = img_width / pil_img.width
-                    scale_y = img_height / pil_img.height
-                    
-                    left = int(rect.left * scale_x)
-                    top = int(rect.top * scale_y) + (page_num * img_height)
-                    width = int(rect.width * scale_x)
-                    height = int(rect.height * scale_y)
-                else:
-                    # Use PDF coordinates directly without arbitrary offset
-                    left = rect.left
-                    top = rect.top
-                    width = rect.width
-                    height = rect.height
-                
-                boxes.append(Box(
-                    y1=top,
-                    x1=left,
-                    y2=top + height,
-                    x2=left + width,
-                    area=width * height
-                ))
-                
-                valid = validate_symbology(d.type, d.data)
+                left, top, width, height = int(rect.left), int(rect.top), int(rect.width), int(rect.height)
+                boxes.append(Box(top, left, top + height, left + width, width * height))
+                # basic validation (you already have ean_like_checksum_ok / validate_symbology)
+                try:
+                    payload = d.data.decode("utf-8", errors="ignore") if isinstance(d.data, (bytes, bytearray)) else str(d.data)
+                except Exception:
+                    payload = ""
                 infos.append({
-                    'type': d.type,
-                    'data': (d.data.decode('utf-8', errors='ignore') if isinstance(d.data, (bytes, bytearray)) else str(d.data)),
-                    'left': left, 'top': top, 'width': width, 'height': height,
-                    'valid': bool(valid),
-                    'page': page_num
+                    "type": getattr(d, "type", "UNKNOWN"),
+                    "data": payload,
+                    "left": left, "top": top, "width": width, "height": height,
+                    "page": page_idx + 1,
                 })
-        
         doc.close()
-        
     except Exception:
-        # Fallback to original method if PDF processing fails
         return [], []
-    
     return boxes, infos
 
-def find_barcode_boxes_and_info(img: Image.Image):
-    """Legacy barcode detection (kept for fallback)"""
-    decodes = decode_with_variants(img)
-    boxes: List[Box] = []
-    infos = []
-    for d in decodes:
-        rect = d.rect
-        boxes.append(boxes_from_rect(rect.left, rect.top, rect.width, rect.height))
-        valid = validate_symbology(d.type, d.data)
-        infos.append({
-            'type': d.type,
-            'data': (d.data.decode('utf-8', errors='ignore') if isinstance(d.data, (bytes, bytearray)) else str(d.data)),
-            'left': rect.left, 'top': rect.top, 'width': rect.width, 'height': rect.height,
-            'valid': bool(valid)
-        })
-    return boxes, infos
+
 
 # -------------------- CMYK Panel -------------------
 def rgb_to_cmyk_array(img: Image.Image) -> np.ndarray:
@@ -977,6 +887,92 @@ def create_demo():
 
     return demo
 
+def _binarize(pil_img: Image.Image) -> Image.Image:
+    """Create a binarized (black/white) version of the image for better barcode detection"""
+    g = ImageOps.grayscale(pil_img)
+    g = ImageOps.autocontrast(g)
+    return g.point(lambda x: 255 if x > 140 else 0, mode='1').convert('L')
+
+def _decode_once(img: Image.Image):
+    """Single decode attempt with common barcode symbols"""
+    if not HAS_BARCODE:
+        return []
+    syms = [ZBarSymbol.QRCODE, ZBarSymbol.EAN13, ZBarSymbol.EAN8, ZBarSymbol.UPCA, ZBarSymbol.CODE128]
+    return zbar_decode(img, symbols=syms)
+
+def debug_scan_pdf(pdf_path: str, outdir: str = "barcode_debug", max_pages=2):
+    """
+    Debug function to scan PDF at multiple DPIs and variants to diagnose barcode detection issues.
+    
+    This function:
+    - Renders pages at 600/900/1200 DPI
+    - Tries grayscale, binarized, and rotated versions
+    - Scans embedded images (XObjects)
+    - Prints what it finds and writes debug PNGs
+    - Helps identify if barcodes are too thin/low resolution
+    
+    Usage:
+        debug_scan_pdf("your.pdf", outdir="barcode_debug", max_pages=2)
+    """
+    if not (HAS_BARCODE and HAS_PYMUPDF):
+        print("ERROR: Missing dependencies (pyzbar or PyMuPDF)")
+        return
+        
+    os.makedirs(outdir, exist_ok=True)
+    doc = fitz.open(pdf_path)
+    
+    for dpi in (600, 900, 1200):
+        scale = dpi / 72.0
+        mat = fitz.Matrix(scale, scale)
+        print(f"\n=== DPI {dpi} ===")
+        
+        for p in range(min(len(doc), max_pages)):
+            page = doc[p]
+            pix = page.get_pixmap(matrix=mat, alpha=False)
+            img = Image.open(io.BytesIO(pix.tobytes("ppm")))
+            img.save(f"{outdir}/page{p+1}_{dpi}.png")
+            
+            # Try different image variants
+            variants = [
+                ("orig", img),
+                ("gray", ImageOps.grayscale(img)),
+                ("bin", _binarize(img)),
+            ]
+            found = []
+            
+            for tag, v in variants:
+                r = _decode_once(v)
+                if r:
+                    found.extend((tag, rr.type, rr.data) for rr in r)
+                else:
+                    # Try rotations
+                    for angle in (90, 180, 270):
+                        rr = _decode_once(v.rotate(angle, expand=True))
+                        if rr:
+                            found.extend((f"{tag}_rot{angle}", rri.type, rri.data) for rri in rr)
+                            break
+            
+            print(f"Page {p+1}: {len(found)} hits at DPI {dpi} -> {found}")
+
+            # Scan embedded images too
+            imgs = page.get_images(full=True)
+            for ix, (xref, *_) in enumerate(imgs):
+                try:
+                    ipix = fitz.Pixmap(doc, xref)
+                    if ipix.alpha: 
+                        ipix = fitz.Pixmap(ipix, 0)
+                    pil = Image.open(io.BytesIO(ipix.tobytes("ppm")))
+                    pil.save(f"{outdir}/page{p+1}_embed{ix+1}.png")
+                    rr = _decode_once(pil) or _decode_once(_binarize(pil))
+                    if rr:
+                        print(f"  Embedded image {ix+1}: {[(r.type, r.data) for r in rr]}")
+                except Exception as e:
+                    print("  Embedded image error:", e)
+    
+    doc.close()
+    print(f"\nDebug images saved to: {outdir}/")
+    print("Open the PNGs and zoom in to check bar width. If narrow bars are <2px at 600 DPI, you need 900-1200 DPI.")
+
 if __name__ == "__main__":
     demo = create_demo()
     demo.launch(