#!/usr/bin/env python3 """ Gradio PDF Comparison Tool Upload two PDF files and get comprehensive analysis including differences, OCR, barcodes, and CMYK analysis. """ import os, sys, re, csv, json, io from dataclasses import dataclass from typing import List, Tuple, Optional, Iterable import tempfile import unicodedata import numpy as np from PIL import Image, ImageChops, ImageDraw, UnidentifiedImageError from pdf2image import convert_from_path from skimage.measure import label, regionprops from skimage.morphology import dilation, rectangle import gradio as gr # Alternative PDF processing try: import fitz # PyMuPDF HAS_PYMUPDF = True except Exception: fitz = None HAS_PYMUPDF = False # Optional features try: import pytesseract HAS_OCR = True except Exception: pytesseract = None HAS_OCR = False try: from spellchecker import SpellChecker HAS_SPELLCHECK = True except Exception: SpellChecker = None HAS_SPELLCHECK = False try: import regex as re HAS_REGEX = True except Exception: import re HAS_REGEX = False try: from pyzbar.pyzbar import decode as zbar_decode HAS_BARCODE = True except Exception: zbar_decode = None HAS_BARCODE = False # -------------------- Core Data -------------------- @dataclass class Box: y1: int; x1: int; y2: int; x2: int; area: int # ---- spell/tokenization helpers & caches ---- if HAS_REGEX: # Improved regex: better word boundaries, handle apostrophes, hyphens, and spaces _WORD_RE = re.compile(r"\b\p{Letter}+(?:['\-]\p{Letter}+)*\b", re.UNICODE) else: # Fallback regex for basic ASCII _WORD_RE = re.compile(r"\b[A-Za-z]+(?:['\-][A-Za-z]+)*\b") if HAS_SPELLCHECK: # Initialize English spell checker with comprehensive dictionary _SPELL_EN = SpellChecker(language="en") # Try to initialize French spell checker with fallback _SPELL_FR = None try: _SPELL_FR = SpellChecker(language="fr") except Exception: # If French dictionary fails, try alternative approach try: _SPELL_FR = SpellChecker() # Load some basic French words manually if needed except Exception: _SPELL_FR = None print("Warning: French spell checker not available") else: _SPELL_EN = None _SPELL_FR = None _DOMAIN_ALLOWLIST = { # Company/Brand names "Furry", "Fox", "Packaging", "Digitaljoint", "ProofCheck", "PDF", "SKU", "SKUs", "ISO", "G7", "WebCenter", "Hybrid", # Technical terms "CMYK", "RGB", "DPI", "PPI", "TIFF", "JPEG", "PNG", "GIF", "BMP", "Pantone", "Spot", "Process", "Offset", "Lithography", "Gravure", "Flexography", "Digital", "Print", "Press", "Ink", "Paper", "Stock", # Common abbreviations "Inc", "Ltd", "LLC", "Corp", "Co", "Ave", "St", "Rd", "Blvd", "USA", "US", "CA", "ON", "QC", "BC", "AB", "MB", "SK", "NS", "NB", "NL", "PE", "YT", "NT", "NU", # French words (common in Canadian context) "Québec", "Montréal", "Toronto", "Vancouver", "Ottawa", "Calgary", "français", "française", "anglais", "anglaise", "bilingue", # Common business terms "Marketing", "Sales", "Customer", "Service", "Quality", "Control", "Management", "Administration", "Production", "Manufacturing", "Distribution", "Logistics", "Supply", "Chain", "Inventory", # Common words that might be flagged "Email", "Website", "Online", "Internet", "Software", "Hardware", "Database", "System", "Network", "Server", "Client", "User", "Password", "Login", "Logout", "Account", "Profile", "Settings", "Configuration", "Installation", "Maintenance", "Support", # Numbers and measurements "mm", "cm", "m", "kg", "g", "ml", "l", "oz", "lb", "ft", "in", "x", "by", "times", "multiply", "divide", "plus", "minus", # Common misspellings that are actually correct in context "colour", "colour", "favour", "favour", "honour", "honour", "behaviour", "behaviour", "neighbour", "neighbour", "centre", "centre", "theatre", "theatre", "metre", "metre", "litre", "litre", # Pharmaceutical terms "glycerol", "sativa","tocophersolan", "tocopherol", "tocopheryl", "acetate", "ascorbic", "ascorbate", "retinol", "retinyl", "palmitate", "stearate", "oleate", "linoleate", "arachidonate", "docosahexaenoate", "eicosapentaenoate", "alpha", "beta", "gamma", "delta", "omega", "hydroxy", "methyl", "ethyl", "propyl", "butyl", "pentyl", "hexyl", "phosphate", "sulfate", "nitrate", "chloride", "bromide", "iodide", "sodium", "potassium", "calcium", "magnesium", "zinc", "iron", "copper", "manganese", "selenium", "chromium", "molybdenum", "thiamine", "riboflavin", "niacin", "pantothenic", "pyridoxine", "biotin", "folate", "cobalamin", "cholecalciferol", "ergocalciferol", "phylloquinone", "menaquinone", "ubiquinone", "coenzyme", "carnitine", "creatine", "taurine", "glutamine", "arginine", "lysine", "leucine", "isoleucine", "valine", "phenylalanine", "tryptophan", "methionine", "cysteine", "tyrosine", "histidine", "proline", "serine", "threonine", "asparagine", "glutamic", "aspartic", "alanine", "glycine", "polysorbate", "monostearate", "distearate", "tristearate", "polyethylene", "polypropylene", "polyvinyl", "carbomer", "carboxymethyl", "cellulose", "hydroxypropyl", "methylcellulose", "ethylcellulose", "microcrystalline", "lactose", "sucrose", "dextrose", "fructose", "maltose", "galactose", "mannitol", "sorbitol", "xylitol", "erythritol", "stearic", "palmitic", "oleic", "linoleic", "arachidonic", "docosahexaenoic", "eicosapentaenoic", "arachidonic", "linolenic", "gamma", "linolenic", "conjugated", "linoleic", "acid", "ester", "amide", "anhydride", "hydrochloride", "hydrobromide", "hydroiodide", "nitrate", "sulfate", "phosphate", "acetate", "citrate", "tartrate", "succinate", "fumarate", "malate", "lactate", "gluconate", "ascorbate", "tocopheryl", "acetate", "palmitate", "stearate", "oleate", "linoleate", "arachidonate" } _DOMAIN_ALLOWLIST_LOWER = {w.lower() for w in _DOMAIN_ALLOWLIST} if _SPELL_EN: _SPELL_EN.word_frequency.load_words(_DOMAIN_ALLOWLIST_LOWER) if _SPELL_FR: _SPELL_FR.word_frequency.load_words(_DOMAIN_ALLOWLIST_LOWER) def _normalize_text(s: str) -> str: """Normalize text for better word extraction""" if not s: return "" # Unicode normalization s = unicodedata.normalize("NFC", s) # Fix common apostrophe issues s = s.replace("'", "'").replace("'", "'") # Normalize whitespace - replace multiple spaces with single space s = re.sub(r'\s+', ' ', s) # Remove leading/trailing whitespace s = s.strip() return s def _extract_tokens(raw: str): """Extract word tokens with improved filtering""" s = _normalize_text(raw or "") tokens = _WORD_RE.findall(s) # Filter out tokens that are too short or don't look like words filtered_tokens = [] for token in tokens: if len(token) >= 2 and _is_likely_word(token): filtered_tokens.append(token) return filtered_tokens def _looks_like_acronym(tok: str) -> bool: """Check if token looks like a valid acronym""" return tok.isupper() and 2 <= len(tok) <= 6 def _has_digits(tok: str) -> bool: """Check if token contains digits""" return any(ch.isdigit() for ch in tok) def _is_mostly_numbers(tok: str) -> bool: """Check if token is mostly numbers (should be ignored)""" if not tok: return False # Count digits and letters digit_count = sum(1 for ch in tok if ch.isdigit()) letter_count = sum(1 for ch in tok if ch.isalpha()) total_chars = len(tok) # If more than 70% digits, consider it mostly numbers if digit_count / total_chars > 0.7: return True # If it's a pure number (all digits), ignore it if digit_count == total_chars: return True # If it's a number with common suffixes (like "1st", "2nd", "3rd", "4th") if total_chars >= 2 and digit_count >= 1: suffix = tok[-2:].lower() if suffix in ['st', 'nd', 'rd', 'th']: return True # If it's a decimal number (contains digits and decimal point) if '.' in tok and digit_count > 0: return True # If it's a percentage (ends with %) if tok.endswith('%') and digit_count > 0: return True return False def _is_likely_word(tok: str) -> bool: """Check if token looks like a real word (not random characters)""" if len(tok) < 2: return False # Filter out tokens that are mostly non-letter characters letter_count = sum(1 for c in tok if c.isalpha()) if letter_count < len(tok) * 0.6: # At least 60% letters return False # Filter out tokens with too many consecutive consonants/vowels vowels = set('aeiouAEIOU') consonants = set('bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ') # Check for excessive consonant clusters (like "qwerty" or "zxcvb") if len(tok) >= 4: consonant_clusters = 0 vowel_clusters = 0 for i in range(len(tok) - 2): if tok[i:i+3].lower() in consonants: consonant_clusters += 1 if tok[i:i+3].lower() in vowels: vowel_clusters += 1 # If more than half the possible clusters are consonant clusters, likely not a word if consonant_clusters > len(tok) * 0.3: return False # Filter out tokens that look like random keyboard patterns keyboard_patterns = [ 'qwerty', 'asdfgh', 'zxcvbn', 'qwertyuiop', 'asdfghjkl', 'zxcvbnm', 'abcdef', 'bcdefg', 'cdefgh', 'defghi', 'efghij', 'fghijk', '123456', '234567', '345678', '456789', '567890' ] tok_lower = tok.lower() for pattern in keyboard_patterns: if pattern in tok_lower or tok_lower in pattern: return False return True def _is_known_word(tok: str) -> bool: """Check if token is a known word with comprehensive filtering""" t = tok.lower() # First check if it looks like a real word if not _is_likely_word(tok): return True # Don't flag non-words as misspellings # Ignore numbers and mostly numeric tokens if _is_mostly_numbers(tok): return True # Don't flag numbers as misspellings # Check domain allowlist, acronyms, and words with digits if t in _DOMAIN_ALLOWLIST_LOWER or _looks_like_acronym(tok) or _has_digits(tok): return True # Check hyphenated words - if any part is known, consider the whole word known if '-' in tok: parts = tok.split('-') if all(_is_known_word(part) for part in parts): return True # Check against English spell checker if _SPELL_EN: try: # Check if word is known in English dictionary if not _SPELL_EN.unknown([t]): return True except Exception: pass # Check against French spell checker if _SPELL_FR: try: # Check if word is known in French dictionary if not _SPELL_FR.unknown([t]): return True except Exception: pass # Additional checks for common patterns # Check for common suffixes/prefixes that might not be in dictionaries common_suffixes = ['ing', 'ed', 'er', 'est', 'ly', 'tion', 'sion', 'ness', 'ment', 'able', 'ible'] common_prefixes = ['un', 're', 'pre', 'dis', 'mis', 'over', 'under', 'out', 'up', 'down'] # Check if word with common suffix/prefix is known for suffix in common_suffixes: if t.endswith(suffix) and len(t) > len(suffix) + 2: base_word = t[:-len(suffix)] if _SPELL_EN and not _SPELL_EN.unknown([base_word]): return True for prefix in common_prefixes: if t.startswith(prefix) and len(t) > len(prefix) + 2: base_word = t[len(prefix):] if _SPELL_EN and not _SPELL_EN.unknown([base_word]): return True # Check for plural forms (simple 's' ending) if t.endswith('s') and len(t) > 3: singular = t[:-1] if _SPELL_EN and not _SPELL_EN.unknown([singular]): return True return False # (optional) keep a compatibility shim so any other code calling normalize_token() won't break def normalize_token(token: str) -> str: toks = _extract_tokens(token) return (toks[0].lower() if toks else "") # -------------------- Helpers ---------------------- def _is_pdf(path: str) -> bool: return os.path.splitext(path.lower())[1] == ".pdf" def _is_in_excluded_bottom_area(box: Box, image_height: int, excluded_height_mm: float = 115.0, dpi: int = 400) -> bool: """ Check if a box is in the excluded bottom area (115mm from bottom). Converts mm to pixels using DPI. """ # Convert mm to pixels: 1 inch = 25.4mm, so 1mm = dpi/25.4 pixels excluded_height_pixels = int(excluded_height_mm * dpi / 25.4) # Calculate the top boundary of the excluded area excluded_top = image_height - excluded_height_pixels # Check if the box intersects with the excluded area return box.y1 >= excluded_top def _contains_validation_text(text: str) -> bool: """Check if text contains the validation text '50 Carroll'""" return "50 Carroll" in text def load_pdf_pages(path: str, dpi: int = 600, max_pages: int = 15) -> List[Image.Image]: """Load PDF pages as images with fallback options""" if not _is_pdf(path): return [Image.open(path).convert("RGB")] # Try pdf2image first poppler_paths = ["/usr/bin", "/usr/local/bin", "/bin", None] for poppler_path in poppler_paths: try: if poppler_path: imgs = convert_from_path(path, dpi=dpi, first_page=1, last_page=max_pages, poppler_path=poppler_path) else: imgs = convert_from_path(path, dpi=dpi, first_page=1, last_page=max_pages) if imgs: return [img.convert("RGB") for img in imgs] except Exception: if poppler_path is None: # All pdf2image attempts failed break continue # Try next path # Fallback to PyMuPDF if HAS_PYMUPDF: try: doc = fitz.open(path) pages = [] for page_num in range(min(len(doc), max_pages)): page = doc[page_num] mat = fitz.Matrix(dpi/72, dpi/72) pix = page.get_pixmap(matrix=mat) img_data = pix.tobytes("ppm") img = Image.open(io.BytesIO(img_data)) pages.append(img.convert("RGB")) doc.close() return pages except Exception as e: raise ValueError(f"Failed to convert PDF with both pdf2image and PyMuPDF. Error: {str(e)}") raise ValueError("Failed to convert PDF to image. No working method available.") def combine_pages_vertically(pages: List[Image.Image], spacing: int = 20) -> Image.Image: """Combine multiple pages into a single vertical image""" if not pages: raise ValueError("No pages to combine") if len(pages) == 1: return pages[0] # Find the maximum width max_width = max(page.width for page in pages) # Calculate total height total_height = sum(page.height for page in pages) + spacing * (len(pages) - 1) # Create combined image combined = Image.new('RGB', (max_width, total_height), (255, 255, 255)) y_offset = 0 for page in pages: # Center the page horizontally if it's narrower than max_width x_offset = (max_width - page.width) // 2 combined.paste(page, (x_offset, y_offset)) y_offset += page.height + spacing return combined def match_sizes(a: Image.Image, b: Image.Image) -> Tuple[Image.Image, Image.Image]: if a.size == b.size: return a, b w, h = min(a.width, b.width), min(a.height, b.height) return a.crop((0, 0, w, h)), b.crop((0, 0, w, h)) def difference_map(a: Image.Image, b: Image.Image) -> Image.Image: return ImageChops.difference(a, b) def find_diff_boxes(diff_img: Image.Image, threshold: int = 12, min_area: int = 25) -> List[Box]: arr = np.asarray(diff_img).astype(np.uint16) gray = arr.max(axis=2).astype(np.uint8) mask = (gray >= threshold).astype(np.uint8) mask = dilation(mask, rectangle(3, 3)) labeled = label(mask, connectivity=2) out: List[Box] = [] img_height = diff_img.height for p in regionprops(labeled): if p.area < min_area: continue minr, minc, maxr, maxc = p.bbox box = Box(minr, minc, maxr, maxc, int(p.area)) # Skip boxes in the excluded bottom area if _is_in_excluded_bottom_area(box, img_height): continue out.append(box) return out def draw_boxes_multi(img: Image.Image, red_boxes: List[Box], cyan_boxes: List[Box], green_boxes: List[Box] = None, width: int = 3) -> Image.Image: out = img.copy(); d = ImageDraw.Draw(out) # red (diff) for b in red_boxes: for w in range(width): d.rectangle([b.x1-w,b.y1-w,b.x2+w,b.y2+w], outline=(255,0,0)) # cyan (misspellings) for b in cyan_boxes: for w in range(width): d.rectangle([b.x1-w,b.y1-w,b.x2+w,b.y2+w], outline=(0,255,255)) # green (barcodes) if green_boxes: for b in green_boxes: for w in range(width): d.rectangle([b.x1-w,b.y1-w,b.x2+w,b.y2+w], outline=(0,255,0)) return out def make_red_overlay(a: Image.Image, b: Image.Image) -> Image.Image: A = np.asarray(a).copy(); B = np.asarray(b) mask = np.any(A != B, axis=2) A[mask] = [255, 0, 0] return Image.fromarray(A) # -------------------- OCR + Spellcheck ------------- from typing import List, Iterable, Optional from PIL import Image import unicodedata import regex as re import pytesseract from spellchecker import SpellChecker # If these existed in your file, keep them; otherwise define defaults to avoid NameError try: HAS_OCR except NameError: HAS_OCR = True try: HAS_SPELLCHECK except NameError: HAS_SPELLCHECK = True # ---- spell/tokenization helpers & caches ---- _WORD_RE = re.compile(r"\p{Letter}+(?:[’'\-]\p{Letter}+)*", re.UNICODE) _SPELL_EN = SpellChecker(language="en") _SPELL_FR = SpellChecker(language="fr") _DOMAIN_ALLOWLIST = { "Furry", "Fox", "Packaging", "Digitaljoint", "ProofCheck", "PDF", "SKU", "SKUs", "ISO", "G7", "WebCenter", "Hybrid" } _SPELL_EN.word_frequency.load_words(w.lower() for w in _DOMAIN_ALLOWLIST) _SPELL_FR.word_frequency.load_words(w.lower() for w in _DOMAIN_ALLOWLIST) def _normalize_text(s: str) -> str: s = unicodedata.normalize("NFC", s) return s.replace("’", "'").strip() def _extract_tokens(raw: str): s = _normalize_text(raw or "") return _WORD_RE.findall(s) def _looks_like_acronym(tok: str) -> bool: return tok.isupper() and 2 <= len(tok) <= 6 def _has_digits(tok: str) -> bool: return any(ch.isdigit() for ch in tok) # (optional) keep a compatibility shim so any other code calling normalize_token() won't break def normalize_token(token: str) -> str: toks = _extract_tokens(token) return (toks[0].lower() if toks else "") def _get_available_tesseract_langs(): """Get available Tesseract languages""" try: langs = pytesseract.get_languages() if 'eng' in langs and 'fra' in langs: return "eng+fra" elif 'eng' in langs: return "eng" elif langs: return langs[0] else: return "eng" except Exception: return "eng" def prepare_for_ocr(img: Image.Image) -> Image.Image: """Prepare image for better OCR results""" from PIL import ImageOps, ImageFilter g = img.convert("L") g = ImageOps.autocontrast(g) g = g.filter(ImageFilter.UnsharpMask(radius=1.0, percent=150, threshold=2)) return g def extract_pdf_text(path: str, max_pages: int = 5) -> List[str]: """Extract text directly from PDF using PyMuPDF""" if not HAS_PYMUPDF: return [] try: doc = fitz.open(path) texts = [] for page_num in range(min(len(doc), max_pages)): page = doc[page_num] text = page.get_text() texts.append(text) doc.close() return texts except Exception: return [] def convert_pdf_to_image_coords(pdf_bbox, pdf_page_size, image_size, page_num=0, page_height=1000): """Convert PDF coordinates to image coordinates""" pdf_width, pdf_height = pdf_page_size img_width, img_height = image_size # Scale factors scale_x = img_width / pdf_width scale_y = img_height / pdf_height # Convert PDF coordinates to image coordinates x1 = int(pdf_bbox[0] * scale_x) y1 = int(pdf_bbox[1] * scale_y) + (page_num * page_height) x2 = int(pdf_bbox[2] * scale_x) y2 = int(pdf_bbox[3] * scale_y) + (page_num * page_height) return x1, y1, x2, y2 def find_misspell_boxes_from_text( pdf_path: str, *, extra_allow: Optional[Iterable[str]] = None, max_pages: int = 5, image_size: Optional[Tuple[int, int]] = None ) -> List[Box]: """Find misspellings by analyzing extracted PDF text directly with coordinate mapping""" if not (HAS_SPELLCHECK and HAS_PYMUPDF): return [] # Load extra allowed words if extra_allow and _SPELL_EN: _SPELL_EN.word_frequency.load_words(w.lower() for w in extra_allow) if extra_allow and _SPELL_FR: _SPELL_FR.word_frequency.load_words(w.lower() for w in extra_allow) boxes: List[Box] = [] try: doc = fitz.open(pdf_path) for page_num in range(min(len(doc), max_pages)): page = doc[page_num] # Get text with position information text_dict = page.get_text("dict") # Process each block of text for block in text_dict.get("blocks", []): if "lines" not in block: continue for line in block["lines"]: for span in line["spans"]: text = span.get("text", "").strip() if not text: continue # Extract tokens and check for misspellings tokens = _extract_tokens(text) has_misspelling = False for token in tokens: if len(token) >= 2 and not _is_known_word(token): has_misspelling = True break # If this span has misspellings, create a box for it if has_misspelling: bbox = span["bbox"] # [x0, y0, x1, y1] # Get page dimensions for coordinate conversion page_rect = page.rect pdf_width = page_rect.width pdf_height = page_rect.height # Calculate coordinates if image_size: img_width, img_height = image_size # Convert PDF coordinates to image coordinates scale_x = img_width / pdf_width scale_y = img_height / pdf_height x1 = int(bbox[0] * scale_x) 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: x1 = int(bbox[0]) y1 = int(bbox[1]) + (page_num * 1000) x2 = int(bbox[2]) y2 = int(bbox[3]) + (page_num * 1000) # Create box box = Box(y1=y1, x1=x1, y2=y2, x2=x2, area=(x2 - x1) * (y2 - y1)) # Skip boxes in excluded bottom area unless they contain validation text if image_size: img_height = image_size[1] if _is_in_excluded_bottom_area(box, img_height) and not _contains_validation_text(text): continue else: if _is_in_excluded_bottom_area(box, ph): continue boxes.append(box) doc.close() except Exception: # Fallback to simple text extraction if coordinate mapping fails page_texts = extract_pdf_text(pdf_path, max_pages) for page_num, text in enumerate(page_texts): if not text.strip(): continue tokens = _extract_tokens(text) misspelled_words = [token for token in tokens if len(token) >= 2 and not _is_known_word(token)] if misspelled_words: # Create a placeholder box for the page boxes.append(Box( y1=page_num * 1000, x1=0, y2=(page_num + 1) * 1000, x2=800, area=800 * 1000 )) return boxes def find_misspell_boxes( img: Image.Image, *, min_conf: int = 60, lang: Optional[str] = None, extra_allow: Optional[Iterable[str]] = None, dpi: int = 300, psm: int = 6, oem: int = 3 ) -> List[Box]: """Legacy OCR-based spell checking (kept for fallback)""" if not (HAS_OCR and HAS_SPELLCHECK): return [] # Auto-detect language if not provided if lang is None: try: avail = set(pytesseract.get_languages(config="") or []) except Exception: avail = {"eng"} lang = "eng+fra" if {"eng","fra"}.issubset(avail) else "eng" # OPTIONAL: light upscale if the image is small (heuristic) # target width ~ 2500–3000 px for letter-sized pages if img.width < 1600: scale = 2 img = img.resize((img.width*scale, img.height*scale), Image.LANCZOS) # Prepare image for better OCR img = prepare_for_ocr(img) try: if extra_allow and _SPELL_EN: _SPELL_EN.word_frequency.load_words(w.lower() for w in extra_allow) if extra_allow and _SPELL_FR: _SPELL_FR.word_frequency.load_words(w.lower() for w in extra_allow) # Build a config that sets an explicit DPI and keeps spaces config = f"--psm {psm} --oem {oem} -c preserve_interword_spaces=1 -c user_defined_dpi={dpi}" data = pytesseract.image_to_data( img, lang=lang, config=config, output_type=pytesseract.Output.DICT, ) except Exception: return [] n = len(data.get("text", [])) or 0 boxes: List[Box] = [] for i in range(n): raw = data["text"][i] if not raw: continue # confidence filter conf_str = data.get("conf", ["-1"])[i] try: conf = int(float(conf_str)) except Exception: conf = -1 if conf < min_conf: continue tokens = _extract_tokens(raw) if not tokens: continue # flag the box if ANY token in it looks misspelled if all(_is_known_word(tok) or len(tok) < 2 for tok in tokens): continue left = data.get("left", [0])[i] top = data.get("top", [0])[i] width = data.get("width", [0])[i] height = data.get("height",[0])[i] if width <= 0 or height <= 0: continue # NOTE: adjust to match your Box constructor if needed b = Box(top, left, top + height, left + width, width * height) # Exclude bottom 115mm unless the text contains the validation phrase if _is_in_excluded_bottom_area(b, img.height) and not _contains_validation_text(raw): continue boxes.append(b) return boxes # 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 import fitz # PyMuPDF # Optional backends try: import zxingcpp; HAS_ZXING=True except Exception: HAS_ZXING=False try: 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 # your Box(y1,x1,y2,x2,area) assumed to exist def _binarize(img: Image.Image) -> Image.Image: g = ImageOps.grayscale(img) g = ImageOps.autocontrast(g) 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 _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 # zxingcpp.Position may be iterable (sequence of points) or an object with corner attributes 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 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", ) 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 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 out.append({ "type": str(r.format), "data": r.text or "", "left": x1, "top": y1, "width": w, "height": h, }) return out 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(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_cv2_qr(pil: Image.Image) -> List[Dict[str,Any]]: if not HAS_CV2: return [] try: 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 [] 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 [] 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: 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: b = Box(r["top"], r["left"], r["top"]+r["height"], r["left"]+r["width"], r["width"]*r["height"]) # Exclude barcodes in the bottom 115mm of the page image if _is_in_excluded_bottom_area(b, pil.height): continue boxes.append(b) 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: b = Box(r["top"], r["left"], r["top"]+r["height"], r["left"]+r["width"], r["width"]*r["height"]) if _is_in_excluded_bottom_area(b, pil.height): continue boxes.append(b) 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 def avg_cmyk_in_box(cmyk_arr: np.ndarray, box: Box) -> Tuple[float,float,float,float]: y1,y2 = max(0, box.y1), min(cmyk_arr.shape[0], box.y2) x1,x2 = max(0, box.x1), min(cmyk_arr.shape[1], box.x2) if y2<=y1 or x2<=x1: return (0.0,0.0,0.0,0.0) region = cmyk_arr[y1:y2, x1:x2, :] mean_vals = region.reshape(-1, 4).mean(axis=0) return tuple(float(round(v * 100.0 / 255.0, 1)) for v in mean_vals) def compute_cmyk_diffs(a_img: Image.Image, b_img: Image.Image, red_boxes: List[Box]): a_cmyk = rgb_to_cmyk_array(a_img) b_cmyk = rgb_to_cmyk_array(b_img) entries = [] for i, bx in enumerate(red_boxes): a_vals = avg_cmyk_in_box(a_cmyk, bx) b_vals = avg_cmyk_in_box(b_cmyk, bx) delta = tuple(round(b_vals[j] - a_vals[j], 1) for j in range(4)) entries.append({'idx': i+1, 'A': a_vals, 'B': b_vals, 'Delta': delta}) return entries def draw_cmyk_panel(base: Image.Image, entries, title: str = 'CMYK breakdowns', panel_width: int = 260) -> Image.Image: w,h = base.size panel = Image.new('RGB', (panel_width, h), (245,245,245)) out = Image.new('RGB', (w+panel_width, h), (255,255,255)) out.paste(base, (0,0)); out.paste(panel, (w,0)) d = ImageDraw.Draw(out) x0 = w + 8; y = 8 d.text((x0, y), title, fill=(0,0,0)); y += 18 if not entries: d.text((x0, y), 'No differing regions', fill=(80,80,80)) return out for e in entries: idx = e['idx']; aC,aM,aY,aK = e['A']; bC,bM,bY,bK = e['B']; dC,dM,dY,dK = e['Delta'] d.text((x0, y), f"#{idx}", fill=(0,0,0)); y += 14 d.text((x0, y), f"A: C {aC}% M {aM}% Y {aY}% K {aK}%", fill=(0,0,0)); y += 14 d.text((x0, y), f"B: C {bC}% M {bM}% Y {bY}% K {bK}%", fill=(0,0,0)); y += 14 d.text((x0, y), f"Delta: C {dC}% M {dM}% Y {dY}% K {dK}%", fill=(120,0,0)); y += 18 if y > h - 40: break return out # -------------------- Gradio Interface ----------------- def compare_pdfs(file_a, file_b): """Main comparison function for Gradio interface""" try: if file_a is None or file_b is None: return None, None, None, "❌ Please upload both PDF files to compare", [], [] # Load images with multiple pages support pages_a = load_pdf_pages(file_a.name, dpi=600, max_pages=15) pages_b = load_pdf_pages(file_b.name, dpi=600, max_pages=15) # Combine pages into single images for comparison a = combine_pages_vertically(pages_a) b = combine_pages_vertically(pages_b) # Match sizes a, b = match_sizes(a, b) # Find differences with default settings diff = difference_map(a, b) red_boxes = find_diff_boxes(diff, threshold=12, min_area=25) # Run all analysis features with defaults # Use text-based spell checking instead of OCR for better accuracy # Pass image dimensions for proper coordinate mapping image_size = (a.width, a.height) misspell_a = find_misspell_boxes_from_text(file_a.name, image_size=image_size) if HAS_SPELLCHECK and HAS_PYMUPDF else [] misspell_b = find_misspell_boxes_from_text(file_b.name, image_size=image_size) if HAS_SPELLCHECK and HAS_PYMUPDF else [] # Debug: Print spell check results print(f"Spell check results - A: {len(misspell_a)} boxes, B: {len(misspell_b)} boxes") if HAS_BARCODE: # Use PDF-based barcode detection instead of rasterized image bar_a, info_a = find_barcode_boxes_and_info_from_pdf(file_a.name, image_size=image_size) if HAS_PYMUPDF else find_barcode_boxes_and_info(a) bar_b, info_b = find_barcode_boxes_and_info_from_pdf(file_b.name, image_size=image_size) if HAS_PYMUPDF else find_barcode_boxes_and_info(b) # Debug: Print barcode detection results print(f"Barcode detection results - A: {len(bar_a)} codes, B: {len(bar_b)} codes") else: bar_a, info_a = [], [] bar_b, info_b = [], [] # Always enable CMYK analysis cmyk_entries = compute_cmyk_diffs(a, b, red_boxes) # Create visualizations with default box width a_boxed_core = draw_boxes_multi(a, red_boxes, misspell_a, bar_a, width=3) b_boxed_core = draw_boxes_multi(b, red_boxes, misspell_b, bar_b, width=3) # Always show CMYK panel a_disp = draw_cmyk_panel(a_boxed_core, cmyk_entries, title='CMYK Analysis (A vs B)') b_disp = draw_cmyk_panel(b_boxed_core, cmyk_entries, title='CMYK Analysis (A vs B)') # Create pixel difference overlay overlay = make_red_overlay(a, b) # Create status message status = f""" 📊 **Analysis Complete!** - **Pages processed:** A: {len(pages_a)}, B: {len(pages_b)} - **Difference regions found:** {len(red_boxes)} - **Misspellings detected:** A: {len(misspell_a)}, B: {len(misspell_b)} - **Barcodes found:** A: {len(bar_a)}, B: {len(bar_b)} - **Combined image dimensions:** {a.width} × {a.height} pixels **Legend:** - 🔴 Red boxes: Visual differences - 🔵 Cyan boxes: Spelling errors - 🟢 Green boxes: Barcodes/QR codes """ # Prepare barcode data for tables codes_a = [[c.get('type',''), c.get('data',''), c.get('left',0), c.get('top',0), c.get('width',0), c.get('height',0), c.get('valid', False)] for c in info_a] codes_b = [[c.get('type',''), c.get('data',''), c.get('left',0), c.get('top',0), c.get('width',0), c.get('height',0), c.get('valid', False)] for c in info_b] return overlay, a_disp, b_disp, status, codes_a, codes_b except Exception as e: error_msg = f"❌ **Error:** {str(e)}" return None, None, None, error_msg, [], [] # -------------------- Gradio App ------------------- def create_demo(): # Create custom theme with light blue background # Create a simple, working theme with supported parameters only custom_theme = gr.themes.Soft( primary_hue="blue", neutral_hue="blue", font=gr.themes.GoogleFont("Inter"), ).set( body_background_fill="#99cfe9", # Light blue background body_background_fill_dark="#99cfe9", block_background_fill="#000000", # Black blocks for contrast block_background_fill_dark="#000000", border_color_primary="#333333", # Dark borders border_color_primary_dark="#333333", ) with gr.Blocks(title="PDF Comparison Tool", theme=custom_theme) as demo: gr.Markdown(""" # 🔍 Advanced PDF Comparison Tool Upload two PDF files to get comprehensive analysis including: - **Multi-page PDF support** (up to 15 pages per document) - **Visual differences** with bounding boxes - **OCR and spell checking** - **Barcode/QR code detection** - **CMYK color analysis** """) with gr.Row(): with gr.Column(): file_a = gr.File(label="📄 PDF A (Reference)", file_types=[".pdf"]) file_b = gr.File(label="📄 PDF B (Comparison)", file_types=[".pdf"]) compare_btn = gr.Button("🔍 Compare PDF Files", variant="primary", size="lg") status_md = gr.Markdown("") with gr.Row(): overlay_img = gr.Image(label="🔴 Pixel Differences (Red = Different)", type="pil") with gr.Row(): img_a = gr.Image(label="📄 File A with Analysis", type="pil") img_b = gr.Image(label="📄 File B with Analysis", type="pil") gr.Markdown("### 📊 Barcode Detection Results") with gr.Row(): codes_a_df = gr.Dataframe( headers=["Type", "Data", "Left", "Top", "Width", "Height", "Valid"], label="Barcodes in File A", interactive=False ) codes_b_df = gr.Dataframe( headers=["Type", "Data", "Left", "Top", "Width", "Height", "Valid"], label="Barcodes in File B", interactive=False ) # Event handlers compare_btn.click( fn=compare_pdfs, inputs=[file_a, file_b], outputs=[overlay_img, img_a, img_b, status_md, codes_a_df, codes_b_df] ) gr.Markdown(""" ### 📝 Instructions: 1. Upload two PDF files 2. Click "Compare PDF Files" 3. View results with comprehensive analysis ### 🎨 Color Legend: - **🔴 Red boxes:** Visual differences between files - **🔵 Cyan boxes:** Potential spelling errors (OCR) - **🟢 Green boxes:** Detected barcodes/QR codes - **📊 Side panel:** CMYK color analysis for print workflows """) 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.") def find_barcode_boxes_and_info_from_pdf(pdf_path: str, image_size: Optional[Tuple[int, int]] = None, max_pages: int = 10): """Detect barcodes from the original PDF and return boxes in the same coordinate space as the combined display image. If image_size is provided (w,h of the vertically combined display image), each page is rendered so its width matches w, then decoded. Box y-coordinates are offset by the cumulative height of previous pages so that all boxes map into the combined image space correctly. """ boxes: List[Box] = [] infos: List[Dict[str, Any]] = [] try: doc = fitz.open(pdf_path) num_pages = min(len(doc), max_pages) if num_pages == 0: return [], [] target_width = None if image_size: target_width = int(image_size[0]) y_offset = 0 for page_idx in range(num_pages): page = doc[page_idx] # Compute scale so that rendered width matches target_width when provided if target_width: page_width_pts = float(page.rect.width) # points (72 dpi) scale = max(1.0, target_width / page_width_pts) else: # fallback dpi ~600 scale = 600.0 / 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) pw, ph = pil.size hits = _decode_variants(pil) for r in hits: x1 = int(r.get("left", 0)) y1 = int(r.get("top", 0)) + y_offset w = int(r.get("width", 0)) h = int(r.get("height", 0)) x2 = x1 + w y2 = y1 + h b = Box(y1, x1, y2, x2, w * h) # Exclude bottom 115mm for combined image if we know full height; else per-page if image_size and _is_in_excluded_bottom_area(b, image_size[1]): continue if not image_size and _is_in_excluded_bottom_area(b, ph): continue boxes.append(b) sym, payload = r.get("type", ""), r.get("data", "") infos.append({**r, "valid": _validate(sym, payload), "page": page_idx + 1, "source": f"page@scale{scale:.2f}"}) y_offset += ph doc.close() except Exception: return [], [] return boxes, infos if __name__ == "__main__": demo = create_demo() demo.launch( server_name="0.0.0.0", # Allow external access share=True, # Set to True to create a public link show_error=True )