Update app.py

app.py

@@ -3,8 +3,8 @@ import cv2
 import numpy as np
 from PIL import Image
 
-def detect_text_lines(img_pil):
-    """Robust text line detection with multiple fallback strategies"""
+def find_text_lines_voynich(img_pil):
+    """Specialized function to find actual Voynich text lines, not page edges"""
     if img_pil is None:
         return None
     
@@ -15,138 +15,141 @@ def detect_text_lines(img_pil):
     else:
         gray = img
     
-    # Get image dimensions
     img_height, img_width = gray.shape
     print(f"Processing image: {img_width}x{img_height}")
     
-    # Strategy 1: Try with border cropping
-    border_x = int(img_width * 0.03)  # Reduced from 0.05
-    border_y = int(img_height * 0.03)
-    cropped_gray = gray[border_y:img_height-border_y, border_x:img_width-border_x]
-    
-    result = try_extract_line(cropped_gray, border_x, border_y, img, "Strategy 1 (cropped)")
-    if result is not None:
-        return result
-    
-    # Strategy 2: Try with full image
-    print("Strategy 1 failed, trying full image...")
-    result = try_extract_line(gray, 0, 0, img, "Strategy 2 (full)")
-    if result is not None:
-        return result
-    
-    # Strategy 3: Simple horizontal strip from top
-    print("Strategy 2 failed, trying horizontal strip...")
-    strip_height = min(100, img_height // 8)  # Top 1/8 of image or 100px
-    strip = img[0:strip_height, 0:img_width]
-    if strip.size > 0:
-        print(f"Returning top strip of size: {strip.shape}")
-        return Image.fromarray(strip)
-    
-    # Strategy 4: Return original if all else fails
-    print("All strategies failed, returning original image")
-    return img_pil
-
-def try_extract_line(gray, offset_x, offset_y, original_img, strategy_name):
-    """Try to extract a text line with given parameters"""
-    print(f"\n--- {strategy_name} ---")
+    # Skip the top portion where page edges and headers might be
+    # Look for text in the middle and lower portions
+    skip_top = int(img_height * 0.15)  # Skip top 15%
+    search_area = gray[skip_top:, :]
     
-    # Enhanced preprocessing
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    enhanced = clahe.apply(gray)
+    print(f"Searching in area starting from y={skip_top}")
     
-    # Multiple thresholding approaches
-    _, thresh_otsu = cv2.threshold(enhanced, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-    thresh_adaptive = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-                                           cv2.THRESH_BINARY_INV, 15, 8)
+    # Enhance contrast specifically for faded manuscript text
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+    enhanced = clahe.apply(search_area)
     
-    # Combine thresholds
-    thresh = cv2.bitwise_or(thresh_otsu, thresh_adaptive)
+    # Use adaptive thresholding which works better for manuscripts
+    thresh = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                   cv2.THRESH_BINARY_INV, 11, 2)
     
-    # Morphological operations - start gentle
-    horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 1))
-    dilated = cv2.dilate(thresh, horizontal_kernel, iterations=1)
+    # Create a small horizontal kernel to connect characters within words
+    # But keep it small to avoid connecting different lines
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (8, 1))
+    connected = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
     
     # Find contours
-    contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    print(f"Found {len(contours)} contours")
+    contours, _ = cv2.findContours(connected, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    print(f"Found {len(contours)} contours in search area")
     
-    if not contours:
-        return None
+    # Filter for text-like contours
+    text_contours = []
+    search_height, search_width = search_area.shape
+    
+    for i, contour in enumerate(contours):
+        x, y, w, h = cv2.boundingRect(contour)
+        area = cv2.contourArea(contour)
+        
+        # Calculate properties
+        aspect_ratio = w / h if h > 0 else 0
+        width_percent = (w / search_width) * 100
+        height_percent = (h / search_height) * 100
+        
+        print(f"Contour {i}: pos=({x},{y}), size=({w},{h}), ratio={aspect_ratio:.1f}, w%={width_percent:.1f}, h%={height_percent:.1f}")
+        
+        # Criteria for Voynich text lines:
+        # - Should be reasonably wide (at least 15% of width)
+        # - Should not be too tall (text lines are horizontal)
+        # - Should have good aspect ratio (wider than tall)
+        # - Should not be tiny (at least 10 pixels high for readability)
+        if (w >= search_width * 0.15 and    # Minimum width
+            h >= 10 and                      # Minimum height
+            h <= search_height * 0.05 and    # Maximum height (5% of search area)
+            aspect_ratio >= 3.0 and          # Should be wide
+            width_percent <= 90):            # Not the entire width (avoid page edges)
+            
+            text_contours.append((contour, x, y + skip_top, w, h))  # Add skip_top back to y
+            print(f"  ✓ ACCEPTED as text line")
+        else:
+            print(f"  ✗ REJECTED")
+    
+    print(f"Found {len(text_contours)} potential text lines")
+    
+    if text_contours:
+        # Sort by y-coordinate to get the topmost text line
+        text_contours.sort(key=lambda x: x[2])  # Sort by y position
+        
+        # Take the first text line found
+        contour, x, y, w, h = text_contours[0]
+        
+        print(f"Extracting text line at: x={x}, y={y}, w={w}, h={h}")
+        
+        # Extract with generous margins
+        margin_x = 30
+        margin_y = 20
+        y_start = max(0, y - margin_y)
+        y_end = min(img_height, y + h + margin_y)
+        x_start = max(0, x - margin_x)
+        x_end = min(img_width, x + w + margin_x)
+        
+        extracted = img[y_start:y_end, x_start:x_end]
+        
+        if extracted.size > 0:
+            print(f"Successfully extracted line: {extracted.shape}")
+            return Image.fromarray(extracted)
+    
+    # Fallback: If no text lines found, try scanning line by line in lower portion
+    print("No contours found, trying line-by-line scan...")
+    return scan_for_text_lines(img, skip_top)
+
+def scan_for_text_lines(img, start_y):
+    """Scan line by line looking for text content"""
+    if len(img.shape) == 3:
+        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = img
     
-    # Get image dimensions
     img_height, img_width = gray.shape
     
-    # Progressive filtering - start lenient, get stricter
-    for attempt in range(3):
-        print(f"\nAttempt {attempt + 1}:")
+    # Scan from start_y downward
+    for y in range(start_y, img_height - 40, 10):  # Check every 10 pixels
+        # Take a 40-pixel high strip
+        strip = gray[y:y+40, :]
         
-        if attempt == 0:
-            # Very lenient criteria
-            min_width = img_width * 0.1
-            max_height = img_height * 0.15
-            min_aspect = 2.0
-            max_area = 10.0
-        elif attempt == 1:
-            # Moderate criteria
-            min_width = img_width * 0.15
-            max_height = img_height * 0.12
-            min_aspect = 3.0
-            max_area = 8.0
-        else:
-            # Strict criteria
-            min_width = img_width * 0.2
-            max_height = img_height * 0.08
-            min_aspect = 5.0
-            max_area = 5.0
+        # Apply threshold
+        _, thresh = cv2.threshold(strip, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
         
-        valid_contours = []
+        # Count dark pixels (ink)
+        ink_pixels = np.sum(thresh > 0)
+        total_pixels = strip.shape[0] * strip.shape[1]
+        ink_ratio = ink_pixels / total_pixels
         
-        for i, contour in enumerate(contours):
-            x, y, w, h = cv2.boundingRect(contour)
-            area = cv2.contourArea(contour)
-            
-            # Calculate metrics
-            aspect_ratio = w / h if h > 0 else 0
-            area_percent = (area / (img_width * img_height)) * 100
-            
-            # Check criteria
-            if (w >= min_width and 
-                h >= 5 and  # Minimum readable height
-                h <= max_height and
-                aspect_ratio >= min_aspect and
-                area_percent <= max_area):
-                valid_contours.append((contour, x, y, w, h, area_percent))
-                print(f"  ✓ Valid contour {i}: {w}x{h}, ratio={aspect_ratio:.1f}, area={area_percent:.1f}%")
-            else:
-                print(f"  ✗ Contour {i}: {w}x{h}, ratio={aspect_ratio:.1f}, area={area_percent:.1f}%")
+        # Also check if the ink is distributed horizontally (like text)
+        # Sum ink pixels in each row
+        row_sums = np.sum(thresh, axis=1)
+        rows_with_ink = np.sum(row_sums > 0)
         
-        if valid_contours:
-            # Sort by y-coordinate (top to bottom)
-            valid_contours.sort(key=lambda x: x[2])
-            
-            # Get the first (topmost) line
-            contour, x, y, w, h, area_percent = valid_contours[0]
-            
-            # Adjust coordinates back to original image
-            x_orig = x + offset_x
-            y_orig = y + offset_y
-            
-            print(f"Selected line: x={x_orig}, y={y_orig}, w={w}, h={h}")
-            
-            # Extract with margin
-            margin = 15
-            y_start = max(0, y_orig - margin)
-            y_end = min(original_img.shape[0], y_orig + h + margin)
-            x_start = max(0, x_orig - margin)
-            x_end = min(original_img.shape[1], x_orig + w + margin)
-            
-            crop = original_img[y_start:y_end, x_start:x_end]
+        print(f"y={y}: ink_ratio={ink_ratio:.3f}, rows_with_ink={rows_with_ink}")
+        
+        # If we find a region with reasonable ink and horizontal distribution
+        if ink_ratio > 0.02 and rows_with_ink >= 5:  # At least 5 rows with ink
+            # Expand the region
+            y_start = max(0, y - 15)
+            y_end = min(img_height, y + 55)
             
-            if crop.size > 0:
-                print(f"Successfully extracted crop: {crop.shape}")
-                return Image.fromarray(crop)
+            if len(img.shape) == 3:
+                extracted = img[y_start:y_end, :]
+            else:
+                extracted = gray[y_start:y_end, :]
+                
+            print(f"Found text at y={y}, extracting region {y_start}:{y_end}")
+            return Image.fromarray(extracted)
     
-    return None
+    # If still nothing found, return a middle section
+    print("No text found, returning middle section")
+    mid_y = img_height // 2
+    section = img[mid_y:mid_y + img_height//4, :]
+    return Image.fromarray(section)
 
 def preprocess_voynich_image(img_pil):
     """Enhanced preprocessing for Voynich manuscript images"""
@@ -169,8 +172,8 @@ def preprocess_voynich_image(img_pil):
     
     return Image.fromarray(enhanced)
 
-def debug_text_detection(img_pil):
-    """Comprehensive debug showing all processing steps"""
+def debug_voynich_detection(img_pil):
+    """Debug function showing the detection process"""
     if img_pil is None:
         return None, None, None, None
     
@@ -180,101 +183,77 @@ def debug_text_detection(img_pil):
     else:
         gray = img
     
-    # Show original grayscale
-    original_gray = Image.fromarray(gray)
+    img_height, img_width = gray.shape
     
-    # Apply CLAHE
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    enhanced = clahe.apply(gray)
-    enhanced_img = Image.fromarray(enhanced)
+    # Show the search area (skip top 15%)
+    skip_top = int(img_height * 0.15)
+    search_area = gray[skip_top:, :]
     
-    # Combined threshold
-    _, thresh_otsu = cv2.threshold(enhanced, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-    thresh_adaptive = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-                                           cv2.THRESH_BINARY_INV, 15, 8)
-    thresh_combined = cv2.bitwise_or(thresh_otsu, thresh_adaptive)
-    thresh_img = Image.fromarray(thresh_combined)
+    # Create a visualization showing the search area
+    search_viz = np.copy(gray)
+    cv2.rectangle(search_viz, (0, skip_top), (img_width, img_height), (128), 2)
     
-    # Final result
-    result = detect_text_lines(img_pil)
+    # Apply CLAHE to search area
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+    enhanced = clahe.apply(search_area)
     
-    return original_gray, enhanced_img, thresh_img, result
-
-def extract_text_region(img_pil, region_height=0.3):
-    """Extract top region of the manuscript for text analysis"""
-    if img_pil is None:
-        return None
+    # Apply threshold
+    thresh = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                   cv2.THRESH_BINARY_INV, 11, 2)
     
-    img = np.array(img_pil)
-    img_height = img.shape[0]
+    # Show full-size threshold result
+    thresh_full = np.zeros_like(gray)
+    thresh_full[skip_top:, :] = thresh
     
-    # Extract top portion
-    region_pixels = int(img_height * region_height)
-    region = img[0:region_pixels, :]
+    # Get the final result
+    result = find_text_lines_voynich(img_pil)
     
-    return Image.fromarray(region)
+    return (Image.fromarray(search_viz), 
+            Image.fromarray(enhanced), 
+            Image.fromarray(thresh_full), 
+            result)
 
-def simple_line_extraction(img_pil):
-    """Simple horizontal line extraction as fallback"""
+def extract_text_block(img_pil, start_percent=0.2, height_percent=0.4):
+    """Extract a block of text from a specific region"""
     if img_pil is None:
         return None
     
     img = np.array(img_pil)
-    if len(img.shape) == 3:
-        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    else:
-        gray = img
-    
-    # Find the first significant horizontal line by scanning from top
-    img_height, img_width = gray.shape
+    img_height = img.shape[0]
     
-    # Scan line by line looking for text
-    for y in range(0, img_height - 30, 5):  # Check every 5 pixels
-        line_region = gray[y:y+30, :]  # 30-pixel high strip
-        
-        # Check if this region has enough "ink" (dark pixels)
-        _, thresh = cv2.threshold(line_region, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-        ink_pixels = np.sum(thresh > 0)
-        total_pixels = line_region.shape[0] * line_region.shape[1]
-        ink_ratio = ink_pixels / total_pixels
-        
-        # If we find a region with reasonable amount of ink, extract it
-        if ink_ratio > 0.05:  # At least 5% ink
-            # Expand the region a bit
-            y_start = max(0, y - 10)
-            y_end = min(img_height, y + 50)
-            extracted = img[y_start:y_end, :]
-            
-            print(f"Simple extraction found line at y={y}, ink_ratio={ink_ratio:.3f}")
-            return Image.fromarray(extracted)
+    start_y = int(img_height * start_percent)
+    block_height = int(img_height * height_percent)
+    end_y = min(img_height, start_y + block_height)
     
-    # If no line found, return top portion
-    top_portion = img[0:img_height//4, :]
-    return Image.fromarray(top_portion)
+    block = img[start_y:end_y, :]
+    return Image.fromarray(block)
 
 # Enhanced Gradio interface
-with gr.Blocks(title="Robust Voynich Manuscript Line Extractor") as demo:
-    gr.Markdown("# Robust Voynich Manuscript Line Extractor")
-    gr.Markdown("Upload a scanned folio of the Voynich manuscript. This version uses multiple strategies to ensure we always get a result.")
+with gr.Blocks(title="Voynich Text Line Extractor - Fixed") as demo:
+    gr.Markdown("# Voynich Text Line Extractor - Fixed Version")
+    gr.Markdown("This version specifically looks for actual text lines in the manuscript, not page edges. It skips the top portion and searches in the text areas.")
     
     with gr.Row():
         with gr.Column():
             input_image = gr.Image(type="pil", label="Upload Voynich Folio")
             enhance_btn = gr.Button("Enhance Image")
-            extract_btn = gr.Button("Extract First Line (Smart)")
-            simple_btn = gr.Button("Extract Line (Simple)")
-            region_btn = gr.Button("Extract Text Region")
-            debug_btn = gr.Button("Debug Processing")
+            extract_btn = gr.Button("Find Text Lines")
+            block_btn = gr.Button("Extract Text Block")
+            debug_btn = gr.Button("Debug Detection")
+            
+            # Add slider for text block extraction
+            start_slider = gr.Slider(0.1, 0.8, 0.2, label="Start Position (% from top)")
+            height_slider = gr.Slider(0.1, 0.6, 0.4, label="Block Height (% of image)")
             
         with gr.Column():
             enhanced_output = gr.Image(label="Enhanced Image")
-            line_output = gr.Image(label="Extracted Result")
+            line_output = gr.Image(label="Extracted Text")
     
     with gr.Row():
-        debug_original = gr.Image(label="1. Original Grayscale")
-        debug_enhanced = gr.Image(label="2. Enhanced (CLAHE)")
-        debug_thresh = gr.Image(label="3. Combined Threshold")
-        debug_result = gr.Image(label="4. Final Result")
+        debug_search = gr.Image(label="1. Search Area")
+        debug_enhanced = gr.Image(label="2. Enhanced")
+        debug_thresh = gr.Image(label="3. Threshold")
+        debug_result = gr.Image(label="4. Result")
     
     enhance_btn.click(
         fn=preprocess_voynich_image,
@@ -283,27 +262,21 @@ with gr.Blocks(title="Robust Voynich Manuscript Line Extractor") as demo:
     )
     
     extract_btn.click(
-        fn=detect_text_lines,
-        inputs=input_image,
-        outputs=line_output
-    )
-    
-    simple_btn.click(
-        fn=simple_line_extraction,
+        fn=find_text_lines_voynich,
         inputs=input_image,
         outputs=line_output
     )
     
-    region_btn.click(
-        fn=extract_text_region,
-        inputs=input_image,
+    block_btn.click(
+        fn=extract_text_block,
+        inputs=[input_image, start_slider, height_slider],
         outputs=line_output
     )
     
     debug_btn.click(
-        fn=debug_text_detection,
+        fn=debug_voynich_detection,
         inputs=input_image,
-        outputs=[debug_original, debug_enhanced, debug_thresh, debug_result]
+        outputs=[debug_search, debug_enhanced, debug_thresh, debug_result]
     )
 
 if __name__ == "__main__":