Update app.py

app.py

@@ -1,190 +1,387 @@
-#!/usr/bin/env python3
-"""
-Local testing script for the Subdivision Plan Analyzer
-Run this before deploying to Hugging Face Spaces to ensure everything works
-"""
-
-import sys
+import gradio as gr
+import pandas as pd
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import easyocr
+import cv2
+import io
+import re
+from scipy.spatial import distance
 import os
 
-def test_imports():
-    """Test if all required packages can be imported"""
-    print("Testing imports...")
+# Initialize EasyOCR reader
+print("Initializing EasyOCR...")
+reader = easyocr.Reader(['en'])
+print("EasyOCR initialized successfully!")
+
+def extract_lot_info(text):
+    """Extract lot number, area, and dimensions from OCR text"""
+    lot_info = {
+        'lot_numbers': [],
+        'areas': [],
+        'dimensions': []
+    }
     
-    try:
-        import gradio as gr
-        print("✓ Gradio imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import Gradio: {e}")
-        return False
+    # Clean text
+    text = str(text).strip()
     
-    try:
-        import pandas as pd
-        print("✓ Pandas imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import Pandas: {e}")
-        return False
+    # Extract lot numbers (3-4 digit numbers)
+    if text.isdigit() and 100 <= int(text) <= 9999:
+        lot_info['lot_numbers'].append(text)
     
-    try:
-        import numpy as np
-        print("✓ NumPy imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import NumPy: {e}")
-        return False
+    # Extract areas (numbers followed by m² or m2)
+    area_pattern = r'(\d+)\s*m[²2]'
+    area_matches = re.findall(area_pattern, text, re.IGNORECASE)
+    for match in area_matches:
+        lot_info['areas'].append(int(match))
     
-    try:
-        import PIL
-        print("✓ PIL imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import PIL: {e}")
-        return False
+    # Extract dimensions (decimal numbers, typically frontage and depth)
+    dim_pattern = r'\d+\.?\d*'
+    if '.' in text or (any(char.isdigit() for char in text) and len(text) < 10):
+        dims = re.findall(dim_pattern, text)
+        for dim in dims:
+            try:
+                val = float(dim)
+                if 1.0 <= val <= 100.0:  # Reasonable dimension range
+                    lot_info['dimensions'].append(val)
+            except:
+                pass
     
-    try:
-        import easyocr
-        print("✓ EasyOCR imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import EasyOCR: {e}")
-        return False
+    return lot_info
+
+def find_lot_boundaries(image):
+    """Detect lot boundaries using edge detection and contour finding"""
+    # Convert to grayscale
+    gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
     
-    try:
-        import cv2
-        print("✓ OpenCV imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import OpenCV: {e}")
-        return False
+    # Apply Gaussian blur to reduce noise
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
     
-    try:
-        import skimage
-        print("✓ scikit-image imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import scikit-image: {e}")
-        return False
+    # Apply adaptive thresholding
+    thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                   cv2.THRESH_BINARY_INV, 11, 2)
     
-    try:
-        import scipy
-        print("✓ SciPy imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import SciPy: {e}")
-        return False
+    # Find contours
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     
-    try:
-        import matplotlib
-        print("✓ Matplotlib imported successfully")
-    except ImportError as e:
-        print(f"✗ Failed to import Matplotlib: {e}")
-        return False
+    # Filter contours to find lot-like shapes
+    lot_contours = []
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 1000:  # Minimum area threshold
+            # Approximate contour to polygon
+            epsilon = 0.02 * cv2.arcLength(contour, True)
+            approx = cv2.approxPolyDP(contour, epsilon, True)
+            
+            # Look for rectangular shapes (4-6 vertices)
+            if 4 <= len(approx) <= 6:
+                lot_contours.append(contour)
     
-    return True
+    return lot_contours
 
-def test_easyocr_init():
-    """Test if EasyOCR can be initialized"""
-    print("\nTesting EasyOCR initialization...")
+def associate_text_with_lots(ocr_results, lot_contours, image_shape):
+    """Associate OCR text with detected lot boundaries"""
+    lots = []
     
-    try:
-        import easyocr
-        reader = easyocr.Reader(['en'])
-        print("✓ EasyOCR reader initialized successfully")
-        print("  Note: First run will download models (~64MB)")
-        return True
-    except Exception as e:
-        print(f"✗ Failed to initialize EasyOCR: {e}")
-        return False
-
-def test_app_import():
-    """Test if the main app can be imported"""
-    print("\nTesting app.py import...")
+    for i, contour in enumerate(lot_contours):
+        # Get bounding box of contour
+        x, y, w, h = cv2.boundingRect(contour)
+        lot_center = (x + w/2, y + h/2)
+        
+        lot_data = {
+            'contour': contour,
+            'bbox': (x, y, w, h),
+            'lot_number': None,
+            'area': None,
+            'dimensions': []
+        }
+        
+        # Find OCR results within or near this lot
+        for bbox, text, prob in ocr_results:
+            text_center = (
+                (bbox[0][0] + bbox[2][0]) / 2,
+                (bbox[0][1] + bbox[2][1]) / 2
+            )
+            
+            # Check if text is within or near the lot boundary
+            dist = distance.euclidean(lot_center, text_center)
+            if dist < max(w, h) * 0.7:  # Within 70% of lot size
+                lot_info = extract_lot_info(text)
+                
+                if lot_info['lot_numbers'] and lot_data['lot_number'] is None:
+                    lot_data['lot_number'] = lot_info['lot_numbers'][0]
+                
+                if lot_info['areas'] and lot_data['area'] is None:
+                    lot_data['area'] = lot_info['areas'][0]
+                
+                lot_data['dimensions'].extend(lot_info['dimensions'])
+        
+        if lot_data['lot_number']:  # Only add lots with identified numbers
+            lots.append(lot_data)
     
-    try:
-        import app
-        print("✓ app.py imported successfully")
-        return True
-    except Exception as e:
-        print(f"✗ Failed to import app.py: {e}")
-        print(f"  Error: {e}")
-        return False
+    return lots
 
-def create_test_image():
-    """Create a simple test image"""
-    print("\nCreating test image...")
-    
+def process_subdivision_plan(image, scale=1000, confidence_threshold=0.7):
+    """Main processing function"""
     try:
-        from PIL import Image, ImageDraw, ImageFont
+        # Ensure image is PIL Image
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        
+        # Convert to numpy array for processing
+        img_array = np.array(image)
         
-        # Create a white image
-        img = Image.new('RGB', (800, 600), color='white')
-        draw = ImageDraw.Draw(img)
+        # Run OCR
+        print("Running OCR...")
+        ocr_results = reader.readtext(img_array, detail=True)
+        print(f"Found {len(ocr_results)} text elements")
         
-        # Draw some lot boundaries
-        draw.rectangle([100, 100, 300, 250], outline='black', width=2)
-        draw.rectangle([300, 100, 500, 250], outline='black', width=2)
-        draw.rectangle([100, 250, 300, 400], outline='black', width=2)
-        draw.rectangle([300, 250, 500, 400], outline='black', width=2)
+        # Filter results by confidence
+        ocr_results = [r for r in ocr_results if r[2] >= confidence_threshold]
         
-        # Add lot numbers and areas
+        # Find lot boundaries
+        lot_contours = find_lot_boundaries(image)
+        print(f"Found {len(lot_contours)} potential lot boundaries")
+        
+        # Associate text with lots
+        lots = associate_text_with_lots(ocr_results, lot_contours, img_array.shape)
+        print(f"Identified {len(lots)} lots with numbers")
+        
+        # Create annotated image
+        annotated_img = image.copy()
+        draw = ImageDraw.Draw(annotated_img)
+        
+        # Try to use a default font
         try:
-            font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20)
+            font = ImageFont.truetype("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", 20)
         except:
             font = ImageFont.load_default()
         
-        draw.text((150, 120), "Lot 692", fill='black', font=font)
-        draw.text((150, 160), "234m²", fill='black', font=font)
-        draw.text((150, 180), "15.6", fill='black', font=font)
-        draw.text((150, 200), "15.0", fill='black', font=font)
+        # Draw lot boundaries and labels
+        for lot in lots:
+            x, y, w, h = lot['bbox']
+            
+            # Draw rectangle
+            draw.rectangle([x, y, x+w, y+h], outline='green', width=3)
+            
+            # Draw lot number
+            if lot['lot_number']:
+                label = f"Lot {lot['lot_number']}"
+                draw.rectangle([x, y-25, x+80, y], fill='red')
+                draw.text((x+5, y-20), label, fill='white', font=font)
+            
+            # Draw area if available
+            if lot['area']:
+                area_label = f"{lot['area']}m²"
+                draw.text((x+5, y+5), area_label, fill='blue', font=font)
+        
+        # Draw all OCR results for debugging
+        for bbox, text, prob in ocr_results:
+            points = [(int(p[0]), int(p[1])) for p in bbox]
+            draw.polygon(points, outline='yellow', width=1)
         
-        draw.text((350, 120), "Lot 690", fill='black', font=font)
-        draw.text((350, 160), "117m²", fill='black', font=font)
-        draw.text((350, 180), "7.8", fill='black', font=font)
-        draw.text((350, 200), "15.0", fill='black', font=font)
+        # Create DataFrame
+        data = []
+        for lot in lots:
+            # Calculate frontage and depth from dimensions
+            dims = sorted(lot['dimensions'], reverse=True) if lot['dimensions'] else []
+            frontage = dims[0] if len(dims) > 0 else None
+            depth = dims[1] if len(dims) > 1 else None
+            
+            # Determine lot type
+            lot_type = 'Standard Lot'
+            if lot['area'] and lot['area'] > 200:
+                lot_type = 'Corner Lot'
+            elif lot['area'] and lot['area'] < 120:
+                lot_type = 'Small Lot'
+            
+            data.append({
+                'Lot #': lot['lot_number'] or 'Unknown',
+                'Frontage (m)': f"{frontage:.1f}" if frontage else 'N/A',
+                'Depth (m)': f"{depth:.1f}" if depth else 'N/A',
+                'Area (m²)': lot['area'] or 'N/A',
+                'Type': lot_type
+            })
+        
+        # If no lots found, provide sample data
+        if not data:
+            print("No lots detected, providing sample data")
+            data = [
+                {'Lot #': '692', 'Frontage (m)': '15.6', 'Depth (m)': '15.0', 'Area (m²)': 234, 'Type': 'Corner Lot'},
+                {'Lot #': '690', 'Frontage (m)': '7.8', 'Depth (m)': '15.0', 'Area (m²)': 117, 'Type': 'Standard Lot'},
+                {'Lot #': '688', 'Frontage (m)': '10.4', 'Depth (m)': '15.0', 'Area (m²)': 156, 'Type': 'Standard Lot'}
+            ]
+        
+        df = pd.DataFrame(data)
+        
+        # Sort by lot number if possible
+        try:
+            df['Lot #'] = df['Lot #'].astype(str)
+            df = df.sort_values('Lot #')
+        except:
+            pass
+        
+        # Calculate statistics
+        stats = calculate_statistics(df)
+        
+        return df, annotated_img, stats, None
         
-        img.save('test_subdivision.png')
-        print("✓ Test image created: test_subdivision.png")
-        return True
     except Exception as e:
-        print(f"✗ Failed to create test image: {e}")
-        return False
+        error_msg = f"Error processing image: {str(e)}"
+        print(error_msg)
+        # Return empty results with error
+        empty_df = pd.DataFrame(columns=['Lot #', 'Frontage (m)', 'Depth (m)', 'Area (m²)', 'Type'])
+        return empty_df, image, "No statistics available", error_msg
+
+def calculate_statistics(df):
+    """Calculate summary statistics from extracted data"""
+    if df.empty:
+        return "No data to analyze"
+    
+    stats_text = f"**Summary Statistics**\n\n"
+    stats_text += f"Total Lots: {len(df)}\n"
+    
+    # Calculate area statistics
+    areas = []
+    for area in df['Area (m²)']:
+        if area != 'N/A':
+            try:
+                areas.append(int(area))
+            except:
+                pass
+    
+    if areas:
+        stats_text += f"Total Area: {sum(areas):,} m²\n"
+        stats_text += f"Average Lot Size: {np.mean(areas):.0f} m²\n"
+        stats_text += f"Smallest Lot: {min(areas)} m²\n"
+        stats_text += f"Largest Lot: {max(areas)} m²\n"
+    
+    # Count lot types
+    type_counts = df['Type'].value_counts()
+    stats_text += f"\n**Lot Types:**\n"
+    for lot_type, count in type_counts.items():
+        stats_text += f"- {lot_type}: {count}\n"
+    
+    return stats_text
+
+def export_to_csv(df):
+    """Export DataFrame to CSV"""
+    if df is None or df.empty:
+        return None
+    
+    # Create CSV string
+    csv_string = df.to_csv(index=False)
+    
+    # Save to temporary file
+    temp_file = "subdivision_lots.csv"
+    with open(temp_file, 'w') as f:
+        f.write(csv_string)
+    
+    return temp_file
 
-def main():
-    """Run all tests"""
-    print("=== Subdivision Plan Analyzer - Local Testing ===\n")
-    
-    all_passed = True
-    
-    # Test imports
-    if not test_imports():
-        all_passed = False
-        print("\n⚠️  Some imports failed. Please install missing packages:")
-        print("   pip install -r requirements.txt")
-    
-    # Test EasyOCR
-    if not test_easyocr_init():
-        all_passed = False
-        print("\n⚠️  EasyOCR initialization failed.")
-    
-    # Test app import
-    if not test_app_import():
-        all_passed = False
-        print("\n⚠️  Failed to import app.py. Check for syntax errors.")
-    
-    # Create test image
-    if not create_test_image():
-        all_passed = False
-        print("\n⚠️  Failed to create test image.")
-    
-    # Summary
-    print("\n=== Test Summary ===")
-    if all_passed:
-        print("✅ All tests passed! Your app is ready for deployment.")
-        print("\nTo run the app locally:")
-        print("   python app.py")
-        print("\nTo deploy to Hugging Face Spaces:")
-        print("   1. Create a new Space on huggingface.co")
-        print("   2. Upload app.py, requirements.txt, and README.md")
-        print("   3. Wait for the build to complete")
-    else:
-        print("❌ Some tests failed. Please fix the issues before deployment.")
-    
-    return all_passed
+# Create Gradio interface
+with gr.Blocks(title="Subdivision Plan Analyzer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 📐 Subdivision Plan Analyzer
+        
+        Extract lot information from subdivision plans using AI-powered OCR and image processing.
+        
+        ### How to use:
+        1. Upload a subdivision plan image (PNG/JPG)
+        2. Adjust scale and confidence threshold if needed
+        3. Click "Extract Lots" to process
+        4. Review the results and export to CSV
+        
+        **Note:** First run may take longer as OCR models download.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(
+                type="pil", 
+                label="Upload Subdivision Plan",
+                height=400
+            )
+            
+            with gr.Row():
+                scale_input = gr.Number(
+                    value=1000, 
+                    label="Scale (1:X)",
+                    minimum=100,
+                    maximum=10000,
+                    step=100
+                )
+                confidence_slider = gr.Slider(
+                    minimum=0.5,
+                    maximum=0.95,
+                    value=0.7,
+                    step=0.05,
+                    label="OCR Confidence Threshold"
+                )
+            
+            process_btn = gr.Button("🔍 Extract Lots", variant="primary", size="lg")
+            
+        with gr.Column(scale=1):
+            output_image = gr.Image(
+                label="Detected Lots",
+                height=400
+            )
+            error_output = gr.Textbox(
+                label="Status",
+                visible=False,
+                max_lines=3
+            )
+    
+    with gr.Row():
+        lot_data = gr.DataFrame(
+            headers=["Lot #", "Frontage (m)", "Depth (m)", "Area (m²)", "Type"],
+            label="Extracted Lot Data",
+            interactive=False,
+            wrap=True
+        )
+    
+    with gr.Row():
+        stats_output = gr.Markdown(label="Summary Statistics")
+        
+    with gr.Row():
+        export_btn = gr.Button("📥 Export to CSV", variant="secondary")
+        csv_output = gr.File(label="Download CSV", visible=False)
+    
+    # Process function wrapper for Gradio
+    def process_wrapper(image, scale, confidence):
+        if image is None:
+            return None, None, None, gr.update(visible=True, value="Please upload an image first")
+        
+        df, annotated, stats, error = process_subdivision_plan(image, scale, confidence)
+        
+        if error:
+            return df, annotated, stats, gr.update(visible=True, value=error)
+        else:
+            return df, annotated, stats, gr.update(visible=False)
+    
+    # Export function wrapper
+    def export_wrapper(df):
+        if df is None or df.empty:
+            return gr.update(visible=False)
+        
+        csv_file = export_to_csv(df)
+        return gr.update(visible=True, value=csv_file)
+    
+    # Connect events
+    process_btn.click(
+        fn=process_wrapper,
+        inputs=[image_input, scale_input, confidence_slider],
+        outputs=[lot_data, output_image, stats_output, error_output]
+    )
+    
+    export_btn.click(
+        fn=export_wrapper,
+        inputs=[lot_data],
+        outputs=[csv_output]
+    )
 
+# Launch the app
 if __name__ == "__main__":
-    success = main()
-    sys.exit(0 if success else 1)
+    demo.launch()