Scanning and OCR Processing with Python

pip install pytesseract opencv-python pymupdf Pillow

import pytesseract
import sys
import subprocess

def validate_ocr_environment():
 try:
 # Explicitly set path if not in system PATH (Windows/Linux custom installs)
 # pytesseract.pytesseract.tesseract_cmd = r'/usr/bin/tesseract'
 
 version_output = subprocess.check_output(['tesseract', '--version'], text=True)
 print(f"✅ Tesseract Engine Detected:\n{version_output.splitlines()[0]}")
 
 # Verify Python wrapper communication
 test_result = pytesseract.image_to_string(pytesseract.pytesseract.Image.open('test_blank.png'))
 print("✅ pytesseract wrapper communication successful.")
 return True
 except FileNotFoundError:
 print("❌ Tesseract executable not found. Add to system PATH or configure tesseract_cmd.")
 sys.exit(1)
 except Exception as e:
 print(f"❌ Environment validation failed: {e}")
 sys.exit(1)

if __name__ == "__main__":
 validate_ocr_environment()

import cv2
import numpy as np
from pathlib import Path

def preprocess_for_ocr(image_path: str, output_path: str = None) -> np.ndarray:
 """
 Applies grayscale conversion, Otsu's binarization, denoising, and automatic deskewing.
 """
 try:
 img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
 if img is None:
 raise ValueError(f"Failed to load image at {image_path}")

 # 1. Binarization
 _, thresh = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
 # 2. Denoising
 denoised = cv2.fastNlMeansDenoising(thresh, h=30)
 
 # 3. Deskew
 coords = np.column_stack(np.where(denoised > 0))
 if len(coords) == 0:
 raise ValueError("No foreground pixels detected for angle calculation.")
 
 rect = cv2.minAreaRect(coords)
 angle = rect[-1]
 if angle < -45:
 angle = -(90 + angle)
 else:
 angle = -angle
 
 (h, w) = denoised.shape[:2]
 center = (w // 2, h // 2)
 M = cv2.getRotationMatrix2D(center, angle, 1.0)
 rotated = cv2.warpAffine(denoised, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
 
 if output_path:
 cv2.imwrite(output_path, rotated)
 print(f"✅ Preprocessed image saved to {output_path}")
 
 return rotated
 except Exception as e:
 print(f"❌ Preprocessing pipeline failed: {e}")
 raise

import pytesseract
from PIL import Image
import numpy as np

def extract_with_confidence(image_array: np.ndarray, lang: str = 'eng', min_conf: int = 60) -> str:
 """
 Runs OCR and filters out tokens below the specified confidence threshold.
 """
 try:
 # Convert numpy array back to PIL Image for pytesseract
 pil_img = Image.fromarray(image_array)
 
 # Retrieve per-word data including bounding boxes and confidence
 data = pytesseract.image_to_data(pil_img, lang=lang, output_type=pytesseract.Output.DICT)
 
 filtered_text = []
 for i, conf in enumerate(data['conf']):
 if int(conf) >= min_conf and data['text'][i].strip():
 filtered_text.append(data['text'][i])
 
 return ' '.join(filtered_text)
 except Exception as e:
 print(f"❌ OCR execution failed: {e}")
 return ""

# Example usage:
# processed_img = preprocess_for_ocr("./scans/invoice_001.png")
# extracted_text = extract_with_confidence(processed_img, min_conf=70)
# print(extracted_text)

import fitz # PyMuPDF
import pytesseract
from PIL import Image
import re
from pathlib import Path

def clean_ocr_text(raw_text: str) -> str:
 """Applies regex normalization to fix spacing, hyphenation, and line breaks."""
 text = re.sub(r'\s+', ' ', raw_text) # Collapse multiple spaces
 text = re.sub(r'-\s*\n', '', text) # Fix hyphenated line breaks
 return text.strip()

def add_searchable_layer(pdf_path: str, output_path: str, lang: str = 'eng'):
 """
 Renders each PDF page as an image, runs OCR, and overlays a hidden text layer.
 """
 try:
 doc = fitz.open(pdf_path)
 for page_num in range(len(doc)):
 page = doc[page_num]
 # Render at 300 DPI for optimal OCR input
 pix = page.get_pixmap(dpi=300)
 img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
 
 # Generate searchable PDF from Tesseract
 ocr_pdf_bytes = pytesseract.image_to_pdf_or_hocr(img, extension='pdf', lang=lang)
 
 # Overlay invisible text onto original page
 overlay = fitz.open("pdf", ocr_pdf_bytes)
 page.show_pdf_page(page.rect, overlay, 0)
 overlay.close()
 
 doc.save(output_path, garbage=4, deflate=True)
 print(f"✅ Searchable PDF saved to {output_path}")
 except Exception as e:
 print(f"❌ PDF layer injection failed: {e}")
 raise

# Example workflow integration:
# add_searchable_layer("./scans/contract_scan.pdf", "./output/contract_searchable.pdf")