Final initial commit

README.md

@@ -0,0 +1,3 @@
+---
+license: apache-2.0
+---

gradiosite.py

@@ -0,0 +1,910 @@
+import os
+import cv2
+import numpy as np
+import gradio as gr
+from ultralytics import YOLO
+from pdf2image import convert_from_path
+from PIL import Image
+import easyocr
+import uuid
+import re
+import difflib
+import math
+
+# Conditional import for LLM
+try:
+    from llama_cpp import Llama
+    LLAMA_AVAILABLE = True
+except ImportError:
+    print("Warning: llama_cpp not available. LLM functionality will be disabled.")
+    LLAMA_AVAILABLE = False
+
+# --- Configuration ---
+# Folders for temporary files and results
+UPLOAD_FOLDER = 'static/uploads/'
+RESULTS_FOLDER = 'static/results/'
+
+# --- Model Paths (Update these paths if necessary) ---
+CUSTOM_MODEL_PATH = 'best.pt'
+PRETRAINED_MODEL_PATH = 'yolov10s.pt'
+SIGNATURE_MODEL_PATH = 'yolov8s.pt'
+LLAMA_MODEL_PATH = "unsloth.F16.gguf"
+
+# Detection Parameters
+YOLO_CONFIDENCE_THRESHOLD = 0.5
+OCR_CONFIDENCE_THRESHOLD = 0.5
+
+# Create directories if they don't exist
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(RESULTS_FOLDER, exist_ok=True)
+
+# --- Global Model Placeholders ---
+custom_model, pretrained_model, signature_model, reader, llama_model = None, None, None, None, None
+
+def load_models():
+    """
+    Loads all AI models into the global scope. This function is called on the first
+    analysis request to avoid startup conflicts. It ensures models are only loaded once.
+    """
+    global custom_model, pretrained_model, signature_model, reader, llama_model
+  
+    # If models are already loaded, do nothing.
+    if reader is not None and (llama_model is not None or not LLAMA_AVAILABLE):
+        print("Models already loaded.")
+        return
+    print("=== Loading Models (this may take a moment) ===")
+    
+    # Helper function to check for model files
+    def check_model_path(path, name):
+        if not os.path.exists(path):
+            print(f"✗ WARNING: {name} model not found at '{path}'. The application may not function correctly.")
+            return False
+        return True
+    
+    # YOLO Models
+    if check_model_path(CUSTOM_MODEL_PATH, "Custom YOLO"):
+        try:
+            custom_model = YOLO(CUSTOM_MODEL_PATH)
+            print("✓ Custom YOLO model loaded.")
+        except Exception as e:
+            print(f"✗ Error loading custom model: {e}")
+    if check_model_path(PRETRAINED_MODEL_PATH, "Pre-trained YOLO"):
+        try:
+            pretrained_model = YOLO(PRETRAINED_MODEL_PATH)
+            print("✓ Pre-trained YOLO model loaded.")
+        except Exception as e:
+            print(f"✗ Error loading pre-trained model: {e}")
+    if check_model_path(SIGNATURE_MODEL_PATH, "Signature YOLO"):
+        try:
+            signature_model = YOLO(SIGNATURE_MODEL_PATH)
+            print("✓ Signature YOLO model loaded.")
+        except Exception as e:
+            print(f"✗ Error loading signature model: {e}")
+    
+    # OCR Model
+    try:
+        reader = easyocr.Reader(['en'], gpu=True)
+        print("✓ EasyOCR model loaded.")
+    except Exception as e:
+        print(f"✗ Error loading EasyOCR: {e}. Text detection will be unavailable.")
+    
+    # LLM Model - Only load if available
+    if LLAMA_AVAILABLE and check_model_path(LLAMA_MODEL_PATH, "LLM"):
+        try:
+            llama_model = Llama(
+                model_path=LLAMA_MODEL_PATH,
+                n_gpu_layers=-1, n_ctx=4096, chat_format="llama-3", verbose=False
+            )
+            print("✓ LLM model loaded.")
+        except Exception as e:
+            print(f"✗ Error loading LLM model: {e}. Text analysis will be unavailable.")
+    print("=== All Models Initialized ===")
+
+# YOLO Class Mappings
+CUSTOM_CLASS_NAMES = {0: 'face', 1: 'qr', 2: 'signature'}
+PRETRAINED_CLASS_MAP = {0: 'face'}
+
+# --- Core Detection & Processing Functions ---
+def detect_visual_pii(image_data):
+    """Runs the three-stage YOLO detection on a single image."""
+    all_boxes = []
+    all_classes = []
+  
+    if custom_model is None:
+        print("Custom model not available for visual detection")
+        return all_boxes, all_classes
+  
+    # Pass 1: Custom Model
+    custom_results = custom_model.predict(source=image_data, conf=YOLO_CONFIDENCE_THRESHOLD, verbose=False)[0]
+    detected_custom_classes = {CUSTOM_CLASS_NAMES[int(cls)] for cls in custom_results.boxes.cls}
+  
+    for box, cls in zip(custom_results.boxes.xyxy.cpu().numpy().astype(int), custom_results.boxes.cls):
+        all_boxes.append(box)
+        all_classes.append(CUSTOM_CLASS_NAMES[int(cls)])
+    
+    # Pass 2: Pre-trained Model (Face Fallback)
+    if 'face' not in detected_custom_classes and pretrained_model is not None:
+        print(" Custom model missed 'face'. Trying pre-trained model as fallback.")
+        pretrained_results = pretrained_model.predict(source=image_data, conf=YOLO_CONFIDENCE_THRESHOLD, verbose=False)[0]
+        for box in pretrained_results.boxes:
+            if int(box.cls[0]) in PRETRAINED_CLASS_MAP:
+                all_boxes.append(box.xyxy.cpu().numpy().astype(int)[0])
+                all_classes.append("face (fallback)")
+    
+    # Pass 3: Specialized Model (Signature Fallback)
+    if 'signature' not in detected_custom_classes and signature_model is not None:
+        print(" Custom model missed 'signature'. Trying specialized signature model as fallback.")
+        signature_results = signature_model.predict(source=image_data, conf=YOLO_CONFIDENCE_THRESHOLD, verbose=False)[0]
+        for box in signature_results.boxes:
+            all_boxes.append(box.xyxy.cpu().numpy().astype(int)[0])
+            all_classes.append("signature (fallback)")
+    
+    return all_boxes, all_classes
+
+# --- OCR + LLM Functions ---
+def calculate_distance(bbox1, bbox2):
+    """Calculates the Euclidean distance between the centers of two bounding boxes."""
+    c1_x = (bbox1[0] + bbox1[2]) / 2
+    c1_y = (bbox1[1] + bbox1[3]) / 2
+    c2_x = (bbox2[0] + bbox2[2]) / 2
+    c2_y = (bbox2[1] + bbox2[3]) / 2
+    return math.sqrt((c2_x - c1_x)**2 + (c2_y - c1_y)**2)
+
+def refine_pii_flags(ocr_results, isolation_threshold=150):
+    """Post-processing step to unmark short, isolated PII detections."""
+    pii_indices = [i for i, result in enumerate(ocr_results) if result["is_pii"]]
+  
+    if len(pii_indices) <= 1:
+        return ocr_results
+    indices_to_unmark = []
+    for i in pii_indices:
+        current_result = ocr_results[i]
+        normalized_text = re.sub(r'[^a-zA-Z0-9]', '', current_result["text"])
+      
+        if len(normalized_text) <= 3:
+            min_dist_to_neighbor = float('inf')
+          
+            for j in pii_indices:
+                if i == j:
+                    continue
+              
+                other_result = ocr_results[j]
+                dist = calculate_distance(current_result["bbox"], other_result["bbox"])
+                if dist < min_dist_to_neighbor:
+                    min_dist_to_neighbor = dist
+          
+            if min_dist_to_neighbor > isolation_threshold:
+                print(f" - Refining PII: Unmarking short ('{current_result['text']}') and isolated (min_dist: {min_dist_to_neighbor:.2f}px) PII.")
+                indices_to_unmark.append(i)
+    
+    for i in indices_to_unmark:
+        ocr_results[i]["is_pii"] = False
+          
+    return ocr_results
+
+def parse_pii_output(generated_text):
+    """Parse the new curly braces format PII output"""
+    pii_list = []
+    try:
+        match = re.search(r'\{([^}]*)\}', generated_text)
+        if match:
+            content = match.group(1)
+            items = re.findall(r'"([^"]*)"', content)
+            pii_list = [item.strip() for item in items if item.strip()]
+    except Exception as e:
+        print(f"Error parsing PII output: {e}")
+        pii_list = []
+    return pii_list
+
+def normalize_text(text):
+    """Comprehensive text normalization for better matching"""
+    if not text:
+        return ""
+  
+    normalized = re.sub(r'[.,;:!?()"\'\-_/\\]', '', text)
+  
+    ocr_corrections = {
+        '0': 'o', 'O': '0', '1': 'l', 'l': '1', '5': 's', 'S': '5',
+        '8': 'b', 'B': '8', 'rn': 'm', 'RN': 'M', 'vv': 'w', 'VV': 'W',
+        'cl': 'd', 'CL': 'D',
+    }
+  
+    for wrong, correct in ocr_corrections.items():
+        normalized = normalized.replace(wrong, correct)
+  
+    normalized = ' '.join(normalized.split()).lower()
+    return normalized
+
+def fuzzy_match_score(text1, text2, threshold=0.8):
+    """Calculate fuzzy matching score between two strings"""
+    if not text1 or not text2:
+        return False
+    return difflib.SequenceMatcher(None, text1.lower(), text2.lower()).ratio() >= threshold
+
+def levenshtein_distance(s1, s2):
+    """Calculate Levenshtein distance between two strings"""
+    if len(s1) < len(s2):
+        return levenshtein_distance(s2, s1)
+  
+    if len(s2) == 0:
+        return len(s1)
+  
+    previous_row = list(range(len(s2) + 1))
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+            current_row.append(min(insertions, deletions, substitutions))
+        previous_row = current_row
+  
+    return previous_row[-1]
+
+def is_similar_by_edit_distance(text1, text2, max_distance=2):
+    """Check if two texts are similar within edit distance threshold"""
+    if not text1 or not text2:
+        return False
+  
+    distance = levenshtein_distance(text1.lower(), text2.lower())
+    max_len = max(len(text1), len(text2))
+  
+    if max_len <= 3:
+        threshold = 1
+    elif max_len <= 6:
+        threshold = 2
+    else:
+        threshold = min(max_distance, max_len // 3)
+  
+    return distance <= threshold
+
+def extract_sentence_text(ocr_results):
+    """Extract sentence-based text for LLM input"""
+    paragraph_text = ""
+    for item in ocr_results:
+        if len(item) == 3:
+            _, text, _ = item
+        elif len(item) == 2:
+            _, text = item
+        else:
+            print(f"Unexpected OCR result format: {item}")
+            continue
+        if text.strip():
+            paragraph_text += text + " "
+    return paragraph_text.strip()
+
+def extract_word_bboxes_improved(ocr_results):
+    """Improved word extraction with better handling of punctuation and spacing"""
+    word_bbox_map = []
+  
+    for item in ocr_results:
+        if len(item) == 3:
+            bbox, text, confidence = item
+        elif len(item) == 2:
+            bbox, text = item
+            confidence = 1.0
+        else:
+            print(f"Unexpected OCR result format: {item}")
+            continue
+      
+        original_text = text.strip()
+        if not original_text:
+            continue
+      
+        if isinstance(bbox[0], (list, tuple)):
+            x_coords = [point[0] for point in bbox]
+            y_coords = [point[1] for point in bbox]
+            line_x1, line_y1 = min(x_coords), min(y_coords)
+            line_x2, line_y2 = max(x_coords), max(y_coords)
+        else:
+            line_x1, line_y1, line_x2, line_y2 = bbox
+      
+        tokens = re.findall(r'\S+', original_text)
+        if len(tokens) <= 1:
+            padding = 1
+            word_bbox_map.append({
+                "word": original_text,
+                "bbox": [
+                    max(0, int(line_x1 - padding)),
+                    max(0, int(line_y1 - padding)),
+                    int(line_x2 + padding),
+                    int(line_y2 + padding)
+                ],
+                "confidence": confidence,
+                "original_line": original_text
+            })
+            continue
+      
+        full_width = line_x2 - line_x1
+        full_height = line_y2 - line_y1
+        text_without_spaces = original_text.replace(' ', '')
+        total_chars = len(text_without_spaces)
+      
+        char_position = 0
+        for i, token in enumerate(tokens):
+            token_start_ratio = char_position / total_chars if total_chars > 0 else 0
+            char_position += len(token)
+            token_end_ratio = char_position / total_chars if total_chars > 0 else 1
+          
+            token_x1 = line_x1 + (full_width * token_start_ratio)
+            token_x2 = line_x1 + (full_width * token_end_ratio)
+          
+            padding = 1
+            word_bbox = [
+                max(0, int(token_x1 - padding)),
+                max(0, int(line_y1 - padding)),
+                int(min(token_x2 + padding, line_x2)),
+                int(line_y2 + padding)
+            ]
+          
+            word_bbox_map.append({
+                "word": token,
+                "bbox": word_bbox,
+                "confidence": confidence,
+                "original_line": original_text
+            })
+  
+    return sorted(word_bbox_map, key=lambda x: (x['bbox'][1], x['bbox'][0]))
+
+def advanced_match_pii_to_words(pii_list, word_bbox_map):
+    """Advanced multi-strategy PII matching with comprehensive fallbacks"""
+    ocr_results_for_template = []
+    words = [info['word'] for info in word_bbox_map]
+    bboxes = [info['bbox'] for info in word_bbox_map]
+    is_pii_flags = [False] * len(words)
+  
+    # Pre-process all words with different normalization strategies
+    normalized_words = [normalize_text(word) for word in words]
+  
+    print(f"Processing {len(pii_list)} PII items against {len(words)} OCR words")
+  
+    for pii_idx, pii_item in enumerate(pii_list):
+        if not pii_item.strip():
+            continue
+      
+        print(f"Processing PII item {pii_idx + 1}: '{pii_item}'")
+      
+        # Normalize the PII item
+        normalized_pii = normalize_text(pii_item)
+        pii_words = normalized_pii.split()
+      
+        if not pii_words:
+            continue
+      
+        matched = False
+      
+        # Strategy 1: Exact matching after normalization
+        if len(pii_words) == 1:
+            pii_word = pii_words[0]
+            for idx, norm_word in enumerate(normalized_words):
+                if norm_word == pii_word and not is_pii_flags[idx]:
+                    is_pii_flags[idx] = True
+                    matched = True
+                    print(f" ✓ Exact match: '{words[idx]}' -> '{pii_item}'")
+        else:
+            # Multi-word exact matching
+            pii_len = len(pii_words)
+            start_idx = 0
+            while start_idx < len(normalized_words) - pii_len + 1:
+                exact_match = True
+                for j in range(pii_len):
+                    if normalized_words[start_idx + j] != pii_words[j]:
+                        exact_match = False
+                        break
+              
+                if exact_match:
+                    # Check spatial proximity
+                    spatial_ok = True
+                    for j in range(1, pii_len):
+                        prev_bbox = bboxes[start_idx + j - 1]
+                        curr_bbox = bboxes[start_idx + j]
+                      
+                        horizontal_distance = curr_bbox[0] - prev_bbox[2]
+                        vertical_alignment = (abs(prev_bbox[1] - curr_bbox[1]) < 30 and
+                                              abs(prev_bbox[3] - curr_bbox[3]) < 30)
+                      
+                        if not (vertical_alignment and horizontal_distance <= 150):
+                            spatial_ok = False
+                            break
+                  
+                    if spatial_ok:
+                        for j in range(pii_len):
+                            if not is_pii_flags[start_idx + j]:
+                                is_pii_flags[start_idx + j] = True
+                        matched = True
+                        matched_text = ' '.join(words[start_idx:start_idx + pii_len])
+                        print(f" ✓ Multi-word exact: '{matched_text}' -> '{pii_item}'")
+                        start_idx += pii_len
+                        continue
+                start_idx += 1
+      
+        # Strategy 2: Fuzzy matching if exact matching failed
+        if not matched:
+            if len(pii_words) == 1:
+                pii_word = pii_words[0]
+                for idx, norm_word in enumerate(normalized_words):
+                    if (not is_pii_flags[idx] and
+                        (fuzzy_match_score(norm_word, pii_word, 0.9) or
+                         is_similar_by_edit_distance(norm_word, pii_word, 2))):
+                        is_pii_flags[idx] = True
+                        matched = True
+                        print(f" ✓ Fuzzy match: '{words[idx]}' -> '{pii_item}'")
+            else:
+                # Multi-word fuzzy matching
+                pii_len = len(pii_words)
+                start_idx = 0
+                while start_idx < len(normalized_words) - pii_len + 1:
+                    fuzzy_match = True
+                    for j in range(pii_len):
+                        if not (fuzzy_match_score(normalized_words[start_idx + j], pii_words[j], 0.85) or
+                                is_similar_by_edit_distance(normalized_words[start_idx + j], pii_words[j], 2)):
+                            fuzzy_match = False
+                            break
+                  
+                    if fuzzy_match:
+                        # Check spatial proximity
+                        spatial_ok = True
+                        for j in range(1, pii_len):
+                            prev_bbox = bboxes[start_idx + j - 1]
+                            curr_bbox = bboxes[start_idx + j]
+                          
+                            horizontal_distance = curr_bbox[0] - prev_bbox[2]
+                            vertical_alignment = (abs(prev_bbox[1] - curr_bbox[1]) < 30 and
+                                                  abs(prev_bbox[3] - curr_bbox[3]) < 30)
+                          
+                            if not (vertical_alignment and horizontal_distance <= 150):
+                                spatial_ok = False
+                                break
+                      
+                        if spatial_ok:
+                            for j in range(pii_len):
+                                if not is_pii_flags[start_idx + j]:
+                                    is_pii_flags[start_idx + j] = True
+                            matched = True
+                            matched_text = ' '.join(words[start_idx:start_idx + pii_len])
+                            print(f" ✓ Multi-word fuzzy: '{matched_text}' -> '{pii_item}'")
+                            start_idx += pii_len
+                            continue
+                    start_idx += 1
+      
+        # Strategy 3: Substring and partial matching
+        if not matched:
+            full_normalized_text = ' '.join(normalized_words)
+          
+            pos = 0
+            while True:
+                start_pos = full_normalized_text.find(normalized_pii, pos)
+                if start_pos == -1:
+                    break
+                end_pos = start_pos + len(normalized_pii)
+              
+                char_count = 0
+                start_word_idx = None
+                end_word_idx = None
+              
+                for idx, norm_word in enumerate(normalized_words):
+                    word_start = char_count
+                    word_end = char_count + len(norm_word)
+                  
+                    if start_word_idx is None and word_end > start_pos:
+                        start_word_idx = idx
+                  
+                    if word_start < end_pos:
+                        end_word_idx = idx
+                  
+                    char_count += len(norm_word) + 1
+              
+                if start_word_idx is not None and end_word_idx is not None and end_word_idx - start_word_idx + 1 >= len(pii_words):
+                    spatial_ok = True
+                    for j in range(start_word_idx, end_word_idx):
+                        if j + 1 <= end_word_idx:
+                            prev_bbox = bboxes[j]
+                            next_bbox = bboxes[j + 1]
+                          
+                            horizontal_distance = next_bbox[0] - prev_bbox[2]
+                            vertical_alignment = (abs(prev_bbox[1] - next_bbox[1]) < 30 and
+                                                  abs(prev_bbox[3] - next_bbox[3]) < 30)
+                          
+                            if not (vertical_alignment and horizontal_distance <= 200):
+                                spatial_ok = False
+                                break
+                  
+                    if spatial_ok:
+                        for j in range(start_word_idx, end_word_idx + 1):
+                            if not is_pii_flags[j]:
+                                is_pii_flags[j] = True
+                        matched = True
+                        matched_text = ' '.join(words[start_word_idx:end_word_idx + 1])
+                        print(f" ✓ Substring match: '{matched_text}' -> '{pii_item}'")
+                pos = end_pos
+      
+        # Strategy 4: Individual word matching with relaxed criteria
+        if not matched:
+            for pii_word in pii_words:
+                if len(pii_word) < 3:
+                    continue
+              
+                for idx, norm_word in enumerate(normalized_words):
+                    if not is_pii_flags[idx]:
+                        if (norm_word == pii_word or
+                            fuzzy_match_score(norm_word, pii_word, 0.8) or
+                            is_similar_by_edit_distance(norm_word, pii_word, 2) or
+                            (len(pii_word) > 5 and (pii_word in norm_word or norm_word in pii_word))):
+                            is_pii_flags[idx] = True
+                            print(f" ✓ Individual word match: '{words[idx]}' -> '{pii_word}' from '{pii_item}'")
+      
+        if not matched:
+            print(f" ✗ No match found for: '{pii_item}'")
+  
+    for idx, word_info in enumerate(word_bbox_map):
+        ocr_results_for_template.append({
+            "text": word_info["word"],
+            "bbox": word_info["bbox"],
+            "is_pii": is_pii_flags[idx],
+            "confidence": word_info.get("confidence", 1.0)
+        })
+  
+    ocr_results_for_template = merge_horizontal_pii_boxes_improved(ocr_results_for_template)
+  
+    return ocr_results_for_template
+
+def merge_horizontal_pii_boxes_improved(ocr_results, merge_distance=50):
+    """Improved merging with better spatial awareness and tighter boxes"""
+    if not ocr_results:
+        return ocr_results
+  
+    merged_results = []
+    i = 0
+  
+    while i < len(ocr_results):
+        current_word = ocr_results[i]
+      
+        if not current_word["is_pii"]:
+            merged_results.append(current_word)
+            i += 1
+            continue
+      
+        merge_group = [current_word]
+        j = i + 1
+      
+        while j < len(ocr_results):
+            next_word = ocr_results[j]
+          
+            if not next_word["is_pii"]:
+                break
+          
+            current_bbox = merge_group[-1]["bbox"]
+            next_bbox = next_word["bbox"]
+          
+            y_center_current = (current_bbox[1] + current_bbox[3]) / 2
+            y_center_next = (next_bbox[1] + next_bbox[3]) / 2
+            y_overlap = abs(y_center_current - y_center_next) < 20
+          
+            horizontal_distance = next_bbox[0] - current_bbox[2]
+          
+            if y_overlap and horizontal_distance <= merge_distance:
+                merge_group.append(next_word)
+                j += 1
+            else:
+                break
+      
+        if len(merge_group) > 1:
+            min_x = min(word["bbox"][0] for word in merge_group)
+            min_y = min(word["bbox"][1] for word in merge_group)
+            max_x = max(word["bbox"][2] for word in merge_group)
+            max_y = max(word["bbox"][3] for word in merge_group)
+          
+            merged_text = " ".join(word["text"] for word in merge_group)
+          
+            merged_word = {
+                "text": merged_text,
+                "bbox": [min_x, min_y, max_x, max_y],
+                "is_pii": True,
+                "confidence": max(word.get("confidence", 1.0) for word in merge_group)
+            }
+            merged_results.append(merged_word)
+            print(f" ✓ Merged PII box: '{merged_text}' at [{min_x},{min_y},{max_x},{max_y}]")
+        else:
+            merged_results.append(current_word)
+      
+        i = j
+  
+    return merged_results
+
+def post_process_pii_detection(ocr_results_for_template, pii_list):
+    """Post-process to catch any missed PII using relaxed matching"""
+    words = [result["text"] for result in ocr_results_for_template]
+  
+    for pii_item in pii_list:
+        normalized_pii = normalize_text(pii_item)
+        pii_words = normalized_pii.split()
+      
+        if not pii_words:
+            continue
+      
+        pii_detected = False
+        for result in ocr_results_for_template:
+            if result["is_pii"]:
+                result_normalized = normalize_text(result["text"])
+                if (normalized_pii in result_normalized or
+                    result_normalized in normalized_pii or
+                    fuzzy_match_score(result_normalized, normalized_pii, 0.7)):
+                    pii_detected = True
+                    break
+      
+        if not pii_detected:
+            print(f" ⚠ PII not detected, trying fallback matching: '{pii_item}'")
+          
+            for idx, result in enumerate(ocr_results_for_template):
+                if result["is_pii"]:
+                    continue
+              
+                word_normalized = normalize_text(result["text"])
+              
+                for pii_word in pii_words:
+                    if (len(pii_word) > 3 and
+                        (pii_word in word_normalized or
+                         word_normalized in pii_word or
+                         fuzzy_match_score(word_normalized, pii_word, 0.6) or
+                         is_similar_by_edit_distance(word_normalized, pii_word, 3))):
+                      
+                        ocr_results_for_template[idx]["is_pii"] = True
+                        print(f" ✓ Fallback match: '{result['text']}' -> '{pii_word}' from '{pii_item}'")
+                        break
+  
+    return ocr_results_for_template
+
+def detect_pii_from_combined_text(combined_text):
+    """Detect PII from combined multi-page text using LLM"""
+    if llama_model is None:
+        print("LLM model not available for PII detection")
+        return [], "LLM model not available"
+  
+    instruction = (
+        "Extract all Personally Identifiable Information (PII) of the main subject from the given text. "
+        "Include data like Name, Date of Birth, Gender, Address, Phone Number, Email, Social Security Number (SSN), Member ID, Group Number, or any other PII data available. "
+        "Ignore any information about doctors, staff, providers, colleagues, organizations, companies, hospitals, educational institutes, or facilities. "
+        "Return the results strictly as a flat set of strings enclosed in { } without labels."
+    )
+    prompt_content = f"{instruction}\n{combined_text}"
+  
+    pii_list = []
+    llama_raw_output = ""
+    try:
+        messages = [{"role": "user", "content": prompt_content}]
+        response = llama_model.create_chat_completion(
+            messages=messages,
+            max_tokens=512,
+            temperature=0.1,
+        )
+        llama_raw_output = response['choices'][0]['message']['content']
+        pii_list = parse_pii_output(llama_raw_output)
+        print(f"LLM detected {len(pii_list)} PII items from combined text: {pii_list}")
+    except Exception as e:
+        print(f"Error during Llama PII detection: {e}")
+        llama_raw_output = f"Error: {str(e)}"
+        pii_list = []
+  
+    return pii_list, llama_raw_output
+
+# --- Combined Processing Function ---
+def process_page_combined(img_cv, global_pii_list):
+    """Process a single page with both YOLO and OCR+LLM detection"""
+    all_detections = []
+  
+    # Step 1: YOLO Visual Detection
+    print(" Running YOLO visual detection...")
+    visual_boxes, visual_classes = detect_visual_pii(img_cv)
+  
+    for box, cls in zip(visual_boxes, visual_classes):
+        all_detections.append({
+            "text": cls,
+            "bbox": box.tolist() if hasattr(box, 'tolist') else box,
+            "is_pii": True,
+            "confidence": 1.0,
+            "detection_type": "visual"
+        })
+  
+    print(f" YOLO detected {len(visual_boxes)} visual elements")
+  
+    # Step 2: OCR + LLM Text Detection
+    if reader is not None:
+        print(" Running OCR text extraction...")
+        word_ocr_results = reader.readtext(img_cv, paragraph=False, width_ths=0.7, height_ths=0.7)
+      
+        if word_ocr_results:
+            word_bbox_map = extract_word_bboxes_improved(word_ocr_results)
+          
+            ocr_results_for_template = advanced_match_pii_to_words(global_pii_list, word_bbox_map)
+            ocr_results_for_template = post_process_pii_detection(ocr_results_for_template, global_pii_list)
+            ocr_results_for_template = refine_pii_flags(ocr_results_for_template)
+            ocr_results_for_template = merge_horizontal_pii_boxes_improved(ocr_results_for_template)
+          
+            for result in ocr_results_for_template:
+                if result["is_pii"]:
+                    result["detection_type"] = "text"
+                    all_detections.append(result)
+          
+            print(f" OCR detected {sum(1 for r in ocr_results_for_template if r['is_pii'])} text PII elements")
+  
+    return all_detections
+
+# --- Main Gradio Processing Function ---
+def analyze_document(file, progress=gr.Progress()):
+    """
+    This function takes an uploaded file, processes it through the PII detection pipeline,
+    and returns the annotated images, a redacted PDF, and a summary report.
+    """
+    load_models()
+    if file is None:
+        return None, None, "Please upload a document to begin."
+    
+    unique_id = uuid.uuid4().hex
+  
+    if hasattr(file, 'name'):
+        filepath = file.name
+    else:
+        filepath = str(file)
+  
+    filename = os.path.basename(filepath)
+    extension = os.path.splitext(filename)[1]
+    
+    progress(0, desc="Converting document to images...")
+    images_to_process = []
+    try:
+        if extension.lower() == '.pdf':
+            try:
+                images_to_process = [cv2.cvtColor(np.array(page), cv2.COLOR_RGB2BGR) for page in convert_from_path(filepath, dpi=300)]
+            except Exception as e:
+                print(f"PDF conversion error: {e}. Trying fallback method...")
+                try:
+                    images_to_process = [cv2.cvtColor(np.array(page), cv2.COLOR_RGB2BGR) for page in convert_from_path(filepath, dpi=150)]
+                except Exception as e2:
+                    return None, None, f"🔴 **Error:** Could not process PDF. Please ensure Poppler is installed or try converting to images first.\nDetails: {e2}"
+        else:
+            img = cv2.imread(filepath)
+            if img is not None:
+                images_to_process.append(img)
+    except Exception as e:
+        return None, None, f"🔴 **Error:** Could not process file. Details: {e}"
+    
+    if not images_to_process:
+        return None, None, "🔴 **Error:** No pages could be extracted from the document."
+    
+    total_pages = len(images_to_process)
+    print(f"Processing {total_pages} pages for job {unique_id}...")
+    
+    progress(0.1, desc="Extracting text from all pages (OCR)...")
+    combined_text, all_pages_data = "", []
+    for i, img_cv in enumerate(images_to_process):
+        page_text = ""
+        if reader:
+            page_text = extract_sentence_text(reader.readtext(img_cv, paragraph=True))
+            combined_text += f"\n--- Page {i+1} ---\n{page_text}\n"
+        all_pages_data.append({"img_cv": img_cv, "page_num": i + 1})
+    
+    progress(0.4, desc="Analyzing text for PII with LLM...")
+    global_pii_list, llama_raw_output = detect_pii_from_combined_text(combined_text)
+    
+    annotated_paths, redacted_pils = [], []
+    report = f"## 🔍 Analysis Report\n**Global PII Found:** `{', '.join(global_pii_list) if global_pii_list else 'None'}`\n\n---\n"
+    for i, page_info in enumerate(all_pages_data):
+        progress(0.5 + (i / total_pages * 0.4), desc=f"Processing Page {i+1}/{total_pages} (Visual & Text)...")
+        img_cv, page_num = page_info["img_cv"], page_info["page_num"]
+        detections = process_page_combined(img_cv, global_pii_list)
+      
+        annotated_img, redacted_img = img_cv.copy(), img_cv.copy()
+        visual_count = sum(1 for d in detections if d["detection_type"] == "visual")
+        text_count = sum(1 for d in detections if d.get("detection_type") == "text")
+        for d in detections:
+            bbox = d.get("bbox", [])
+            if not bbox: continue
+            x1, y1, x2, y2 = map(int, bbox)
+            color = (0, 255, 0) if d.get("detection_type") == "visual" else (0, 0, 255)
+            cv2.rectangle(annotated_img, (x1, y1), (x2, y2), color, 3)
+            cv2.rectangle(redacted_img, (x1, y1), (x2, y2), (0, 0, 0), -1)
+        
+        path = os.path.join(RESULTS_FOLDER, f"annotated_{unique_id}_{page_num}.jpg")
+        cv2.imwrite(path, annotated_img)
+        annotated_paths.append(path)
+        redacted_pils.append(Image.fromarray(cv2.cvtColor(redacted_img, cv2.COLOR_BGR2RGB)))
+      
+        report += f"### 📄 Page {page_num}\n- **Visual Detections (🟩 Green):** {visual_count}\n- **Text Detections (🟥 Red):** {text_count}\n"
+    
+    progress(0.9, desc="Generating final redacted PDF...")
+    redacted_pdf_path = None
+    if redacted_pils:
+        pdf_path = os.path.join(RESULTS_FOLDER, f"redacted_{unique_id}.pdf")
+        redacted_pils[0].save(pdf_path, "PDF", resolution=100.0, save_all=True, append_images=redacted_pils[1:])
+        redacted_pdf_path = pdf_path
+  
+    progress(1, desc="Complete!")
+    print("Processing Complete.")
+    return annotated_paths, redacted_pdf_path, report
+
+# --- Gradio Interface Definition ---
+title = "🔒 Combined PII Detection System"
+description = """
+### Advanced Multi-Modal PII Detection
+This system uses a combination of visual and textual analysis to detect and redact Personally Identifiable Information from your documents.
+- **🖼️ Visual Detection (YOLO):** Detects Faces, QR Codes, and Signatures.
+- **📝 Text Detection (OCR + LLM):** Detects Names, Addresses, Phone Numbers, IDs, and other contextual PII.
+**How to Use:**
+1. Upload a document (PDF or image format).
+2. The system will process each page and display annotated previews with colored boxes.
+3. A fully redacted PDF with blacked-out PII is generated for you to download.
+4. An analysis report summarizes the findings for each page.
+"""
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(f"<h1 style='margin-bottom: 0.25rem;'>{title}</h1>")
+    gr.Markdown(
+        "<p style='color:#475569; line-height:1.6;'>"
+        "Upload a PDF or image to detect and redact PII using visual detectors (🟩) and text analysis (🟥). "
+        "Fixed for local environment with proper YOLO support."
+        "</p>"
+    )
+    with gr.Accordion("About this tool", open=False):
+        gr.Markdown(description)
+    with gr.Tabs():
+        with gr.Tab("Run"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    file_input = gr.File(
+                        label="Upload Document",
+                        file_types=['.pdf', '.jpg', '.jpeg', '.png', '.bmp'],
+                        file_count="single",
+                        height=100
+                    )
+                    submit_btn = gr.Button("🚀 Analyze Document", variant="primary")
+                    with gr.Accordion("Tips", open=False):
+                        gr.Markdown(
+                            "- Prefer high-resolution files for better OCR results (300 DPI for PDFs).\n"
+                            "- For PDFs, ensure Poppler is installed on your system.\n"
+                            "- Visual detections are drawn in green; text-based detections are in red.\n"
+                            "- Use the Previews tab to inspect annotated pages and the Report tab to download the redacted PDF."
+                        )
+                with gr.Column(scale=1):
+                    gr.Markdown("### What happens during analysis")
+                    gr.Markdown(
+                        "- Convert pages to images\n"
+                        "- Run global OCR to build combined text\n"
+                        "- Use LLM to extract possible PII strings\n"
+                        "- Match PII back to words and merge boxes\n"
+                        "- Render annotated previews and build a redacted PDF"
+                    )
+                    clear_btn = gr.Button("🧹 Clear Results", variant="secondary")
+        with gr.Tab("Previews"):
+            gr.Markdown("### Annotated Previews (🟩 Visual, 🟥 Text)")
+            gallery_output = gr.Gallery(
+                label="Annotated Pages",
+                show_label=False,
+                elem_id="gallery",
+                columns=[2],
+                rows=[1],
+                object_fit="contain",
+                height=480
+            )
+        with gr.Tab("Report & Download"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Download")
+                    file_output = gr.File(label="Redacted PDF")
+                with gr.Column(scale=2):
+                    gr.Markdown("### Analysis Report")
+                    report_output = gr.Markdown(label="Analysis Report")
+    
+    submit_btn.click(
+        fn=analyze_document,
+        inputs=file_input,
+        outputs=[gallery_output, file_output, report_output]
+    )
+    
+    clear_btn.click(
+        fn=lambda: ([], None, "Ready. Upload a document and click Analyze."),
+        inputs=None,
+        outputs=[gallery_output, file_output, report_output]
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(server_port=7860)