Update app.py

app.py

@@ -1,754 +1,792 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from matplotlib.patches import FancyBboxPatch, Path, PathPatch, Rectangle
+from matplotlib.collections import PatchCollection
+from datetime import datetime
+import io
+import json
+import tempfile
+import re
+
+# Try to import plan reading libraries
+try:
+    import cv2
+    import pytesseract
+    from PIL import Image
+    from pdf2image import convert_from_path
+    PLAN_READER_AVAILABLE = True
+except ImportError:
+    PLAN_READER_AVAILABLE = False
+    print("Warning: Plan reader libraries not available. "
+          "Install opencv-python, pytesseract, pillow, and pdf2image for full functionality.")
+
+
+class AdvancedGridOptimizer:
+    def __init__(self):
+        # Standard lot widths and their typical depths
+        self.lot_specifications = {
+            8.5:   {"depths": [21, 25, 28],                      "type": "SLHC",        "squares": "11-16"},
+            10.5:  {"depths": [21, 25, 28, 32, 35],               "type": "SLHC",        "squares": "13-21.5"},
+            12.5:  {"depths": [21, 25, 28, 30, 32],               "type": "Standard",    "squares": "16-24"},
+            14.0:  {"depths": [21, 25, 28, 30, 32, 34],           "type": "Standard",    "squares": "17-28"},
+            16.0:  {"depths": [28, 30, 32, 34, 36, 40],           "type": "Premium",     "squares": "24-38"},
+            18.0:  {"depths": [32, 34, 36],                       "type": "Premium",     "squares": "32-39"},
+            # Traditional corner lots
+            11.0:  {"depths": [21, 25],                           "type": "Corner-SLHC", "squares": "13-17"},
+            13.3:  {"depths": [25, 28],                           "type": "Corner-Standard", "squares": "18-22"},
+            14.8:  {"depths": [28, 30],                           "type": "Corner-Standard", "squares": "22-26"},
+            16.8:  {"depths": [30, 32],                           "type": "Corner-Premium",  "squares": "26-32"}
+        }
 
-**Sample lots generated for demonstration.**
-"""
-            return preview_img, mock_lots, summary
+        self.slhc_widths = [8.5, 10.5]
+        self.standard_widths = [12.5, 14.0]
+        self.premium_widths = [16.0, 18.0]
+        self.corner_specific = [11.0, 13.3, 14.8, 16.8]
+
+        # Define corner_widths as all widths suitable for corners
+        self.corner_widths = self.corner_specific + [14.0, 16.0, 18.0]
+
+        # Enhanced color palette with gradients
+        self.color_schemes = {
+            'modern': {
+                8.5: '#FF6B6B',   10.5: '#4ECDC4',  12.5: '#45B7D1',
+                14.0: '#96CEB4', 16.0: '#DDA0DD',  18.0: '#FFD93D',
+                11.0: '#FFA07A', 13.3: '#98D8C8',  14.8: '#F7DC6F',
+                16.8: '#BB8FCE'
+            },
+            'professional': {
+                8.5: '#E74C3C',   10.5: '#3498DB',  12.5: '#2ECC71',
+                14.0: '#F39C12', 16.0: '#9B59B6',  18.0: '#1ABC9C',
+                11.0: '#E67E22', 13.3: '#16A085',  14.8: '#F1C40F',
+                16.8: '#8E44AD'
+            },
+            'neon': {
+                8.5: '#FF073A',   10.5: '#0AEFFF',  12.5: '#39FF14',
+                14.0: '#FF6600', 16.0: '#BF00FF',  18.0: '#FFFF00',
+                11.0: '#FF1493', 13.3: '#00FFFF',  14.8: '#FFF700',
+                16.8: '#FF00FF'
+            }
+        }
 
-        try:
-            # Load either PDF → image, or direct image file
-            if image_path.lower().endswith('.pdf'):
-                with tempfile.TemporaryDirectory() as temp_dir:
-                    images = convert_from_path(image_path, dpi=300)
-                    if images:
-                        img = np.array(images[0])
-                    else:
-                        return None, None, "Failed to convert PDF to image"
+        self.current_scheme = 'neon'
+        self.current_solution = None  # Store current AI solution
+
+    def create_enhanced_visualization(self, solution, stage_width, stage_depth=32,
+                                      title="Premium Grid Layout", show_variance=None):
+        """Create a clean 2D visualization with corner splays and proper alignment"""
+        fig, (ax1, ax2) = plt.subplots(
+            2, 1, figsize=(18, 12),
+            gridspec_kw={'height_ratios': [3, 1]},
+            facecolor='#1a1a1a'
+        )
+
+        colors = self.color_schemes[self.current_scheme]
+        x_pos = 0
+        lot_num = 1
+        ax1.set_xlim(-5, stage_width + 5)
+        ax1.set_ylim(-10, 50)
+        ax1.set_facecolor('#1a1a1a')
+
+        # Title with variance if provided
+        if show_variance is not None:
+            title_text = f"{title}\nGrid Variance: {show_variance:+.1f}m"
+            ax1.set_title(title_text, fontsize=28, fontweight='bold', pad=25, color='white')
+        else:
+            ax1.set_title(title, fontsize=28, fontweight='bold', pad=25, color='white')
+
+        # Subtle dark gradient background
+        gradient = np.linspace(0.2, 0, 100).reshape(1, -1)
+        ax1.imshow(gradient, extent=[-5, stage_width + 5, -10, 50],
+                   aspect='auto', cmap='Greys', alpha=0.3, zorder=0)
+
+        # Draw street rectangle
+        street = Rectangle((-5, -8), stage_width + 10, 12,
+                           facecolor='#2c2c2c', alpha=0.9, zorder=1,
+                           edgecolor='#444444', linewidth=2)
+        ax1.add_patch(street)
+        ax1.text(stage_width / 2, -2, 'STREET', ha='center', va='center',
+                 fontsize=20, color='white', fontweight='bold')
+
+        # Corner splay size and uniform lot height
+        splay_size = 3
+        lot_height = 28
+
+        for i, (width, lot_type) in enumerate(solution):
+            # Pick base color, or nearest if missing
+            if width in colors:
+                base_color = colors[width]
             else:
-                img = cv2.imread(image_path)
-                if img is None:
-                    return None, None, "Failed to load image"
-
-            # Ensure it's in RGB
-            if len(img.shape) == 2:
-                img_rgb = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-            elif img.shape[2] == 4:
-                img_rgb = cv2.cvtColor(img, cv2.COLOR_BGRA2RGB)
+                closest_width = min(colors.keys(), key=lambda x: abs(x - width))
+                base_color = colors[closest_width]
+
+            is_corner = (i == 0 or i == len(solution) - 1)
+            face_color = base_color
+            edge_color = 'white'
+            linewidth = 4.0 if is_corner else 3.0
+
+            if is_corner:
+                # Build a 5‐vertex corner polygon (splay at front) &
+                # keep uniform lot height
+                if i == 0:
+                    vertices = [
+                        (x_pos + splay_size, 8),  # start after splay
+                        (x_pos + width, 8),
+                        (x_pos + width, 8 + lot_height),
+                        (x_pos,      8 + lot_height),
+                        (x_pos,      8 + splay_size)
+                    ]
+                else:
+                    vertices = [
+                        (x_pos,      8),
+                        (x_pos + width - splay_size, 8),
+                        (x_pos + width,      8 + splay_size),
+                        (x_pos + width,      8 + lot_height),
+                        (x_pos,      8 + lot_height)
+                    ]
+
+                # Close polygon path
+                codes = [Path.MOVETO] + [Path.LINETO] * (len(vertices) - 1) + [Path.CLOSEPOLY]
+                vertices.append(vertices[0])
+                path = Path(vertices, codes)
+                lot_patch = PathPatch(path, facecolor=face_color,
+                                      edgecolor=edge_color, linewidth=linewidth, zorder=3)
+                ax1.add_patch(lot_patch)
+
+                # Draw splay line
+                if i == 0:
+                    ax1.plot([x_pos, x_pos + splay_size], [8 + splay_size, 8],
+                             'white', linewidth=2, alpha=0.8)
+                else:
+                    ax1.plot([x_pos + width - splay_size, x_pos + width],
+                             [8, 8 + splay_size], 'white', linewidth=2, alpha=0.8)
             else:
-                img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                # Regular rectangular (rounded) lot
+                lot_patch = FancyBboxPatch(
+                    (x_pos, 8), width, lot_height,
+                    boxstyle="round,pad=0.1",
+                    facecolor=face_color,
+                    edgecolor=edge_color,
+                    linewidth=linewidth,
+                    zorder=3
+                )
+                ax1.add_patch(lot_patch)
+
+            # Add glow underneath
+            glow = FancyBboxPatch(
+                (x_pos - 0.2, 7.8), width + 0.4, lot_height + 0.4,
+                boxstyle="round,pad=0.15",
+                facecolor='none',
+                edgecolor=face_color,
+                linewidth=1,
+                alpha=0.5,
+                zorder=2
+            )
+            ax1.add_patch(glow)
+
+            # Rear alignment dashed line
+            rear_y = 8 + lot_height
+            ax1.plot([x_pos, x_pos + width], [rear_y, rear_y],
+                     color=edge_color, linewidth=1, alpha=0.3, linestyle='--')
+
+            # Lot labels (number & width)
+            ax1.text(x_pos + width / 2, 40, f"L{lot_num}",
+                     ha='center', va='center', fontsize=16, fontweight='bold', color='white')
+            ax1.text(x_pos + width / 2, 35, f"{width:.1f}m",
+                     ha='center', va='center', fontsize=14, fontweight='bold', color='white')
+
+            # Lot type text inside a dark box
+            if int(width) in self.lot_specifications:
+                spec = self.lot_specifications[int(width)]
+            elif width in self.lot_specifications:
+                spec = self.lot_specifications[width]
+            else:
+                closest_width = min(self.lot_specifications.keys(),
+                                    key=lambda x: abs(x - width))
+                spec = self.lot_specifications[closest_width]
+                spec = {**spec, 'type': 'Custom'}
+
+            lot_type_text = spec['type']
+            if is_corner:
+                lot_type_text = "CORNER"
+
+            ax1.text(
+                x_pos + width / 2, 23, lot_type_text,
+                ha='center', va='center', fontsize=11,
+                bbox=dict(
+                    boxstyle="round,pad=0.3",
+                    facecolor='#333333',
+                    edgecolor='white',
+                    alpha=0.9
+                ),
+                color='white'
+            )
 
-            gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+            # Dimension indicator lines at front of lot
+            ax1.plot([x_pos, x_pos + width], [12, 12], 'w-', linewidth=1, alpha=0.3)
+            ax1.plot([x_pos, x_pos], [10, 14], 'w-', linewidth=1, alpha=0.3)
+            ax1.plot([x_pos + width, x_pos + width], [10, 14], 'w-', linewidth=1, alpha=0.3)
+
+            x_pos += width
+            lot_num += 1
+
+        # Draw one final “rear” alignment line across everything
+        ax1.plot([0, stage_width], [8 + lot_height, 8 + lot_height],
+                 'cyan', linewidth=2, alpha=0.8, linestyle='-')
+        ax1.text(
+            stage_width / 2, 8 + lot_height + 1, 'REAR ALIGNMENT LINE',
+            ha='center', va='bottom', fontsize=12, color='cyan', alpha=0.8,
+            bbox=dict(
+                boxstyle="round,pad=0.3",
+                facecolor='#1a1a1a',
+                edgecolor='cyan',
+                alpha=0.8
+            )
+        )
 
-            lots_detected = self.detect_lot_boundaries(gray, img_rgb, confidence)
-            text_data = self.extract_text_from_plan(gray)
-            lot_data = self.match_lots_with_dimensions(lots_detected, text_data, scale, auto_detect_scale)
-            preview_img = self.create_annotated_preview(img_rgb, lot_data)
+        # Draw stage dimension arrow & text
+        arrow_props = dict(arrowstyle='<->', color='white', lw=3)
+        ax1.annotate('', xy=(0, -6), xytext=(stage_width, -6), arrowprops=arrow_props)
+        ax1.text(stage_width / 2, -7, f'{stage_width}m × {stage_depth}m',
+                 ha='center', va='top', fontsize=16, fontweight='bold', color='white')
 
-            summary = f"""
-### Analysis Complete! 
-- **Lots Detected**: {len(lot_data)}
-- **Scale Used**: 1:{scale if not auto_detect_scale else 'Auto-detected'}
-- **Confidence**: {int(confidence * 100)}%
+        # Hide all axes spines/ticks
+        ax1.set_xticks([]); ax1.set_yticks([])
+        for spine in ax1.spines.values():
+            spine.set_visible(False)
 
-**Next Steps:**
-1. Review detected lots in the table below  
-2. Make any necessary corrections  
-3. Click "Send to Optimizer" to analyze the layout  
-"""
-            return preview_img, lot_data, summary
+        # ========== Metrics panel below ========== #
+        ax2.axis('off')
+        ax2.set_facecolor('#1a1a1a')
 
-        except Exception as e:
-            return None, None, f"Error processing plan: {str(e)}"
-
-    def detect_lot_boundaries(self, gray_img, rgb_img, confidence):
-        """Use Canny + findContours to locate rectangular-ish shapes as “lots”"""
-        lots = []
-        edges = cv2.Canny(gray_img, 50, 150)
-        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        for contour in contours:
-            area = cv2.contourArea(contour)
-            if area > 1000:
-                epsilon = 0.02 * cv2.arcLength(contour, True)
-                approx = cv2.approxPolyDP(contour, epsilon, True)
-                if 4 <= len(approx) <= 6:
-                    x, y, w, h = cv2.boundingRect(contour)
-                    aspect_ratio = float(w) / h if h > 0 else 0
-                    if 0.3 <= aspect_ratio <= 3.0:
-                        lots.append({
-                            'contour': approx,
-                            'bbox': (x, y, w, h),
-                            'area': area,
-                            'confidence': confidence
-                        })
-        return lots
-
-    def extract_text_from_plan(self, gray_img):
-        """Run Tesseract OCR on a binary version of the plan to pull out any numbers or “L\d+” labels"""
-        try:
-            _, thresh = cv2.threshold(gray_img, 150, 255, cv2.THRESH_BINARY)
-            data = pytesseract.image_to_data(thresh, output_type=pytesseract.Output.DICT)
-            text_elements = []
-            for i in range(len(data['text'])):
-                conf = int(data['conf'][i])
-                if conf > 0:
-                    text_val = data['text'][i].strip()
-                    if not text_val:
-                        continue
-                    text_elements.append({
-                        'text': text_val,
-                        'x': data['left'][i],
-                        'y': data['top'][i],
-                        'w': data['width'][i],
-                        'h': data['height'][i]
-                    })
-            return text_elements
-        except Exception:
-            return []
+        total_lots = len(solution)
+        unique_widths = len(set(w for w, _ in solution))
+        diversity_score = unique_widths / len(set(self.lot_specifications.keys()))
 
-    def match_lots_with_dimensions(self, lots, text_data, scale, auto_detect_scale):
-        """
-        For each detected lot‐bounding‐box, look for nearby OCR text that matches:
-          - Lot number: r'^L\d+'
-          - A dimension in metres: r'^\d+\.?\d*m?$'
-        If no dimension is found, estimate using pixel→metre (w/scale).
-        """
-        lot_info = []
-        for i, lot in enumerate(lots):
-            x, y, w, h = lot['bbox']
-            lot_center = (x + w / 2, y + h / 2)
-            lot_number = None
-            frontage = None
-            depth = None
-
-            for text in text_data:
-                text_center = (
-                    text['x'] + text['w'] / 2,
-                    text['y'] + text['h'] / 2
-                )
-                dist = np.hypot(lot_center[0] - text_center[0],
-                                lot_center[1] - text_center[1])
-                if dist < max(w, h) * 0.5:
-                    text_val = text['text']
-
-                    # Check if it's a lot number like "L3" or "L12"
-                    if re.match(r'^L\d+', text_val):
-                        lot_number = text_val
-
-                    # Check if it's a dimension in metres, e.g. "12.5m" or "8.5"
-                    elif re.match(r'^\d+\.?\d*m?$', text_val):
-                        # Grab the numeric part
-                        num_str = re.findall(r'\d+\.?\d*', text_val)[0]
-                        dim_val = float(num_str)
-                        # If horizontally near center, assume frontage
-                        if abs(text_center[1] - lot_center[1]) < h * 0.3:
-                            frontage = dim_val
-                        else:
-                            depth = dim_val
-
-            if not lot_number:
-                lot_number = f"L{i + 1}"
-            if frontage is None:
-                frontage = round(w / scale * 1000, 1)
-            if depth is None:
-                depth = round(h / scale * 1000, 1)
-
-            lot_type = "SLHC" if frontage <= 10.5 else "Standard" if frontage <= 14 else "Premium"
-            lot_info.append({
-                'lot_number': lot_number,
-                'frontage': frontage,
-                'depth': depth,
-                'area': frontage * depth,
-                'type': lot_type,
-                'bbox': lot['bbox']
-            })
-
-        # Sort by lot_number if possible (e.g. L1, L2, L3…)
-        try:
-            lot_info.sort(key=lambda x: int(re.findall(r'\d+', x['lot_number'])[0]))
-        except Exception:
-            pass
+        slhc_count = sum(1 for w, _ in solution if w <= 10.5)
+        standard_count = sum(1 for w, _ in solution if 10.5 < w <= 14)
+        premium_count = sum(1 for w, _ in solution if w > 14)
 
-        return lot_info
+        slhc_pairs = sum(
+            1 for i in range(len(solution) - 1)
+            if solution[i][0] <= 10.5 and solution[i + 1][0] <= 10.5
+        )
 
-    def create_annotated_preview(self, img, lot_data):
-        """Overlay bounding boxes and labels onto the plan image for preview"""
-        if not PLAN_READER_AVAILABLE:
-            return img
+        total_width = sum(w for w, _ in solution)
+        variance = total_width - stage_width
+        efficiency = "100%" if abs(variance) < 0.001 else f"{(total_width / stage_width) * 100:.1f}%"
+
+        metrics_lines = [
+            f"📊 TOTAL LOTS: {total_lots}",
+            f"📐 LAND EFFICIENCY: {efficiency}",
+            f"🎯 DIVERSITY: {diversity_score:.0%} ({unique_widths} types)",
+            f"📏 GRID VARIANCE: {variance:+.2f}m",
+            "",
+            f"SLHC (≤10.5m): {slhc_count} lots",
+            f"Standard (11–14m): {standard_count} lots",
+            f"Premium (>14m): {premium_count} lots",
+            "",
+            f"🚗 SLHC Pairs: {slhc_pairs}",
+            f"💰 Revenue: ${total_lots * 0.5:.1f}M – ${total_lots * 1.2:.1f}M"
+        ]
+
+        col1_text = '\n'.join(metrics_lines[:5])
+        col2_text = '\n'.join(metrics_lines[5:])
+
+        ax2.text(
+            0.05, 0.5, col1_text, transform=ax2.transAxes,
+            fontsize=14, verticalalignment='center', fontweight='bold',
+            color='white',
+            bbox=dict(
+                boxstyle="round,pad=0.5",
+                facecolor='#2a2a2a',
+                edgecolor='#444444',
+                alpha=0.8
+            )
+        )
+        ax2.text(
+            0.55, 0.5, col2_text, transform=ax2.transAxes,
+            fontsize=14, verticalalignment='center', fontweight='bold',
+            color='white',
+            bbox=dict(
+                boxstyle="round,pad=0.5",
+                facecolor='#2a2a2a',
+                edgecolor='#444444',
+                alpha=0.8
+            )
+        )
 
-        annotated = img.copy()
-        colors = {
-            'SLHC':    (255, 0, 0),
-            'Standard': (0, 255, 0),
-            'Premium': (0, 0, 255)
-        }
+        plt.tight_layout()
+        return fig
 
-        for lot in lot_data:
-            if 'bbox' in lot:
-                x, y, w, h = lot['bbox']
-                color = colors.get(lot['type'], (128, 128, 128))
-                cv2.rectangle(annotated, (x, y), (x + w, y + h), color, 2)
-                label = f"{lot['lot_number']}: {lot['frontage']}m"
-                cv2.putText(annotated, label, (x + 5, y + 20),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
-        return annotated
-
-    def lot_data_to_dataframe(self, lot_data):
-        """Turn a list of lot dicts into a pandas DataFrame for display/editing"""
-        if not lot_data:
-            return pd.DataFrame(columns=["Lot #", "Frontage (m)", "Depth (m)", "Area (m²)", "Type"])
-
-        rows = []
-        for lot in lot_data:
-            rows.append({
-                "Lot #":      lot['lot_number'],
-                "Frontage (m)": lot['frontage'],
-                "Depth (m)":    lot['depth'],
-                "Area (m²)":    round(lot['area'], 1),
-                "Type":        lot['type']
-            })
-        return pd.DataFrame(rows)
-
-    def export_lot_data_to_csv(self, df):
-        """Return the CSV‐string representation of the lot‐DataFrame"""
-        if df is None or df.empty:
-            return None
-        buffer = io.StringIO()
-        df.to_csv(buffer, index=False)
-        return buffer.getvalue()
-
-    def convert_lot_data_to_stage_format(self, df):
-        """
-        Summarize manually‐edited lot DataFrame into a total stage width and common depth
-        (so that the main optimizer can re‐run on them).
-        """
-        if df is None or df.empty:
-            return None, None
-
-        frontage_counts = {}
-        for _, row in df.iterrows():
-            frontage = float(row['Frontage (m)'])
-            frontage_counts[frontage] = frontage_counts.get(frontage, 0) + 1
-
-        total_width = sum(f * c for f, c in frontage_counts.items())
-        depths = df['Depth (m)'].mode()
-        common_depth = depths[0] if len(depths) > 0 else 32
-        return total_width, common_depth
-
-    def darken_color(self, hex_color, factor=0.8):
-        """Return a darker shade of the given hex color by multiplying each channel by `factor`."""
+    def parse_manual_adjustments(self, adjustment_text):
+        """Parse manual adjustment input into a list of widths"""
         try:
-            hex_color = hex_color.lstrip('#')
-            r, g, b = (int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-            darker = (int(r * factor), int(g * factor), int(b * factor))
-            return '#' + ''.join(f'{c:02x}' for c in darker)
-        except Exception:
-            return hex_color
-
-
-def create_advanced_app():
-    optimizer = AdvancedGridOptimizer()
-
-    def optimize_grid(
-        stage_width, stage_depth,
-        enable_8_5, enable_10_5, enable_12_5,
-        enable_14, enable_16, enable_18,
-        enable_corners, enable_11, enable_13_3,
-        enable_14_8, enable_16_8,
-        allow_custom_corners, optimization_strategy, color_scheme
-    ):
-        optimizer.current_scheme = color_scheme
-
-        enabled_widths = []
-        if enable_8_5:  enabled_widths.append(8.5)
-        if enable_10_5: enabled_widths.append(10.5)
-        if enable_12_5: enabled_widths.append(12.5)
-        if enable_14:   enabled_widths.append(14.0)
-        if enable_16:   enabled_widths.append(16.0)
-        if enable_18:   enabled_widths.append(18.0)
-
-        if enable_corners:
-            if enable_11:    enabled_widths.append(11.0)
-            if enable_13_3:  enabled_widths.append(13.3)
-            if enable_14_8:  enabled_widths.append(14.8)
-            if enable_16_8:  enabled_widths.append(16.8)
-
-        if not enabled_widths:
-            return None, pd.DataFrame(), "❌ Please select at least one lot width!", "", ""
-
-        if optimization_strategy == "diversity_focus":
-            optimized_solution = optimizer.optimize_with_flexible_corners(
-                stage_width, enabled_widths, allow_custom_corners
-            )
-        else:
-            optimized_solution = optimizer.optimize_with_corners_diverse(
-                stage_width, enabled_widths, None
-            )
+            if not adjustment_text:
+                return []
+            adjustment_text = adjustment_text.strip()
+            parts = re.split(r'[,\s]+', adjustment_text)
+            widths = [float(w.strip()) for w in parts if w.strip()]
+            return widths
+        except Exception as e:
+            print(f"Error parsing manual adjustments: {e}")
+            return []
 
-        optimizer.current_solution = optimized_solution
+    def validate_manual_solution(self, widths, stage_width):
+        """Validate and provide feedback on manual solution"""
+        if not widths:
+            return None, "No widths provided"
 
-        if optimized_solution:
-            total_width = sum(w for w, _ in optimized_solution)
-            variance = total_width - stage_width
-        else:
-            variance = None
-
-        # —— The only change is this multiline string block, which now IS properly terminated:
-        if (not optimized_solution) or abs(sum(w for w, _ in optimized_solution) - stage_width) > 0.001:
-            return None, pd.DataFrame(), f"""
-### ❌ Cannot achieve 100% usage with selected widths
-
-**Stage Width**: {stage_width}m  
-**Available Widths**: {', '.join([f"{w}m" for w in sorted(enabled_widths)])}
-
-**Try:**
-1. Enable more lot types for flexibility  
-2. Enable "Custom Corners" option  
-3. Try common stage widths: 84m, 105m, 126m  
-""", "", ""
-        # —— End of terminated multiline string block —— #
-
-        fig_2d = optimizer.create_enhanced_visualization(
-            optimized_solution, stage_width, stage_depth,
-            "AI-Optimized Diverse Subdivision Layout",
-            show_variance=variance
-        )
+        total_width = sum(widths)
+        variance = total_width - stage_width
 
-        width_counts = {}
-        for width, lot_type in optimized_solution:
-            key = f"{width:.1f}m"
-            if key in width_counts:
-                width_counts[key]['count'] += 1
+        solution = [
+            (w, 'corner' if i in [0, len(widths) - 1] else 'standard')
+            for i, w in enumerate(widths)
+        ]
+
+        if abs(variance) < 0.001:
+            feedback = "✅ Perfect fit! Grid is exactly aligned."
+        elif variance > 0:
+            feedback = f"⚠️ Grid is {variance:.2f}m too wide."
+        else:
+            feedback = f"⚠️ Grid is {-variance:.2f}m too narrow."
+
+        if abs(variance) > 0.001:
+            if variance > 0:
+                suggestions = []
+                for i, w in enumerate(widths):
+                    if w - variance >= 8.5:
+                        suggestions.append(f"L{i + 1}: reduce from {w:.1f}m to {w - variance:.1f}m")
+                if suggestions:
+                    feedback += "\n\nSuggestions:\n" + "\n".join(suggestions[:3])
             else:
-                if width in optimizer.lot_specifications:
-                    spec = optimizer.lot_specifications[width]
-                elif int(width) in optimizer.lot_specifications:
-                    spec = optimizer.lot_specifications[int(width)]
+                add_each = -variance / len(widths)
+                feedback += f"\n\nSuggestion: Add {add_each:.2f}m to each lot"
+
+        return solution, feedback
+
+    def solution_to_string(self, solution):
+        """Convert solution to comma‐separated string for manual editing"""
+        if not solution:
+            return ""
+        return ", ".join([f"{w:.1f}" for w, _ in solution])
+
+    def optimize_with_corners_diverse(self, stage_width, enabled_widths, manual_allocation=None):
+        """Find lot arrangement with emphasis on diversity & proper corners"""
+        all_widths = sorted(enabled_widths)
+        if not all_widths:
+            return None
+
+        min_internal = min(all_widths)
+        corner_options = [w for w in enabled_widths if w >= max(11.0, min_internal)]
+
+        best_solution = None
+        best_fitness = -float('inf')
+
+        for corner1 in corner_options:
+            for corner2 in corner_options:
+                if abs(corner1 - corner2) > 3.0:
+                    continue
+                internal_space = stage_width - corner1 - corner2
+                if internal_space <= 0:
+                    continue
+                internal_sols = self.find_diverse_combinations(internal_space, all_widths, max_solutions=20)
+                for internal_list in internal_sols:
+                    if not internal_list:
+                        continue
+                    if max(internal_list) > min(corner1, corner2):
+                        continue
+                    solution = [(corner1, 'corner')]
+                    solution.extend([(w, 'standard') for w in internal_list])
+                    solution.append((corner2, 'corner'))
+                    optimized = self.optimize_slhc_grouping(solution)
+                    fitness = self.evaluate_solution_with_diversity(optimized, stage_width)
+                    if fitness > best_fitness:
+                        best_fitness = fitness
+                        best_solution = optimized
+
+        if not best_solution:
+            all_combos = []
+            self.find_all_combinations_recursive(stage_width, sorted(enabled_widths), [], all_combos, 20)
+            for combo in all_combos[:50]:
+                sorted_combo = sorted(combo)
+                if len(sorted_combo) >= 2:
+                    sol = [(sorted_combo[-1], 'corner')]
+                    sol.extend((w, 'standard') for w in sorted_combo[:-2])
+                    sol.append((sorted_combo[-2], 'corner'))
                 else:
-                    closest = min(optimizer.lot_specifications.keys(),
-                                  key=lambda x: abs(x - width))
-                    spec = optimizer.lot_specifications[closest]
-                    spec = {**spec, 'type': 'Custom', 'squares': 'Custom'}
-
-                width_counts[key] = {
-                    'count': 1,
-                    'type': spec.get('type', 'Custom'),
-                    'squares': spec.get('squares', 'N/A'),
-                    'area': width * stage_depth
-                }
-
-        results_data = []
-        for width_label, info in sorted(width_counts.items()):
-            results_data.append({
-                'Lot Width': width_label,
-                'Count': info['count'],
-                'Type': info['type'],
-                'Area Each': f"{info['area']:.0f}m²",
-                'Total Width': f"{float(width_label[:-1]) * info['count']:.1f}m",
-                'Total Area': f"{info['area'] * info['count']:.0f}m²"
-            })
-
-        results_df = pd.DataFrame(results_data)
-        report = optimizer.generate_report(optimized_solution, stage_width, stage_depth, None)
-
-        total_lots = len(optimized_solution)
-        unique_widths = len(set(w for w, _ in optimized_solution))
-        slhc_pairs = sum(
-            1 for i in range(len(optimized_solution) - 1)
-            if optimized_solution[i][0] <= 10.5 and optimized_solution[i + 1][0] <= 10.5
-        )
+                    sol = [(w, 'standard') for w in sorted_combo]
+                optimized = self.optimize_slhc_grouping(sol)
+                fitness = self.evaluate_solution_with_diversity(optimized, stage_width)
+                if fitness > best_fitness:
+                    best_fitness = fitness
+                    best_solution = optimized
+
+        return best_solution
+
+    def optimize_with_flexible_corners(self, stage_width, enabled_widths, allow_custom_corners=True):
+        """Enhanced optimization allowing corner widths ±0.5m variation"""
+        standard_internal = [w for w in enabled_widths if w not in self.corner_specific]
+
+        best_solution = None
+        best_fitness = -float('inf')
+
+        # Try strict corner widths first
+        sol = self.optimize_with_corners_diverse(stage_width, enabled_widths, None)
+        if sol:
+            fitness = self.evaluate_solution_with_diversity(sol, stage_width)
+            if fitness > best_fitness:
+                best_fitness = fitness
+                best_solution = sol
+
+        # If custom corners allowed, vary around each base corner
+        if allow_custom_corners and standard_internal:
+            for base in [11.0, 13.3, 14.8, 16.8, 14.0, 16.0]:
+                if any(abs(w - base) < 2 for w in enabled_widths):
+                    custom_sol = self.find_optimal_custom_corners(
+                        stage_width, standard_internal, base, tolerance=0.5
+                    )
+                    if custom_sol:
+                        fitness = self.evaluate_solution_with_diversity(custom_sol, stage_width)
+                        if fitness > best_fitness:
+                            best_fitness = fitness
+                            best_solution = custom_sol
+
+        return best_solution
+
+    def find_optimal_custom_corners(self, stage_width, internal_widths, base_corner_width, tolerance=0.5):
+        """Search corner widths ±0.5m to maximize diversity & fit exactly"""
+        best_solution = None
+        best_fitness = -float('inf')
+
+        min_internal = min(internal_widths) if internal_widths else 8.5
+        min_corner = max(base_corner_width - tolerance, min_internal)
+        variations = np.arange(min_corner, base_corner_width + tolerance + 0.1, 0.1)
+
+        for c1 in variations:
+            for c2 in variations:
+                internal_space = stage_width - c1 - c2
+                if internal_space <= 0:
+                    continue
+                internal_sol = self.find_exact_solution_with_diversity(internal_space, internal_widths)
+                if internal_sol:
+                    if max(internal_sol) > min(c1, c2):
+                        continue
+                    solution = [(round(c1, 1), 'corner')]
+                    solution.extend((w, 'standard') for w in internal_sol)
+                    solution.append((round(c2, 1), 'corner'))
+                    fitness = self.evaluate_solution_with_diversity(solution, stage_width)
+                    if fitness > best_fitness:
+                        best_fitness = fitness
+                        best_solution = solution
+
+        return best_solution
+
+    def find_diverse_combinations(self, target_width, available_widths, max_solutions=20):
+        """Find all combos that sum to target_width, then pick the top‐20 by diversity"""
+        all_solutions = []
+        self.find_all_combinations_recursive(target_width, available_widths, [], all_solutions, 20)
+        if not all_solutions:
+            return []
 
-        corner_info = "N/A"
-        if len(optimized_solution) >= 2:
-            first = optimized_solution[0][0]
-            last = optimized_solution[-1][0]
-            diff = abs(first - last)
-            if diff < 0.1:
-                corner_info = f"✨ PERFECT ({first:.1f}m × 2)"
-            elif diff <= 1.0:
-                corner_info = f"✅ Excellent ({first:.1f}m + {last:.1f}m)"
-            elif diff <= 2.0:
-                corner_info = f"👍 Good ({first:.1f}m + {last:.1f}m)"
+        scored = []
+        for sol in all_solutions:
+            scored.append((len(set(sol)), sol))
+        scored.sort(key=lambda x: (x[0], len(x[1])), reverse=True)
+        return [sol for _, sol in scored[:max_solutions]]
+
+    def find_exact_solution_with_diversity(self, target_width, enabled_widths, max_depth=20):
+        """Dynamic‐programming approach to find an exact‐sum solution that maximizes diversity"""
+        dp = {0: ([], set())}  # {sum: (solution_list, unique_widths)}
+
+        for current in range(1, int(target_width) + 1):
+            best_div = -1
+            best_pair = None
+            for w in enabled_widths:
+                if w <= current and (current - w) in dp:
+                    prev_list, prev_set = dp[current - w]
+                    if len(prev_list) < max_depth:
+                        new_list = prev_list + [w]
+                        new_set = prev_set | {w}
+                        diversity = len(new_set)
+                        if diversity > best_div:
+                            best_div = diversity
+                            best_pair = (new_list, new_set)
+            if best_pair:
+                dp[current] = best_pair
+
+        if target_width in dp:
+            return dp[target_width][0]
+
+        # Fallback to simpler exact‐sum
+        return self.find_exact_solution(target_width, enabled_widths, max_depth)
+
+    def find_exact_solution(self, target_width, enabled_widths, max_depth=20):
+        """Classic DP to find ANY combination of enabled_widths summing to target_width"""
+        # Quick check for a single‐width repetition
+        for w in enabled_widths:
+            if abs(target_width % w) < 0.001:
+                count = int(target_width / w)
+                if count <= max_depth:
+                    return [w] * count
+
+        dp = {0: []}  # {sum: solution_list}
+        for s in range(1, int(target_width) + 1):
+            dp[s] = None
+            for w in enabled_widths:
+                if w <= s and dp[s - w] is not None and len(dp[s - w]) < max_depth:
+                    dp[s] = dp[s - w] + [w]
+                    break
+
+        if dp.get(target_width) is not None:
+            return dp[target_width]
+
+        # Last‐resort: brute‐force recursion
+        all_solutions = []
+        self.find_all_combinations_recursive(target_width, sorted(enabled_widths), [], all_solutions, max_depth)
+        return min(all_solutions, key=len) if all_solutions else None
+
+    def find_all_combinations_recursive(self, remaining, widths, current, all_solutions, max_depth):
+        """Recursively build up lists of widths to exactly match remaining"""
+        if abs(remaining) < 0.001:
+            all_solutions.append(current[:])
+            return
+        if remaining < 0 or len(current) >= max_depth or len(all_solutions) >= 100:
+            return
+        for i, w in enumerate(widths):
+            if w <= remaining + 0.001:
+                current.append(w)
+                self.find_all_combinations_recursive(remaining - w, widths[i:], current, all_solutions, max_depth)
+                current.pop()
+
+    def optimize_slhc_grouping(self, lots):
+        """Re‐order an existing (corner, slhc, standard, custom) list for best grouping"""
+        if not lots or len(lots) <= 1:
+            return lots
+
+        corner_specific = []
+        slhc_lots = []
+        standard_lots = []
+        custom_lots = []
+
+        for w, lot_type in lots:
+            if w in self.corner_specific:
+                corner_specific.append((w, lot_type))
+            elif w <= 10.5:
+                slhc_lots.append((w, lot_type))
+            elif w in self.standard_widths + self.premium_widths:
+                standard_lots.append((w, lot_type))
             else:
-                corner_info = f"⚠️ Unbalanced ({first:.1f}m + {last:.1f}m)"
+                # Custom widths that are not exact matches
+                if 10.8 < w < 17:
+                    custom_lots.append((w, lot_type))
+                else:
+                    standard_lots.append((w, lot_type))
 
-        summary = f"""
-**Stage**: {stage_width}m × {stage_depth}m = {stage_width * stage_depth}m²  
-**Total Lots**: {total_lots}  
-**Unique Lot Types**: {unique_widths}  
-**Grid Variance**: {variance:+.2f}m {"✅" if abs(variance) < 0.001 else "⚠️"}  
-"""
+        slhc_8_5  = [(w, t) for w, t in slhc_lots if abs(w - 8.5) < 0.1]
+        slhc_10_5 = [(w, t) for w, t in slhc_lots if abs(w - 10.5) < 0.1]
 
-        manual_edit_string = optimizer.solution_to_string(optimized_solution)
-        return fig_2d, results_df, summary, report, manual_edit_string
+        corner_solution = self._determine_best_corners(corner_specific + custom_lots, standard_lots)
 
-    def update_manual_adjustment(manual_widths_text, stage_width, stage_depth, color_scheme):
-        """Update visualization based on manually entered widths"""
-        optimizer.current_scheme = color_scheme
-        widths = optimizer.parse_manual_adjustments(manual_widths_text)
-        if not widths:
-            return None, "Please enter lot widths (e.g. '14.0, 8.5, 10.5, 8.5, 14.0')"
+        optimized = []
+        # Place first corner
+        if corner_solution and corner_solution[0]:
+            optimized.append((corner_solution[0][0], 'corner'))
+            for lst in [corner_specific, custom_lots, standard_lots]:
+                if corner_solution[0] in lst:
+                    lst.remove(corner_solution[0])
+                    break
+
+        # Add SLHC in optimal pairs
+        optimized.extend(self._arrange_slhc_optimally(slhc_8_5, slhc_10_5))
+
+        # Add remaining standard & custom
+        optimized.extend(standard_lots)
+        optimized.extend(custom_lots)
+        optimized.extend(corner_specific)
+
+        # Place second corner
+        if corner_solution and len(corner_solution) > 1 and corner_solution[1]:
+            optimized.append((corner_solution[1][0], 'corner'))
 
-        solution, feedback = optimizer.validate_manual_solution(widths, stage_width)
+        return optimized
+
+    def _determine_best_corners(self, corner_suitable, standard_lots):
+        """Pick two lots (among corner‐suitable or large standard) that are closest in width"""
+        all_suitable = corner_suitable + [(w, t) for w, t in standard_lots if w >= 12.5]
+        if len(all_suitable) < 2:
+            return None
+
+        best_pair = None
+        min_diff = float('inf')
+        for i in range(len(all_suitable)):
+            for j in range(i + 1, len(all_suitable)):
+                diff = abs(all_suitable[i][0] - all_suitable[j][0])
+                if diff < min_diff:
+                    min_diff = diff
+                    best_pair = (all_suitable[i], all_suitable[j])
+        return best_pair
+
+    def _arrange_slhc_optimally(self, slhc_8_5, slhc_10_5):
+        """Group SLHC lots in same‐width pairs first, then cross‐mix if needed"""
+        arranged = []
+        while len(slhc_8_5) >= 2:
+            arranged.extend(slhc_8_5[:2])
+            slhc_8_5 = slhc_8_5[2:]
+        while len(slhc_10_5) >= 2:
+            arranged.extend(slhc_10_5[:2])
+            slhc_10_5 = slhc_10_5[2:]
+        while slhc_8_5 and slhc_10_5:
+            arranged.append(slhc_8_5[0]);   slhc_8_5 = slhc_8_5[1:]
+            arranged.append(slhc_10_5[0]);  slhc_10_5 = slhc_10_5[1:]
+        arranged.extend(slhc_8_5)
+        arranged.extend(slhc_10_5)
+        return arranged
+
+    def evaluate_solution_with_diversity(self, solution, stage_width):
+        """Fitness = #lots*1000 + (#unique widths)*2000 – (max repetition)*500 + ratio‐bonus + corner‐bonus"""
         if not solution:
-            return None, feedback
+            return -float('inf')
 
-        total_width = sum(widths)
-        variance = total_width - stage_width
+        total_width = sum(w for w, _ in solution)
+        waste = stage_width - total_width
+        if abs(waste) > 0.001:
+            return -float('inf')
 
-        fig = optimizer.create_enhanced_visualization(
-            solution, stage_width, stage_depth,
-            "Manually Adjusted Layout", show_variance=variance
-        )
-        return fig, feedback
+        lot_count = len(solution)
+        width_counts = {}
+        for w, _ in solution:
+            width_counts[w] = width_counts.get(w, 0) + 1
+
+        unique_widths = len(width_counts)
+        max_repetition = max(width_counts.values())
+        diversity_ratio = unique_widths / lot_count if lot_count > 0 else 0
+
+        fitness = lot_count * 1000
+        fitness += unique_widths * 2000
+        fitness -= max_repetition * 500
+        fitness += diversity_ratio * 3000
+
+        # Corner: penalize if SLHC on corners, reward if ≥11m
+        if len(solution) >= 2:
+            first_w = solution[0][0]
+            last_w  = solution[-1][0]
+            if first_w <= 10.5: fitness -= 2000
+            if last_w <= 10.5:  fitness -= 2000
+            if first_w >= 11.0: fitness += 1000
+            if last_w  >= 11.0: fitness += 1000
+            diff = abs(first_w - last_w)
+            if diff < 0.1:
+                fitness += 1500
+            elif diff <= 1.0:
+                fitness += 1000
+            elif diff <= 2.0:
+                fitness += 500
+            else:
+                fitness -= 500
 
-    def process_uploaded_plan(file_path, scale, auto_detect, confidence):
-        if not file_path:
-            return None, pd.DataFrame(), "Please upload a plan file"
-        preview, lot_data, status = optimizer.process_plan_image(
-            file_path, scale, auto_detect, confidence
-        )
-        if lot_data:
-            df = optimizer.lot_data_to_dataframe(lot_data)
-            return preview, df, status
-        else:
-            return preview, pd.DataFrame(), status
-
-    def export_to_csv(df):
-        if df is None or df.empty:
-            return gr.update(visible=False), "No data to export"
-        csv_content = optimizer.export_lot_data_to_csv(df)
-        return gr.update(value=csv_content, visible=True), "✅ CSV data ready – copy and save as .csv file"
-
-    def send_to_optimizer(df):
-        if df is None or df.empty:
-            return 0, 32, "No data to send"
-        width, depth = optimizer.convert_lot_data_to_stage_format(df)
-        if width is None:
-            return 0, 32, "No data to send"
-        return width, depth, f"✅ Stage dimensions set to {width:.1f}m × {depth:.1f}m\nSwitch to 'AI Optimization' tab to continue"
-
-    def validate_lot_data(df):
-        if df is None or df.empty:
-            return "No data to validate"
-        issues = []
-        if df.isnull().any().any():
-            issues.append("⚠️ Missing values detected")
-        if (df['Frontage (m)'] < 6).any():
-            issues.append("⚠️ Some lots have frontage < 6m")
-        if (df['Frontage (m)'] > 30).any():
-            issues.append("⚠️ Some lots have frontage > 30m")
-        if len(df) < 5:
-            issues.append("ℹ️ Few lots detected – check if all were found")
-        return "✅ Data looks good! {} lots ready for optimization".format(len(df)) \
-            if not issues else "\n".join(issues)
-
-    def add_lot_row(df):
-        if df is None or df.empty:
-            new_row = pd.DataFrame({
-                "Lot #": ["L1"],
-                "Frontage (m)": [12.5],
-                "Depth (m)": [32.0],
-                "Area (m²)": [12.5 * 32],
-                "Type": ["Standard"]
-            })
-            return new_row
-        else:
-            last_lot_num = len(df) + 1
-            new_row = pd.DataFrame({
-                "Lot #": [f"L{last_lot_num}"],
-                "Frontage (m)": [12.5],
-                "Depth (m)": [32.0],
-                "Area (m²)": [12.5 * 32],
-                "Type": ["Standard"]
-            })
-            return pd.concat([df, new_row], ignore_index=True)
-
-    def remove_selected_rows(df, rows_to_remove):
-        if df is None or df.empty:
-            return df
-        if not rows_to_remove:
-            return df
-        return df.drop(rows_to_remove, axis=0, errors='ignore').reset_index(drop=True)
-
-    with gr.Blocks(
-        title="Advanced AI Grid Optimizer",
-        theme=gr.themes.Base(),
-        css="""
-        .gradio-container {
-            font-family: 'Segoe UI', sans-serif;
-            background: #1a1a1a;
-            color: white;
-        }
-        .gr-button-primary {
-            background: linear-gradient(45deg, #FF073A 30%, #0AEFFF 90%);
-            border: none;
-            box-shadow: 0 3px 5px 2px rgba(255, 7, 58, .3);
-        }
-        h1 {
-            background: linear-gradient(45deg, #FF073A, #0AEFFF);
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-            text-align: center;
-            font-size: 2.5em;
-        }
-        .gr-form {
-            background: rgba(42, 42, 42, 0.9);
-            border-radius: 10px;
-            padding: 20px;
-            border: 1px solid #444;
-        }
-        .gr-input {
-            background-color: #2a2a2a;
-            color: white;
-            border: 1px solid #444;
-        }
-        .gr-check-radio {
-            background-color: #2a2a2a;
-        }
-        """
-    ) as demo:
-        gr.Markdown("""
-        # 🏗️ Advanced AI Grid Cut Optimizer Pro  
-        ### AI-Powered Subdivision Planning with Manual Fine-Tuning
-        """)
-
-        with gr.Tabs():
-            with gr.TabItem("🤖 AI Optimization"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        with gr.Group():
-                            gr.Markdown("### 📐 Stage Dimensions")
-                            stage_width = gr.Number(
-                                label="Stage Width (m)",
-                                value=105.0,
-                                info="Width along the street"
-                            )
-                            stage_depth = gr.Number(
-                                label="Stage Depth (m)",
-                                value=32.0,
-                                info="Depth of lots (perpendicular to street)"
-                            )
-
-                        gr.Markdown("### 📏 Lot Width Options")
-                        with gr.Group():
-                            gr.Markdown("**Standard Widths**")
-                            with gr.Row():
-                                enable_8_5  = gr.Checkbox(label="8.5m SLHC", value=True)
-                                enable_10_5 = gr.Checkbox(label="10.5m SLHC", value=True)
-                                enable_12_5 = gr.Checkbox(label="12.5m", value=True)
-                            with gr.Row():
-                                enable_14  = gr.Checkbox(label="14.0m", value=True)
-                                enable_16  = gr.Checkbox(label="16.0m", value=True)
-                                enable_18  = gr.Checkbox(label="18.0m", value=False)
-
-                        with gr.Group():
-                            enable_corners = gr.Checkbox(
-                                label="Enable Corner-Specific Widths",
-                                value=True,
-                                info="Adds variety and helps achieve 100%"
-                            )
-                            with gr.Row():
-                                enable_11   = gr.Checkbox(label="11.0m", value=True)
-                                enable_13_3 = gr.Checkbox(label="13.3m", value=True)
-                            with gr.Row():
-                                enable_14_8 = gr.Checkbox(label="14.8m", value=True)
-                                enable_16_8 = gr.Checkbox(label="16.8m", value=True)
-
-                    with gr.Column(scale=1):
-                        gr.Markdown("### ⚙️ Advanced Settings")
-                        allow_custom_corners = gr.Checkbox(
-                            label="🎯 Allow Flexible Corner Widths",
-                            value=True,
-                            info="Enables 13.8m, 13.9m, etc., for perfect fits"
-                        )
-                        optimization_strategy = gr.Radio(
-                            ["diversity_focus", "balanced"],
-                            label="Optimization Strategy",
-                            value="diversity_focus",
-                            info="Diversity creates more interesting layouts"
-                        )
-                        color_scheme = gr.Radio(
-                            ["modern", "professional", "neon"],
-                            label="🎨 Color Scheme",
-                            value="neon",
-                            info="Neon colors work best with dark background"
-                        )
-                        optimize_btn = gr.Button(
-                            "🚀 Optimize with AI",
-                            variant="primary",
-                            size="lg",
-                            elem_id="optimize-button"
-                        )
-                        gr.Markdown("""
-                        ### 💡 Quick Tips:
-                        - **Visual Fix**: All lots now align at rear boundary  
-                        - **Corner Lots**: Always wider than internals  
-                        - **Grid Variance**: Shows if layout is perfect (0.0m)  
-                        - **Manual Adjust**: Edit the result below after optimization  
-                        """)
-
-                with gr.Row():
-                    plot_2d = gr.Plot(label="2D Layout with Corner Splays")
-
-                gr.Markdown("### ✏️ Fine‐Tune AI Result")
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        manual_widths = gr.Textbox(
-                            label="Manually Adjust Lot Widths",
-                            placeholder="Widths will appear here after optimization",
-                            info="Edit the widths (comma‐separated) and click 'Update Layout'",
-                            lines=2
-                        )
-                    with gr.Column(scale=1):
-                        update_btn = gr.Button("🔄 Update Layout", variant="secondary")
-                        adjustment_feedback = gr.Markdown(
-                            value="",
-                            label="Adjustment Feedback"
-                        )
-
-                with gr.Row():
-                    results_table = gr.DataFrame(label="Lot Distribution Analysis")
-
-                with gr.Row():
-                    with gr.Column():
-                        summary_output = gr.Markdown(label="Optimization Summary")
-                    with gr.Column():
-                        report_output = gr.Markdown(label="Professional Report")
-
-                optimize_btn.click(
-                    optimize_grid,
-                    inputs=[
-                        stage_width, stage_depth,
-                        enable_8_5, enable_10_5, enable_12_5,
-                        enable_14, enable_16, enable_18,
-                        enable_corners, enable_11, enable_13_3,
-                        enable_14_8, enable_16_8,
-                        allow_custom_corners, optimization_strategy, color_scheme
-                    ],
-                    outputs=[plot_2d, results_table, summary_output, report_output, manual_widths]
-                )
+        # Bonus for adjacent SLHC
+        for i in range(len(solution) - 1):
+            if solution[i][0] <= 10.5 and solution[i + 1][0] <= 10.5:
+                fitness += 300
 
-                update_btn.click(
-                    update_manual_adjustment,
-                    inputs=[manual_widths, stage_width, stage_depth, color_scheme],
-                    outputs=[plot_2d, adjustment_feedback]
-                )
+        # Penalty if a corner‐specific width used internally
+        for i in range(1, len(solution) - 1):
+            if solution[i][0] in self.corner_specific:
+                fitness -= 200
 
-            with gr.TabItem("📊 Plan Reader"):
-                gr.Markdown("""
-                ## 🏢 AI Plan Reader  
-                ### Upload your subdivision plan to automatically extract lot information
-                """)
-
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        plan_upload = gr.File(
-                            label="Upload Subdivision Plan",
-                            file_types=["image", "pdf"],
-                            type="filepath"
-                        )
-                        gr.Markdown("""
-                        **Supported Formats:**
-                        - PDF plans  
-                        - PNG/JPG images  
-                        - CAD exports  
-
-                        **Best Results:**
-                        - High resolution (300+ DPI)  
-                        - Clear lot numbers  
-                        - Visible frontage dimensions  
-                        - North arrow included  
-                        """)
-                        process_plan_btn = gr.Button(
-                            "🔍 Analyze Plan",
-                            variant="primary",
-                            size="lg"
-                        )
-                        with gr.Group():
-                            gr.Markdown("**Analysis Settings**")
-                            scale_input = gr.Number(
-                                label="Scale (1:X)",
-                                value=1000,
-                                info="Drawing scale ratio"
-                            )
-                            auto_detect_scale = gr.Checkbox(
-                                label="Auto-detect scale from plan",
-                                value=True
-                            )
-                            confidence_threshold = gr.Slider(
-                                label="Detection Confidence",
-                                minimum=0.5,
-                                maximum=0.95,
-                                value=0.75,
-                                step=0.05,
-                                info="Higher = more accurate but may miss some lots"
-                            )
-
-                    with gr.Column(scale=2):
-                        plan_preview = gr.Image(
-                            label="Analyzed Plan Preview",
-                            type="numpy"
-                        )
-                        analysis_status = gr.Markdown(
-                            value="Upload a plan to begin analysis",
-                            label="Analysis Status"
-                        )
-
-                gr.Markdown("### 📊 Extracted Lot Data")
-                with gr.Row():
-                    extracted_data = gr.DataFrame(
-                        headers=["Lot #", "Frontage (m)", "Depth (m)", "Area (m²)", "Type"],
-                        label="Detected Lots",
-                        interactive=True
-                    )
-                    with gr.Column():
-                        extraction_summary = gr.Markdown(label="Extraction Summary")
-                        export_btn = gr.Button("📥 Export to CSV", variant="secondary")
-                        send_to_optimizer_btn = gr.Button("➡️ Send to Optimizer", variant="primary")
-
-                gr.Markdown("### ✏️ Manual Corrections")
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("""
-                        **Quick Edit Tools:**
-                        - Double‐click cells to edit  
-                        - Add missing lots manually  
-                        - Correct misread numbers  
-                        - Adjust frontages  
-                        """)
-                        add_lot_btn = gr.Button("➕ Add Lot", size="sm")
-                        remove_selected_btn = gr.Button("➖ Remove Selected", size="sm")
-                    with gr.Column():
-                        validation_result = gr.Markdown(label="Data Validation")
-
-                process_plan_btn.click(
-                    process_uploaded_plan,
-                    inputs=[plan_upload, scale_input, auto_detect_scale, confidence_threshold],
-                    outputs=[plan_preview, extracted_data, analysis_status]
-                )
+        return fitness
 
-                export_btn.click(
-                    export_to_csv,
-                    inputs=[extracted_data],
-                    outputs=[gr.Textbox(label="CSV Export (copy & save)", lines=8, visible=False),
-                             extraction_summary]
-                )
+    def generate_report(self, solution, stage_width, stage_depth, manual_allocation=None):
+        """Generate a Markdown‐style report summarizing the layout"""
+        if not solution:
+            return None
 
-                send_to_optimizer_btn.click(
-                    send_to_optimizer,
-                    inputs=[extracted_data],
-                    outputs=[stage_width, stage_depth, extraction_summary]
-                )
+        custom_widths = [f"{w:.1f}m" for w, _ in solution if w not in self.lot_specifications]
 
-                extracted_data.change(
-                    validate_lot_data,
-                    inputs=[extracted_data],
-                    outputs=[validation_result]
-                )
+        unique_widths = len(set(w for w, _ in solution))
+        width_counts = {}
+        for w, _ in solution:
+            width_counts[w] = width_counts.get(w, 0) + 1
 
-                add_lot_btn.click(
-                    add_lot_row,
-                    inputs=[extracted_data],
-                    outputs=[extracted_data]
-                )
+        total_width = sum(w for w, _ in solution)
+        variance = total_width - stage_width
 
-                remove_selected_btn.click(
-                    remove_selected_rows,
-                    inputs=[extracted_data, gr.State([])],
-                    outputs=[extracted_data]
-                )
+        report = f"""
+# SUBDIVISION OPTIMIZATION REPORT
+## Project Analysis for {stage_width}m × {stage_depth}m Stage
+
+### EXECUTIVE SUMMARY
+- **Total Lots**: {len(solution)}
+- **Unique Lot Types**: {unique_widths}
+- **Land Efficiency**: {"100%" if abs(variance) < 0.001 else f"{(total_width/stage_width)*100:.1f}%"}
+- **Grid Variance**: {variance:+.2f}m
+- **Stage Dimensions**: {stage_width}m × {stage_depth}m
+- **Total Area**: {stage_width * stage_depth}m²
+{f"- **Custom Widths Used**: {', '.join(custom_widths)}" if custom_widths else ""}
+"""
+
+        report += "\n### LOT DIVERSITY ANALYSIS\n"
+        sorted_counts = sorted(width_counts.items(), key=lambda x: x[1], reverse=True)
+        for width, count in sorted_counts:
+            percentage = (count / len(solution)) * 100
+            if width in self.lot_specifications:
+                spec = self.lot_specifications[width]
+                report += f"- **{width:.1f}m** × {count} ({percentage:.1f}%): {spec['type']}\n"
+            else:
+                report += f"- **{width:.1f}m** × {count} ({percentage:.1f}%): Custom Width\n"
+
+        if len(solution) >= 2:
+            report += f"""
+### CORNER ANALYSIS
+- **Front Corner**: {solution[0][0]:.1f}m with 3m × 3m splay
+- **Rear Corner**: {solution[-1][0]:.1f}m with 3m × 3m splay
+- **Balance**: {abs(solution[0][0] - solution[-1][0]):.1f}m difference
+"""
+
+        report += """
+### DESIGN FEATURES
+- Corner splays provide safe sight lines at intersections
+- All lots have identical rear alignment for visual consistency
+- Diverse lot mix ensures varied streetscape
+- SLHC lots grouped for efficient garbage collection
 
-    return demo
+---
+*Report generated: {timestamp}*
+""".format(timestamp=datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
 
+        return report
 
-if __name__ == "__main__":
-    app = create_advanced_app()
-    app.launch()
+    def process_plan_image(self, image_path, scale=1000, auto_detect_scale=True, confidence=0.75):
+        """Use OpenCV + Tesseract to identify lots & OCR text; return a preview plus lot data"""
+        if not PLAN_READER_AVAILABLE:
+            # Demo mode: return a mock array and mock lot list
+            mock_lots = []
+            for i in range(8):
+                frontage = np.random.choice([8.5, 10.5, 12.5, 14.0, 16.0])
+                mock_lots.append({
+                    'lot_number': f'L{i + 1}',
+                    'frontage': frontage,
+                    'depth': 32,
+                    'area': frontage * 32,
+                    'type': 'SLHC' if frontage <= 10.5 else 'Standard' if frontage <= 14 else 'Premium'
+                })
+
+            # Create a simple “demo” image
+            fig, ax = plt.subplots(figsize=(10, 8))
+            ax.text(0.5, 0.5,
+                    'Plan Reader Demo Mode\n(Install required libraries for actual functionality)',
+                    ha='center', va='center', fontsize=16, transform=ax.transAxes)
+            ax.set_xlim(0, 1); ax.set_ylim(0, 1); ax.axis('off')
+            fig.canvas.draw()
+            preview_img = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
+            preview_img = preview_img.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+            plt.close()
+            summary = """
+### Demo Mode Active
+Plan reader libraries not installed. Showing sample data.
+
+**To enable full functionality, install:**