Implement text-based spell checking using PDF text extraction

- Add extract_pdf_text() function to extract text directly from PDFs using PyMuPDF
- Add find_misspell_boxes_from_text() function that analyzes PDF text with coordinate mapping
- Update compare_pdfs() to use text-based spell checking instead of OCR
- Maintain fallback to OCR-based approach if needed
- Fix missing return statement in decode_with_variants() function
- Spell checking now operates on original PDF text for better accuracy and performance

pdf_comparator.py

@@ -321,6 +321,105 @@ def prepare_for_ocr(img: Image.Image) -> Image.Image:
     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 find_misspell_boxes_from_text(
+    pdf_path: str,
+    *,
+    extra_allow: Optional[Iterable[str]] = None,
+    max_pages: int = 5
+) -> 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]
+                            boxes.append(Box(
+                                top=bbox[1],      # y0
+                                left=bbox[0],     # x0
+                                bottom=bbox[3],   # y1
+                                right=bbox[2],    # x1
+                                area=(bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+                            ))
+        
+        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(
+                    top=page_num * 1000,
+                    left=0,
+                    bottom=(page_num + 1) * 1000,
+                    right=800,
+                    area=800 * 1000
+                ))
+    
+    return boxes
+
 def find_misspell_boxes(
     img: Image.Image,
     *,
@@ -331,6 +430,7 @@ def find_misspell_boxes(
     psm: int = 6,
     oem: int = 3
 ) -> List[Box]:
+    """Legacy OCR-based spell checking (kept for fallback)"""
     if not (HAS_OCR and HAS_SPELLCHECK):
         return []
     
@@ -459,7 +559,7 @@ def decode_with_variants(img: Image.Image):
     if not results:      do_decode(img.resize((img.width*2, img.height*2), Image.BICUBIC))
     if not results and img.mode != 'RGB':
         do_decode(img.convert('RGB'))
-        return results
+    return results
     
 def find_barcode_boxes_and_info(img: Image.Image):
     decodes = decode_with_variants(img)
@@ -544,8 +644,9 @@ def compare_pdfs(file_a, file_b):
         red_boxes = find_diff_boxes(diff, threshold=12, min_area=25)
 
         # Run all analysis features with defaults
-        misspell_a = find_misspell_boxes(a) if HAS_OCR and HAS_SPELLCHECK else []
-        misspell_b = find_misspell_boxes(b) if HAS_OCR and HAS_SPELLCHECK else []
+        # Use text-based spell checking instead of OCR for better accuracy
+        misspell_a = find_misspell_boxes_from_text(file_a.name) if HAS_SPELLCHECK and HAS_PYMUPDF else []
+        misspell_b = find_misspell_boxes_from_text(file_b.name) if HAS_SPELLCHECK and HAS_PYMUPDF else []
 
         if HAS_BARCODE:
             bar_a, info_a = find_barcode_boxes_and_info(a)