Update app.py

app.py

@@ -5,7 +5,7 @@ from huggingface_hub import hf_hub_download
 import numpy as np
 import cv2
 import roboflow
-from collections import Counter
+from collections import Counter, defaultdict
 import re
 
 # --- 2. Load BOTH of your AI models ---
@@ -44,81 +44,91 @@ def enhance_plate_image(plate_crop):
     gray = cv2.cvtColor(plate_crop, cv2.COLOR_RGB2GRAY)
     
     # Enhancement 1: Adaptive histogram equalization
-    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
     enhanced_gray = clahe.apply(gray)
     enhanced_crops.append(cv2.cvtColor(enhanced_gray, cv2.COLOR_GRAY2RGB))
     
     # Enhancement 2: Gaussian blur + unsharp mask
     blurred = cv2.GaussianBlur(gray, (3, 3), 0)
-    unsharp = cv2.addWeighted(gray, 1.5, blurred, -0.5, 0)
+    unsharp = cv2.addWeighted(gray, 1.8, blurred, -0.8, 0)
     unsharp = np.clip(unsharp, 0, 255).astype(np.uint8)
     enhanced_crops.append(cv2.cvtColor(unsharp, cv2.COLOR_GRAY2RGB))
     
-    # Enhancement 3: Morphological operations
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
-    morph = cv2.morphologyEx(gray, cv2.MORPH_CLOSE, kernel)
-    enhanced_crops.append(cv2.cvtColor(morph, cv2.COLOR_GRAY2RGB))
+    # Enhancement 3: Contrast stretching
+    min_val, max_val = np.percentile(gray, [2, 98])
+    stretched = np.clip((gray - min_val) * 255 / (max_val - min_val), 0, 255).astype(np.uint8)
+    enhanced_crops.append(cv2.cvtColor(stretched, cv2.COLOR_GRAY2RGB))
     
-    # Enhancement 4: Bilateral filter
-    bilateral = cv2.bilateralFilter(gray, 9, 75, 75)
-    enhanced_crops.append(cv2.cvtColor(bilateral, cv2.COLOR_GRAY2RGB))
+    # Enhancement 4: Gamma correction
+    gamma_corrected = np.power(gray / 255.0, 0.7) * 255
+    gamma_corrected = gamma_corrected.astype(np.uint8)
+    enhanced_crops.append(cv2.cvtColor(gamma_corrected, cv2.COLOR_GRAY2RGB))
     
     return enhanced_crops
 
-def post_process_text(raw_text):
+def smart_character_correction(text, pattern_analysis=True):
     """
-    Apply license plate specific formatting and corrections
+    Intelligent character correction based on license plate patterns
     """
-    if not raw_text:
-        return raw_text
+    if not text or len(text) < 3:
+        return text
     
     # Remove any spaces first
-    text = raw_text.replace(" ", "")
-    
-    # Common character corrections for license plates
-    corrections = {
-        '0': 'O',  # In letter context
-        'O': '0',  # In number context  
-        'I': '1',
-        '1': 'I',
-        'S': '5',
-        '5': 'S',
-        'Z': '2',
-        'B': '8',
-        '8': 'B',
-        'G': '6',
-        '6': 'G'
-    }
+    text = text.replace(" ", "").upper()
     
-    # For Philippine plates, common format is 3 letters + 3 numbers (like NOV706)
-    if len(text) >= 6:
-        corrected_chars = list(text)
+    # Philippine license plate patterns analysis
+    def analyze_likely_pattern(s):
+        """Determine if sequence should be letters or numbers based on position and context"""
+        if len(s) < 6:
+            return s
+        
+        # Common Philippine patterns: ABC123, ABC1234, 123ABC
+        # Most common is 3 letters + 3-4 numbers
         
-        # First 3 should typically be letters
-        for i in range(min(3, len(corrected_chars))):
-            char = corrected_chars[i]
+        corrected = list(s)
+        
+        # Pattern 1: First 3 characters are typically letters
+        for i in range(min(3, len(corrected))):
+            char = corrected[i]
             if char.isdigit():
-                # Convert common digit misreads to letters
-                if char in ['0', '1', '5', '8']:
-                    letter_map = {'0': 'O', '1': 'I', '5': 'S', '8': 'B'}
-                    corrected_chars[i] = letter_map.get(char, char)
+                # Convert numbers that look like letters
+                digit_to_letter = {'0': 'O', '1': 'I', '2': 'Z', '5': 'S', '6': 'G', '8': 'B'}
+                if char in digit_to_letter:
+                    corrected[i] = digit_to_letter[char]
         
-        # Last 3 should typically be numbers  
-        for i in range(3, min(6, len(corrected_chars))):
-            char = corrected_chars[i]
+        # Pattern 2: Characters after position 3 are typically numbers
+        for i in range(3, len(corrected)):
+            char = corrected[i]
             if char.isalpha():
-                # Convert common letter misreads to numbers
-                if char in ['O', 'I', 'S', 'B', 'G', 'Z']:
-                    number_map = {'O': '0', 'I': '1', 'S': '5', 'B': '8', 'G': '6', 'Z': '2'}
-                    corrected_chars[i] = number_map.get(char, char)
+                # Convert letters that look like numbers
+                letter_to_digit = {'O': '0', 'I': '1', 'L': '1', 'S': '5', 'G': '6', 'B': '8', 'Z': '2', 'T': '7'}
+                if char in letter_to_digit:
+                    corrected[i] = letter_to_digit[char]
         
-        text = ''.join(corrected_chars)
+        return ''.join(corrected)
+    
+    # Apply pattern-based corrections if enabled
+    if pattern_analysis and len(text) >= 6:
+        text = analyze_likely_pattern(text)
+    
+    # Additional common OCR error corrections
+    ocr_corrections = {
+        # Numbers that might be misread as letters
+        'Q': '0',  # Q often confused with O/0
+        'D': '0',  # D sometimes looks like 0
+        # Letters that might be misread as numbers  
+        'A': 'A',  # Keep A as is (could be confused with 4 but A is common in plates)
+    }
+    
+    # Apply only high-confidence corrections
+    for old_char, new_char in ocr_corrections.items():
+        text = text.replace(old_char, new_char)
     
     return text
 
-def improved_filtering(boxes, character_results, plate_crop_shape, min_confidence=0.3):
+def advanced_detection_filtering(boxes, character_results, plate_crop_shape, min_confidence=0.25):
     """
-    Enhanced filtering focusing on main license plate number only
+    Advanced filtering with clustering and statistical analysis
     """
     if len(boxes) == 0:
         return []
@@ -142,66 +152,156 @@ def improved_filtering(boxes, character_results, plate_crop_shape, min_confidenc
             'width': float(x2 - x1),
             'height': float(y2 - y1),
             'center_x': float((x1 + x2) / 2),
-            'center_y': float((y1 + y2) / 2)
+            'center_y': float((y1 + y2) / 2),
+            'area': float((x2 - x1) * (y2 - y1))
         })
     
     if len(detections) == 0:
         return []
     
-    # MAIN IMPROVEMENT: Focus on the upper portion of the plate
-    # Most license plates have the main number in the top 60% of the plate
-    plate_height = plate_crop_shape[0]
-    upper_threshold = plate_height * 0.70  # Only consider top 65% of plate
-    
-    # Filter out detections in lower portion (subsidiary text area)
-    upper_detections = [d for d in detections if d['center_y'] <= upper_threshold]
+    plate_height, plate_width = plate_crop_shape[:2]
     
-    if len(upper_detections) == 0:
-        # Fallback: if no detections in upper area, use all but be more selective
-        upper_detections = detections
-        print("Warning: No detections in upper area, using all detections")
+    # Step 1: Focus on main character area (upper 75% of plate)
+    main_area_threshold = plate_height * 0.75
+    main_detections = [d for d in detections if d['center_y'] <= main_area_threshold]
     
-    print(f"Filtered to upper area: {len(upper_detections)}/{len(detections)} detections")
+    if len(main_detections) < 3:  # If too few in main area, expand slightly
+        main_area_threshold = plate_height * 0.85
+        main_detections = [d for d in detections if d['center_y'] <= main_area_threshold]
     
-    # Calculate statistics for filtering (now only on upper detections)
-    heights = [d['height'] for d in upper_detections]
-    widths = [d['width'] for d in upper_detections]
-    y_centers = [d['center_y'] for d in upper_detections]
+    if len(main_detections) == 0:
+        main_detections = detections
     
-    if len(heights) == 0:
-        return []
+    # Step 2: Statistical filtering based on size and position
+    heights = [d['height'] for d in main_detections]
+    widths = [d['width'] for d in main_detections]
+    y_positions = [d['center_y'] for d in main_detections]
+    areas = [d['area'] for d in main_detections]
     
+    # Calculate robust statistics (using percentiles to avoid outlier influence)
     median_height = np.median(heights)
     median_width = np.median(widths)
-    median_y_center = np.median(y_centers)
+    median_y = np.median(y_positions)
+    q75_area = np.percentile(areas, 75)
     
-    # More aggressive filtering for main plate numbers
+    # Step 3: Multi-criteria filtering
     filtered_detections = []
-    for detection in upper_detections:
-        # Size filtering (tighter for main numbers)
+    
+    for detection in main_detections:
+        # Size consistency check
         height_ratio = detection['height'] / median_height
         width_ratio = detection['width'] / median_width
         
-        # Alignment filtering (tighter)
-        y_deviation = abs(detection['center_y'] - median_y_center)
-        max_y_deviation = median_height * 0.4  # Reduced from 0.6 to 0.4
+        # Vertical alignment check  
+        y_deviation = abs(detection['center_y'] - median_y)
+        max_y_deviation = median_height * 0.5
+        
+        # Minimum size threshold (avoid tiny noise detections)
+        min_size_threshold = plate_height * 0.12
         
-        # Height-based filtering: main numbers are usually larger
-        min_height_threshold = plate_height * 0.15  # At least 15% of plate height
+        # Area-based filtering (avoid unusually small detections)
+        area_threshold = q75_area * 0.3
         
-        # Keep detection if it passes all criteria
-        if (0.5 <= height_ratio <= 2.0 and      # Tighter height range
-            0.4 <= width_ratio <= 2.5 and       # Tighter width range  
-            y_deviation <= max_y_deviation and   # Better alignment
-            detection['height'] >= min_height_threshold):  # Minimum size
+        # Apply all criteria
+        if (0.4 <= height_ratio <= 2.5 and
+            0.3 <= width_ratio <= 3.0 and
+            y_deviation <= max_y_deviation and
+            detection['height'] >= min_size_threshold and
+            detection['area'] >= area_threshold):
+            
             filtered_detections.append(detection)
     
-    return filtered_detections
+    # Step 4: Remove duplicate detections (same character in nearby positions)
+    final_detections = []
+    used_positions = []
+    
+    # Sort by confidence first
+    filtered_detections.sort(key=lambda x: x['conf'], reverse=True)
+    
+    for detection in filtered_detections:
+        # Check if this position is too close to already used positions
+        too_close = False
+        for used_x in used_positions:
+            if abs(detection['center_x'] - used_x) < median_width * 0.8:
+                too_close = True
+                break
+        
+        if not too_close:
+            final_detections.append(detection)
+            used_positions.append(detection['center_x'])
+    
+    return final_detections
+
+def ensemble_character_voting(all_detections, plate_width, confidence_threshold=0.35):
+    """
+    Advanced ensemble voting with spatial clustering and confidence weighting
+    """
+    if not all_detections:
+        return []
+    
+    # Step 1: Spatial clustering - group detections by x-position
+    position_groups = defaultdict(list)
+    cluster_tolerance = plate_width * 0.15  # 15% of plate width
+    
+    for detection in all_detections:
+        x_pos = detection['center_x']
+        
+        # Find existing cluster or create new one
+        assigned = False
+        for cluster_center in list(position_groups.keys()):
+            if abs(x_pos - cluster_center) <= cluster_tolerance:
+                position_groups[cluster_center].append(detection)
+                assigned = True
+                break
+        
+        if not assigned:
+            position_groups[x_pos].append(detection)
+    
+    # Step 2: For each spatial cluster, determine best character
+    final_characters = []
+    
+    for cluster_center, cluster_detections in position_groups.items():
+        # Group by character within cluster
+        char_groups = defaultdict(list)
+        for det in cluster_detections:
+            char_groups[det['char']].append(det)
+        
+        # Calculate weighted score for each character
+        best_char = None
+        best_score = 0
+        best_detection = None
+        
+        for char, char_detections in char_groups.items():
+            # Calculate score: weighted average of confidence + occurrence bonus
+            confidences = [d['conf'] for d in char_detections]
+            avg_confidence = np.mean(confidences)
+            max_confidence = max(confidences)
+            occurrence_bonus = min(len(char_detections) * 0.1, 0.3)  # Up to 30% bonus
+            
+            # Final score combines average confidence, max confidence, and occurrence
+            score = (avg_confidence * 0.5 + max_confidence * 0.4 + occurrence_bonus * 0.1)
+            
+            if score > best_score and avg_confidence > confidence_threshold:
+                best_score = score
+                best_char = char
+                # Use the detection with highest confidence as representative
+                best_detection = max(char_detections, key=lambda x: x['conf'])
+        
+        if best_char and best_detection:
+            best_detection['final_char'] = best_char
+            best_detection['final_score'] = best_score
+            best_detection['cluster_size'] = len(cluster_detections)
+            final_characters.append(best_detection)
+    
+    # Step 3: Sort by x-position for final ordering
+    final_characters.sort(key=lambda x: x['center_x'])
+    
+    return final_characters
 
 # --- 4. Enhanced main prediction function ---
 def detect_license_plate(input_image):
     """
-    Enhanced version with multi-enhancement processing and ensemble voting
+    Enhanced version with improved filtering and ensemble voting
     """
     print("New image received. Starting enhanced 2-stage pipeline...")
     output_image = input_image.copy()
@@ -219,126 +319,111 @@ def detect_license_plate(input_image):
                                        plate_box['x'] + plate_box['width'] / 2, 
                                        plate_box['y'] + plate_box['height'] / 2]]
     
-    # Add some padding to the plate crop, but reduce vertical padding to avoid extra text
-    h_padding = 8  # Horizontal padding
-    v_padding = 3  # Minimal vertical padding to avoid bottom text
+    # Optimized padding - minimal vertical to avoid extra text
+    h_padding = 10
+    v_padding = 2
     y1 = max(0, y1 - v_padding)
     x1 = max(0, x1 - h_padding)
     y2 = min(input_image.shape[0], y2 + v_padding)
     x2 = min(input_image.shape[1], x2 + h_padding)
     
     plate_crop = input_image[y1:y2, x1:x2]
+    plate_height, plate_width = plate_crop.shape[:2]
     
-    # Crop to focus on upper portion where main numbers are located
-    plate_height = plate_crop.shape[0]
-    # Keep top 70% of the plate to exclude bottom text area
-    main_number_crop = plate_crop[:int(plate_height * 0.7), :]
+    # Focus on main number area (top 75% of plate)
+    main_number_crop = plate_crop[:int(plate_height * 0.75), :]
     
     # --- STAGE 2: Multi-enhancement character detection ---
     enhanced_crops = enhance_plate_image(main_number_crop)
     
     all_detections = []
-    character_votes = {}
     
-    # Process each enhanced version
-    for i, enhanced_crop in enumerate(enhanced_crops):
+    # Process each enhanced version with different confidence thresholds
+    confidence_levels = [0.25, 0.3, 0.35, 0.25]  # Different thresholds for each enhancement
+    
+    for i, (enhanced_crop, conf_threshold) in enumerate(zip(enhanced_crops, confidence_levels)):
         try:
-            character_results = character_model(enhanced_crop, conf=0.3, iou=0.4)
+            character_results = character_model(enhanced_crop, conf=conf_threshold, iou=0.3)
             
             if character_results and hasattr(character_results[0], 'boxes') and len(character_results[0].boxes) > 0:
                 boxes = character_results[0].boxes.cpu().numpy()
-                filtered_detections = improved_filtering(boxes, character_results, 
-                                                       main_number_crop.shape, min_confidence=0.3)
+                filtered_detections = advanced_detection_filtering(
+                    boxes, character_results, main_number_crop.shape, min_confidence=conf_threshold
+                )
                 
-                print(f"Enhancement {i}: {len(boxes)} raw -> {len(filtered_detections)} filtered detections")
+                print(f"Enhancement {i}: {len(boxes)} raw -> {len(filtered_detections)} filtered")
                 
                 for detection in filtered_detections:
-                    # Add enhancement method info
-                    detection['enhancement'] = i
+                    detection['enhancement_method'] = i
+                    detection['enhancement_conf'] = conf_threshold
                     all_detections.append(detection)
                     
-                    # Collect votes for ensemble
-                    x_pos = int(detection['center_x'] / 8) * 8  # Tighter grouping
-                    key = f"x{x_pos}"
-                    if key not in character_votes:
-                        character_votes[key] = []
-                    character_votes[key].append((detection['char'], detection['conf']))
-                    
         except Exception as e:
             print(f"Error processing enhancement {i}: {e}")
             continue
     
-    # --- STAGE 3: Ensemble voting and final selection ---
-    final_detections = []
+    # --- STAGE 3: Advanced ensemble voting ---
+    final_detections = ensemble_character_voting(all_detections, plate_width, confidence_threshold=0.3)
     
-    if character_votes:
-        for x_key in sorted(character_votes.keys()):
-            votes = character_votes[x_key]
-            
-            # Weight votes by confidence and count
-            char_scores = {}
-            for char, conf in votes:
-                if char not in char_scores:
-                    char_scores[char] = []
-                char_scores[char].append(conf)
-            
-            # Calculate weighted scores
-            best_char = None
-            best_score = 0
-            
-            for char, confs in char_scores.items():
-                # Score = average confidence * count weight
-                avg_conf = np.mean(confs)
-                count_weight = min(len(confs) / len(enhanced_crops), 1.0)
-                score = avg_conf * (0.7 + 0.3 * count_weight)
-                
-                if score > best_score:
-                    best_score = score
-                    best_char = char
-            
-            if best_char and best_score > 0.3:
-                # Find representative detection for drawing
-                x_pos = int(x_key[1:])
-                representative = min([d for d in all_detections if abs(d['center_x'] - x_pos) < 15],
-                                   key=lambda x: abs(x['center_x'] - x_pos), default=None)
-                
-                if representative:
-                    representative['final_char'] = best_char
-                    representative['final_conf'] = best_score
-                    final_detections.append(representative)
+    print(f"Ensemble voting: {len(all_detections)} total -> {len(final_detections)} final")
     
-    # --- STAGE 4: Draw results and generate text ---
+    # --- STAGE 4: Generate and post-process text ---
+    if final_detections:
+        # Sort by x position
+        final_detections.sort(key=lambda x: x['center_x'])
+        raw_text = "".join([d['final_char'] for d in final_detections])
+        
+        # Apply smart character correction
+        corrected_text = smart_character_correction(raw_text, pattern_analysis=True)
+        
+        # Additional validation - remove obviously wrong characters
+        if len(corrected_text) > 8:  # If too long, might have false positives
+            # Keep only the most confident detections
+            final_detections = sorted(final_detections, key=lambda x: x['final_score'], reverse=True)[:7]
+            final_detections.sort(key=lambda x: x['center_x'])
+            raw_text = "".join([d['final_char'] for d in final_detections])
+            corrected_text = smart_character_correction(raw_text, pattern_analysis=True)
+    else:
+        raw_text = ""
+        corrected_text = ""
+    
+    # --- STAGE 5: Draw results ---
     # Draw the main plate box
     cv2.rectangle(output_image, (x1, y1), (x2, y2), (0, 0, 255), 2)
-    cv2.putText(output_image, f"Plate Conf: {plate_box['confidence']:.2f}", 
+    cv2.putText(output_image, f"Plate: {plate_box['confidence']:.1f}%", 
                 (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
     
-    # Draw character boxes (adjust coordinates back to main number crop area)
-    for detection in final_detections:
+    # Draw detection area boundary
+    main_area_y = y1 + int(plate_height * 0.75)
+    cv2.line(output_image, (x1, main_area_y), (x2, main_area_y), (255, 255, 0), 2)
+    cv2.putText(output_image, "Detection Area", (x1, main_area_y - 5), 
+                cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 0), 1)
+    
+    # Draw character detections
+    for i, detection in enumerate(final_detections):
         abs_x1 = x1 + int(detection['x1'])
         abs_y1 = y1 + int(detection['y1'])
         abs_x2 = x1 + int(detection['x2'])
         abs_y2 = y1 + int(detection['y2'])
         
-        cv2.rectangle(output_image, (abs_x1, abs_y1), (abs_x2, abs_y2), (0, 255, 0), 2)
-        cv2.putText(output_image, f"{detection['final_char']} {detection['final_conf']:.2f}", 
-                   (abs_x1, abs_y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
-    
-    # Draw a line to show the detection area boundary
-    main_area_y = y1 + int(plate_height * 0.7)
-    cv2.line(output_image, (x1, main_area_y), (x2, main_area_y), (255, 255, 0), 2)
-    
-    # Sort by x position and create final text
-    final_detections.sort(key=lambda x: x['center_x'])
-    raw_text = "".join([d['final_char'] for d in final_detections])
-    
-    # Apply post-processing
-    final_text = post_process_text(raw_text)
-    
-    result_text = f"Raw: {raw_text}\nProcessed: {final_text}" if raw_text != final_text else final_text
-    
-    print(f"Prediction complete. Final result: {result_text}")
-    print(f"Used {len(final_detections)} characters from {len(all_detections)} total detections")
+        # Color code by confidence
+        color = (0, 255, 0) if detection['final_score'] > 0.7 else (0, 255, 255)
+        
+        cv2.rectangle(output_image, (abs_x1, abs_y1), (abs_x2, abs_y2), color, 2)
+        cv2.putText(output_image, f"{detection['final_char']}", 
+                   (abs_x1, abs_y1 - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+        cv2.putText(output_image, f"{detection['final_score']:.2f}", 
+                   (abs_x1, abs_y1 - 3), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
+    
+    # Prepare result text
+    if raw_text != corrected_text and corrected_text:
+        result_text = f"Detected: {raw_text}\nCorrected: {corrected_text}\nConfidence: {len(final_detections)} chars"
+    elif corrected_text:
+        result_text = f"Result: {corrected_text}\nConfidence: {len(final_detections)} characters detected"
+    else:
+        result_text = "No characters detected with sufficient confidence"
+    
+    print(f"Final result: {result_text}")
     
     return output_image, result_text
 
@@ -346,19 +431,20 @@ def detect_license_plate(input_image):
 with gr.Blocks() as demo:
     gr.Markdown("# Enhanced High-Accuracy License Plate Detector")
     gr.Markdown("""
-    This system uses an advanced 2-stage AI pipeline with:
-    - Multiple image enhancement techniques
-    - Ensemble voting across different processed versions
-    - Smart filtering and post-processing
-    - Common license plate character corrections
+    **Improved Features:**
+    - Advanced statistical filtering with spatial clustering
+    - Smart character correction based on license plate patterns
+    - Enhanced ensemble voting with confidence weighting
+    - Optimized detection area focusing
+    - Multi-level confidence thresholds
     """)
     
     with gr.Row():
         image_input = gr.Image(type="numpy", label="Upload License Plate Image")
         image_output = gr.Image(type="numpy", label="Detection Results")
     
-    text_output = gr.Textbox(label="Detected Characters", lines=3)
-    predict_button = gr.Button(value="Detect Characters", variant="primary")
+    text_output = gr.Textbox(label="Detected License Plate", lines=3)
+    predict_button = gr.Button(value="Detect License Plate", variant="primary")
     
     predict_button.click(
         fn=detect_license_plate,