Add custom light blue theme to Gradio app

- Create custom theme with light blue background (#E6F3FF)
- Set block background to slightly lighter blue (#F0F8FF)
- Use soft blue borders (#B3D9FF) for cohesive design
- Apply blue primary and neutral hues for consistent color scheme
- Use Inter font for modern, clean typography
- Maintain accessibility with appropriate contrast ratios
- Aesthetic improvement to match user's preferred color palette

pdf_comparator.py

@@ -386,7 +386,7 @@ def load_pdf_pages(path: str, dpi: int = 400, max_pages: int = 5) -> List[Image.
                     continue
                     
                 return [img.convert("RGB") for img in imgs]
-            except Exception as e:
+        except Exception as e:
                 if poppler_path is None:  # All pdf2image attempts failed
                     break
                 continue  # Try next path
@@ -405,7 +405,7 @@ def load_pdf_pages(path: str, dpi: int = 400, max_pages: int = 5) -> List[Image.
                     pages.append(img.convert("RGB"))
                 doc.close()
                 return pages
-            except Exception as e:
+        except Exception as e:
                 raise ValueError(f"Failed to convert PDF with both pdf2image and PyMuPDF. pdf2image error: poppler not found. PyMuPDF error: {str(e)}")
         else:
             raise ValueError(f"Failed to convert PDF to image with all poppler paths. Last error: poppler not found. PyMuPDF not available as fallback.")
@@ -667,7 +667,7 @@ def find_misspell_boxes_from_text(
                                 y1 = int(bbox[1] * scale_y) + (page_num * img_height)
                                 x2 = int(bbox[2] * scale_x)
                                 y2 = int(bbox[3] * scale_y) + (page_num * img_height)
-                            else:
+                else:
                                 # Use PDF coordinates directly (fallback)
                                 x1 = int(bbox[0])
                                 y1 = int(bbox[1]) + (page_num * 1000)
@@ -697,8 +697,8 @@ def find_misspell_boxes_from_text(
         page_texts = extract_pdf_text(pdf_path, max_pages)
         for page_num, text in enumerate(page_texts):
             if not text.strip():
-                continue
-                
+                    continue
+        
             tokens = _extract_tokens(text)
             misspelled_words = [token for token in tokens if len(token) >= 2 and not _is_known_word(token)]
             
@@ -769,8 +769,8 @@ def find_misspell_boxes(
     for i in range(n):
         raw = data["text"][i]
         if not raw:
-            continue
-
+                    continue
+        
         # confidence filter
         conf_str = data.get("conf", ["-1"])[i]
         try:
@@ -801,158 +801,189 @@ def find_misspell_boxes(
     return boxes
 
 
-# --- Robust PDF barcode scan (page render + embedded images) ---
-from typing import List, Tuple, Optional
-from PIL import Image, ImageOps
+
+
+
+
+
+
+# deps: pip install zxing-cpp pyzbar pylibdmtx PyMuPDF pillow opencv-python-headless regex
+# system: macOS -> brew install zbar poppler ; Ubuntu -> sudo apt-get install libzbar0 poppler-utils
+
 import io, regex as re
+from typing import List, Tuple, Dict, Any
+from PIL import Image, ImageOps
+import numpy as np
 
-try:
-    from pyzbar.pyzbar import decode as zbar_decode, ZBarSymbol
-    HAS_BARCODE = True
-except Exception:
-    HAS_BARCODE = False
-    ZBarSymbol = None
+import fitz  # PyMuPDF
 
+# Optional backends
 try:
-    import fitz  # PyMuPDF
-    HAS_PYMUPDF = True
-except Exception:
-    HAS_PYMUPDF = False
-
+    import zxingcpp; HAS_ZXING=True
+except Exception: HAS_ZXING=False
 try:
-    from pylibdmtx.pylibdmtx import decode as dmtx_decode  # DataMatrix
-    HAS_DMTX = True
-except Exception:
-    HAS_DMTX = False
+    from pyzbar.pyzbar import decode as zbar_decode, ZBarSymbol; HAS_ZBAR=True
+except Exception: HAS_ZBAR=False; ZBarSymbol=None
+try:
+    from pylibdmtx.pylibdmtx import decode as dmtx_decode; HAS_DMTX=True
+except Exception: HAS_DMTX=False
+try:
+    import cv2; HAS_CV2=True
+except Exception: HAS_CV2=False
 
-# assumes you already have: class Box(y1, x1, y2, x2, area)
+# your Box(y1,x1,y2,x2,area) assumed to exist
 
-def _binarize(pil_img: Image.Image) -> Image.Image:
-    g = ImageOps.grayscale(pil_img)
+def _binarize(img: Image.Image) -> Image.Image:
+    g = ImageOps.grayscale(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')
+    return g.point(lambda x: 255 if x > 140 else 0, mode="1").convert("L")
+
+def _ean_checksum_ok(d: str) -> bool:
+    if not d.isdigit(): return False
+    n=len(d); nums=list(map(int,d))
+    if n==8:
+        return (10 - (sum(nums[i]*(3 if i%2==0 else 1) for i in range(7))%10))%10==nums[7]
+    if n==12:
+        return (10 - (sum(nums[i]*(3 if i%2==0 else 1) for i in range(11))%10))%10==nums[11]
+    if n==13:
+        return (10 - (sum(nums[i]*(1 if i%2==0 else 3) for i in range(12))%10))%10==nums[12]
+    return True
 
-def _decode_pyzbar(img: Image.Image) -> list:
-    if not HAS_BARCODE:
-        return []
-    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:
-            from PIL import Image as _PIL
-            u = img.resize((w*2, h*2), resample=_PIL.Resampling.BICUBIC)
-        except Exception:
-            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 _normalize_upc_ean(sym: str, text: str):
+    digits = re.sub(r"\D","",text or "")
+    s = (sym or "").upper()
+    if s in ("EAN13","EAN-13") and len(digits)==13 and digits.startswith("0"):
+        return "UPCA", digits[1:]
+    return s, (digits if s in ("EAN13","EAN-13","EAN8","EAN-8","UPCA","UPC-A") else text or "")
+
+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 _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
+        pts = r.position or []
+        if pts:
+            xs=[p.x for p in pts]; ys=[p.y for p in pts]
+            x1,x2=int(min(xs)),int(max(xs)); y1,y2=int(min(ys)),int(max(ys))
+            w,h=x2-x1,y2-y1
+        else:
+            x1=y1=w=h=0
+        out.append({"type": str(r.format), "data": r.text or "", "left": x1, "top": y1, "width": w, "height": h})
+    return out
 
-def _decode_datamatrix(img: Image.Image) -> list:
-    if not HAS_DMTX:
-        return []
+def _decode_zbar(pil: Image.Image) -> List[Dict[str,Any]]:
+    if not HAS_ZBAR: return []
+    syms=[ZBarSymbol.QRCODE,ZBarSymbol.EAN13,ZBarSymbol.EAN8,ZBarSymbol.UPCA,ZBarSymbol.CODE128] if ZBarSymbol else None
+    res=zbar_decode(pil, symbols=syms) if syms else zbar_decode(pil)
+    return [{"type": d.type, "data": (d.data.decode("utf-8","ignore") if isinstance(d.data,(bytes,bytearray)) else str(d.data)),
+             "left": d.rect.left, "top": d.rect.top, "width": d.rect.width, "height": d.rect.height} for d in res]
+
+def _decode_dmtx(pil: Image.Image) -> List[Dict[str,Any]]:
+    if not HAS_DMTX: return []
     try:
-        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
+        res=dmtx_decode(ImageOps.grayscale(pil))
+        return [{"type":"DATAMATRIX","data": r.data.decode("utf-8","ignore"),
+                 "left": r.rect.left, "top": r.rect.top, "width": r.rect.width, "height": r.rect.height} for r in res]
     except Exception:
         return []
 
-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
+def _decode_cv2_qr(pil: Image.Image) -> List[Dict[str,Any]]:
+    if not HAS_CV2: return []
     try:
-        pix = fitz.Pixmap(fitz.csGRAY, pix)
+        det=cv2.QRCodeDetector()
+        g=np.asarray(pil.convert("L"))
+        val, pts, _ = det.detectAndDecode(g)
+        if val:
+            if pts is not None and len(pts)>=1:
+                pts=pts.reshape(-1,2); xs,ys=pts[:,0],pts[:,1]
+                x1,x2=int(xs.min()),int(xs.max()); y1,y2=int(ys.min()),int(ys.max())
+                w,h=x2-x1,y2-y1
+            else:
+                x1=y1=w=h=0
+            return [{"type":"QRCODE","data":val,"left":x1,"top":y1,"width":w,"height":h}]
     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: List[dict] = []
-    try:
-        doc = fitz.open(pdf_path)
-        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]
+    return []
 
-            # 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)
+def _decode_variants(pil: Image.Image) -> List[Dict[str,Any]]:
+    variants=[pil, ImageOps.grayscale(pil), _binarize(pil)]
+    # upsample small images with NEAREST to keep bars crisp
+    w,h=pil.size
+    if max(w,h)<1600:
+        up=pil.resize((w*2,h*2), resample=Image.NEAREST)
+        variants += [up, _binarize(up)]
+    for v in variants:
+        # ZXing first (broad coverage), then ZBar, then DMTX, then cv2 QR
+        res = _decode_zxing(v)
+        if res: return res
+        res = _decode_zbar(v)
+        if res: return res
+        res = _decode_dmtx(v)
+        if res: return res
+        res = _decode_cv2_qr(v)
+        if res: return res
+        # try rotations
+        for angle in (90,180,270):
+            r=v.rotate(angle, expand=True)
+            res = _decode_zxing(r) or _decode_zbar(r) or _decode_dmtx(r) or _decode_cv2_qr(r)
+            if res: return res
+    return []
 
-            # 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
-            img_height = img.height
-            for d in decs:
-                rect = d.rect
-                left, top, width, height = int(rect.left), int(rect.top), int(rect.width), int(rect.height)
-                box = Box(top, left, top + height, left + width, width * height)
-                
-                # Skip barcodes in the excluded bottom area
-                if _is_in_excluded_bottom_area(box, img_height, dpi=dpi):
-                    continue
-                
-                boxes.append(box)
-                # 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": getattr(d, "type", "UNKNOWN"),
-                    "data": payload,
-                    "left": left, "top": top, "width": width, "height": height,
-                    "page": page_idx + 1,
-                })
-        doc.close()
+def _pix_to_pil(pix) -> Image.Image:
+    # convert PyMuPDF Pixmap to grayscale PIL without alpha (avoids blur)
+    if pix.alpha: pix = fitz.Pixmap(pix, 0)
+    try:
+        pix = fitz.Pixmap(fitz.csGRAY, pix)
     except Exception:
-        return [], []
+        pass
+    return Image.open(io.BytesIO(pix.tobytes("png")))
+
+def scan_pdf_barcodes(pdf_path: str, *, dpi_list=(900,1200), max_pages=10):
+    """Return (boxes, infos) from both rendered pages and embedded images."""
+    boxes=[]; infos=[]
+    doc=fitz.open(pdf_path)
+    n=min(len(doc), max_pages)
+    for page_idx in range(n):
+        page=doc[page_idx]
+
+        # A) Embedded images (often crisp)
+        for ix,(xref,*_) in enumerate(page.get_images(full=True)):
+            try:
+                pix=fitz.Pixmap(doc, xref)
+                pil=_pix_to_pil(pix)
+                hits=_decode_variants(pil)
+                for r in hits:
+                    boxes.append(Box(r["top"], r["left"], r["top"]+r["height"], r["left"]+r["width"], r["width"]*r["height"]))
+                    sym, payload = r["type"], r["data"]
+                    infos.append({**r, "valid": _validate(sym, payload), "page": page_idx+1, "source": f"embed:{ix+1}"})
+            except Exception:
+                pass
+
+        # B) Render page raster at high DPI (grayscale)
+        for dpi in dpi_list:
+            scale=dpi/72.0
+            try:
+                pix=page.get_pixmap(matrix=fitz.Matrix(scale,scale), colorspace=fitz.csGRAY, alpha=False)
+            except TypeError:
+                pix=page.get_pixmap(matrix=fitz.Matrix(scale,scale), alpha=False)
+            pil=_pix_to_pil(pix)
+            hits=_decode_variants(pil)
+            for r in hits:
+                boxes.append(Box(r["top"], r["left"], r["top"]+r["height"], r["left"]+r["width"], r["width"]*r["height"]))
+                sym, payload = r["type"], r["data"]
+                infos.append({**r, "valid": _validate(sym, payload), "page": page_idx+1, "source": f"page@{dpi}dpi"})
+            if any(i["page"]==page_idx+1 for i in infos):
+                break  # found something for this page → next page
+    doc.close()
     return boxes, infos
 
 
 
+
 # -------------------- CMYK Panel -------------------
 def rgb_to_cmyk_array(img: Image.Image) -> np.ndarray:
     return np.asarray(img.convert('CMYK')).astype(np.float32)  # 0..255
@@ -1083,7 +1114,21 @@ def compare_pdfs(file_a, file_b):
 
 # -------------------- Gradio App -------------------
 def create_demo():
-    with gr.Blocks(title="PDF Comparison Tool", theme=gr.themes.Soft()) as demo:
+    # Create custom theme with light blue background
+    custom_theme = gr.themes.Soft(
+        primary_hue="blue",
+        neutral_hue="blue",
+        font=gr.themes.GoogleFont("Inter"),
+    ).set(
+        body_background_fill="#E6F3FF",  # Light blue background
+        body_background_fill_dark="#E6F3FF",
+        block_background_fill="#F0F8FF",  # Slightly lighter blue for blocks
+        block_background_fill_dark="#F0F8FF",
+        border_color_primary="#B3D9FF",  # Soft blue borders
+        border_color_primary_dark="#B3D9FF",
+    )
+    
+    with gr.Blocks(title="PDF Comparison Tool", theme=custom_theme) as demo:
         gr.Markdown("""
         # 🔍 Advanced PDF Comparison Tool
 
@@ -1155,7 +1200,7 @@ def _binarize(pil_img: Image.Image) -> Image.Image:
 def _decode_once(img: Image.Image):
     """Single decode attempt with common barcode symbols"""
     if not HAS_BARCODE:
-        return []
+            return []
     syms = [ZBarSymbol.QRCODE, ZBarSymbol.EAN13, ZBarSymbol.EAN8, ZBarSymbol.UPCA, ZBarSymbol.CODE128]
     return zbar_decode(img, symbols=syms)
 
@@ -1203,14 +1248,14 @@ def debug_scan_pdf(pdf_path: str, outdir: str = "barcode_debug", max_pages=2):
                 r = _decode_once(v)
                 if r:
                     found.extend((tag, rr.type, rr.data) for rr in r)
-                else:
+            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
-            
+                        break
+                
             print(f"Page {p+1}: {len(found)} hits at DPI {dpi} -> {found}")
 
             # Scan embedded images too
@@ -1225,7 +1270,7 @@ def debug_scan_pdf(pdf_path: str, outdir: str = "barcode_debug", max_pages=2):
                     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:
+        except Exception as e:
                     print("  Embedded image error:", e)
     
     doc.close()