Update app.py

app.py

@@ -3,13 +3,16 @@ 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.patches import Rectangle, FancyBboxPatch, Circle, Polygon, Wedge, Path, PathPatch
 from matplotlib.collections import PatchCollection
+from matplotlib import cm
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+import json
 from datetime import datetime
 import io
-import json
+import base64
 import tempfile
-import re
 
 # Try to import plan reading libraries
 try:
@@ -20,264 +23,272 @@ try:
     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.")
-
+    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"},
+            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"}
+            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"}
         }
-
+        
         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'
+                8.5: '#FF6B6B',    # Vibrant Red
+                10.5: '#4ECDC4',   # Teal
+                12.5: '#45B7D1',   # Sky Blue
+                14.0: '#96CEB4',   # Sage Green
+                16.0: '#DDA0DD',   # Lavender
+                18.0: '#FFD93D',   # Golden
+                11.0: '#FFA07A',   # Coral
+                13.3: '#98D8C8',   # Mint
+                14.8: '#F7DC6F',   # Butter
+                16.8: '#BB8FCE'    # Orchid
             },
             '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'
+                8.5: '#E74C3C',    # Professional Red
+                10.5: '#3498DB',   # Professional Blue
+                12.5: '#2ECC71',   # Professional Green
+                14.0: '#F39C12',   # Professional Orange
+                16.0: '#9B59B6',   # Professional Purple
+                18.0: '#1ABC9C',   # Professional Turquoise
+                11.0: '#E67E22',   # Professional Dark Orange
+                13.3: '#16A085',   # Professional Teal
+                14.8: '#F1C40F',   # Professional Yellow
+                16.8: '#8E44AD'    # Professional Dark Purple
             },
             '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'
+                8.5: '#FF073A',    # Neon Red
+                10.5: '#0AEFFF',   # Neon Cyan
+                12.5: '#39FF14',   # Neon Green
+                14.0: '#FF6600',   # Neon Orange
+                16.0: '#BF00FF',   # Neon Purple
+                18.0: '#FFFF00',   # Neon Yellow
+                11.0: '#FF1493',   # Neon Pink
+                13.3: '#00FFFF',   # Neon Aqua
+                14.8: '#FFF700',   # Bright Yellow
+                16.8: '#FF00FF'    # Neon Magenta
             }
         }
-
+        
         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):
+    
+    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'
-        )
-
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(18, 12), gridspec_kw={'height_ratios': [3, 1]}, 
+                                      facecolor='#1a1a1a')
+        
+        # Main visualization
         colors = self.color_schemes[self.current_scheme]
+        
         x_pos = 0
         lot_num = 1
+        
+        # Set up main plot with dark background
         ax1.set_xlim(-5, stage_width + 5)
         ax1.set_ylim(-10, 50)
         ax1.set_facecolor('#1a1a1a')
-
-        # Title with variance if provided
+        
+        # Add title with variance if provided
         if show_variance is not None:
+            variance_color = '#39FF14' if abs(show_variance) < 0.001 else '#FF073A'
             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
+        
+        # Add 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.imshow(gradient, extent=[-5, stage_width + 5, -10, 50], aspect='auto', 
+                   cmap='Greys', alpha=0.3, zorder=0)
+        
+        # Add street with label
+        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
-
+        ax1.text(stage_width/2, -2, 'STREET', ha='center', va='center', 
+                fontsize=20, color='white', fontweight='bold')
+        
+        # Draw lots with corner splays - FIXED ALIGNMENT
+        splay_size = 3  # 3m corner splay
+        lot_height = 28  # UNIFORM HEIGHT FOR ALL LOTS
+        
         for i, (width, lot_type) in enumerate(solution):
-            # Pick base color, or nearest if missing
+            # Get base color
             if width in colors:
                 base_color = colors[width]
             else:
                 closest_width = min(colors.keys(), key=lambda x: abs(x - width))
                 base_color = colors[closest_width]
-
+            
+            # Check position
             is_corner = (i == 0 or i == len(solution) - 1)
+            
+            # Consistent styling for visual alignment
             face_color = base_color
             edge_color = 'white'
             linewidth = 4.0 if is_corner else 3.0
-
+            
+            # Create lot shape with SAME HEIGHT for all lots
             if is_corner:
-                # Build a 5‐vertex corner polygon (splay at front) &
-                # keep uniform lot height
-                if i == 0:
+                # Corner lot with splay - using same height
+                if i == 0:  # First corner
                     vertices = [
-                        (x_pos + splay_size, 8),  # start after splay
+                        (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)
+                        (x_pos + width, 8 + lot_height),  # SAME HEIGHT
+                        (x_pos, 8 + lot_height),  # Straight rear
+                        (x_pos, 8 + splay_size)   # Splay corner
                     ]
-                else:
+                else:  # Last corner
                     vertices = [
-                        (x_pos,      8),
+                        (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)
+                        (x_pos + width, 8 + splay_size),  # Splay corner
+                        (x_pos + width, 8 + lot_height),  # SAME HEIGHT
+                        (x_pos, 8 + lot_height)
                     ]
-
-                # Close polygon path
+                
+                # Create polygon path
                 codes = [Path.MOVETO] + [Path.LINETO] * (len(vertices) - 1) + [Path.CLOSEPOLY]
-                vertices.append(vertices[0])
+                vertices.append(vertices[0])  # Close the path
                 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
+                lot = PathPatch(path, facecolor=face_color, edgecolor=edge_color, 
+                               linewidth=linewidth, zorder=3)
+                ax1.add_patch(lot)
+                
+                # Add splay line
                 if i == 0:
-                    ax1.plot([x_pos, x_pos + splay_size], [8 + splay_size, 8],
-                             'white', linewidth=2, alpha=0.8)
+                    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)
+                    ax1.plot([x_pos + width - splay_size, x_pos + width], 
+                            [8, 8 + splay_size], 'white', linewidth=2, alpha=0.8)
             else:
-                # 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
-            )
+                # Regular lot with SAME HEIGHT
+                lot = 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)
+            
+            # Add subtle glow (same for all)
+            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
+            
+            # Add rear alignment line to emphasize equal depth
             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
+            ax1.plot([x_pos, x_pos + width], [rear_y, rear_y], 
+                    color=edge_color, linewidth=1, alpha=0.3, linestyle='--')
+            
+            # Add lot information (positioned consistently)
+            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
             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))
+                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'
-            )
-
-            # Dimension indicator lines at front of lot
+            
+            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')
+            
+            # Dimension lines
             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
-            )
-        )
-
-        # Draw stage dimension arrow & text
+        
+        # Add rear alignment line across all lots
+        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))
+        
+        # Add stage dimensions
         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')
-
-        # Hide all axes spines/ticks
-        ax1.set_xticks([]); ax1.set_yticks([])
+        ax1.text(stage_width/2, -7, f'{stage_width}m × {stage_depth}m', 
+                ha='center', va='top', fontsize=16, fontweight='bold', color='white')
+        
+        # Style axes
+        ax1.set_xticks([])
+        ax1.set_yticks([])
         for spine in ax1.spines.values():
             spine.set_visible(False)
-
-        # ========== Metrics panel below ========== #
+        
+        # Metrics panel
         ax2.axis('off')
         ax2.set_facecolor('#1a1a1a')
-
+        
+        # Calculate metrics with diversity score
         total_lots = len(solution)
         unique_widths = len(set(w for w, _ in solution))
         diversity_score = unique_widths / len(set(self.lot_specifications.keys()))
-
+        
         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)
-
-        slhc_pairs = sum(
-            1 for i in range(len(solution) - 1)
-            if solution[i][0] <= 10.5 and solution[i + 1][0] <= 10.5
-        )
-
+        
+        # SLHC pairs
+        slhc_pairs = 0
+        for i in range(len(solution) - 1):
+            if solution[i][0] <= 10.5 and solution[i+1][0] <= 10.5:
+                slhc_pairs += 1
+        
+        # Calculate actual total width and variance
         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}%"
-
+        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}",
@@ -285,436 +296,594 @@ class AdvancedGridOptimizer:
             f"📏 GRID VARIANCE: {variance:+.2f}m",
             "",
             f"SLHC (≤10.5m): {slhc_count} lots",
-            f"Standard (11–14m): {standard_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"
+            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
-            )
-        )
-
+        
+        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))
+        
         plt.tight_layout()
         return fig
-
+    
     def parse_manual_adjustments(self, adjustment_text):
         """Parse manual adjustment input into a list of widths"""
         try:
             if not adjustment_text:
                 return []
+            
+            # Remove any whitespace and split by commas or spaces
             adjustment_text = adjustment_text.strip()
-            parts = re.split(r'[,\s]+', adjustment_text)
-            widths = [float(w.strip()) for w in parts if w.strip()]
+            
+            # Try parsing as comma-separated values
+            if ',' in adjustment_text:
+                widths = [float(w.strip()) for w in adjustment_text.split(',') if w.strip()]
+            # Try parsing as space-separated values
+            elif ' ' in adjustment_text:
+                widths = [float(w.strip()) for w in adjustment_text.split() if w.strip()]
+            # Try parsing as newline-separated values
+            elif '\n' in adjustment_text:
+                widths = [float(w.strip()) for w in adjustment_text.split('\n') if w.strip()]
+            else:
+                # Single value
+                widths = [float(adjustment_text)]
+            
             return widths
         except Exception as e:
             print(f"Error parsing manual adjustments: {e}")
             return []
-
+    
     def validate_manual_solution(self, widths, stage_width):
         """Validate and provide feedback on manual solution"""
         if not widths:
             return None, "No widths provided"
-
+        
         total_width = sum(widths)
         variance = total_width - stage_width
-
-        solution = [
-            (w, 'corner' if i in [0, len(widths) - 1] else 'standard')
-            for i, w in enumerate(widths)
-        ]
-
+        
+        # Create solution format
+        solution = [(w, 'corner' if i in [0, len(widths)-1] else 'standard') 
+                    for i, w in enumerate(widths)]
+        
+        # Provide feedback
         if abs(variance) < 0.001:
             feedback = "✅ Perfect fit! Grid is exactly aligned."
         elif variance > 0:
-            feedback = f"⚠️ Grid is {variance:.2f}m too wide."
+            feedback = f"⚠️ Grid is {variance:.2f}m too wide. Remove {variance:.2f}m total width."
         else:
-            feedback = f"⚠️ Grid is {-variance:.2f}m too narrow."
-
+            feedback = f"⚠️ Grid is {-variance:.2f}m too narrow. Add {-variance:.2f}m total width."
+        
+        # Add suggestions if not perfect
         if abs(variance) > 0.001:
             if variance > 0:
+                # Suggest which lots could be reduced
                 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 w - variance >= 8.5:  # Minimum viable width
+                        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])
+                    feedback += f"\n\nSuggestions:\n" + "\n".join(suggestions[:3])
             else:
-                add_each = -variance / len(widths)
-                feedback += f"\n\nSuggestion: Add {add_each:.2f}m to each lot"
-
+                # Suggest which lots could be increased
+                suggestions = []
+                add_per_lot = -variance / len(widths)
+                feedback += f"\n\nSuggestion: Add {add_per_lot:.2f}m to each lot"
+        
         return solution, feedback
-
+    
     def solution_to_string(self, solution):
-        """Convert solution to comma‐separated string for manual editing"""
+        """Convert solution to string format 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)]
-
+    
+    def parse_manual_input(self, manual_text):
+        """Parse manual input into structured data"""
+        try:
+            if not manual_text:
+                return {}
+            
+            # Try JSON format first
+            if manual_text.strip().startswith('{'):
+                return json.loads(manual_text)
+            
+            # Otherwise parse line by line
+            result = {}
+            for line in manual_text.strip().split('\n'):
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                if '=' in line:
+                    parts = line.split('=')
+                    width_str = parts[0].strip().replace('m', '')
+                    count_str = parts[1].strip()
+                    try:
+                        width_val = float(width_str)
+                        result[width_val] = int(count_str)
+                    except:
+                        pass
+                elif ':' in line:
+                    parts = line.split(':')
+                    width_str = parts[0].strip().replace('m', '')
+                    count_str = parts[1].strip()
+                    try:
+                        width_val = float(width_str)
+                        result[width_val] = int(count_str)
+                    except:
+                        pass
+            return result
+        except Exception as e:
+            print(f"Error parsing manual input: {e}")
+            return {}
+    
+    def find_optimal_custom_corners(self, stage_width, internal_widths, base_corner_width, tolerance=0.5):
+        """Find optimal corner widths that can vary slightly from base width"""
         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:
+        
+        # Ensure corners are at least as wide as smallest internal lot
+        min_internal = min(internal_widths) if internal_widths else 8.5
+        min_corner_width = max(base_corner_width - tolerance, min_internal)
+        
+        # Try variations of corner widths within tolerance
+        variations = np.arange(min_corner_width, 
+                              base_corner_width + tolerance + 0.1, 
+                              0.1)
+        
+        for corner1 in variations:
+            for corner2 in variations:
+                # Calculate internal space
+                internal_width = stage_width - corner1 - corner2
+                if internal_width <= 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:
+                
+                # Try to fill internal space exactly
+                internal_solution = self.find_exact_solution_with_diversity(internal_width, internal_widths)
+                
+                if internal_solution:
+                    # Verify no internal lot is wider than corners
+                    max_internal = max(internal_solution) if internal_solution else 0
+                    if max_internal > min(corner1, corner2):
                         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)
+                    
+                    # Build complete solution
+                    solution = [(round(corner1, 1), 'corner')]
+                    solution.extend([(w, 'standard') for w in internal_solution])
+                    solution.append((round(corner2, 1), 'corner'))
+                    
+                    # Evaluate (prefer balanced corners and diversity)
+                    fitness = self.evaluate_solution_with_diversity(solution, 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:
-                    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
-
+                        best_solution = solution
+        
         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"""
+        """Enhanced optimization allowing flexible corner sizes with diversity"""
+        
+        # Separate widths by type
         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)
+        
+        # Strategy 1: Try exact widths first with diversity
+        solution = self.optimize_with_corners_diverse(stage_width, enabled_widths, None)
+        if solution:
+            fitness = self.evaluate_solution_with_diversity(solution, stage_width)
             if fitness > best_fitness:
                 best_fitness = fitness
-                best_solution = sol
-
-        # If custom corners allowed, vary around each base corner
+                best_solution = solution
+        
+        # Strategy 2: Try flexible corners if enabled
         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
+            # Try variations around each corner-suitable width
+            for base_width in [11.0, 13.3, 14.8, 16.8, 14.0, 16.0]:
+                if any(abs(w - base_width) < 2 for w in enabled_widths):
+                    custom_solution = self.find_optimal_custom_corners(
+                        stage_width, standard_internal, base_width, tolerance=0.5
                     )
-                    if custom_sol:
-                        fitness = self.evaluate_solution_with_diversity(custom_sol, stage_width)
+                    if custom_solution:
+                        fitness = self.evaluate_solution_with_diversity(custom_solution, stage_width)
                         if fitness > best_fitness:
                             best_fitness = fitness
-                            best_solution = custom_sol
-
+                            best_solution = custom_solution
+        
         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"""
+    
+    def optimize_with_corners_diverse(self, stage_width, enabled_widths, manual_allocation=None):
+        """Find lot arrangement with emphasis on diversity and proper corner sizing"""
+        
+        # Separate widths by size
+        all_widths = sorted(enabled_widths)
+        min_internal_width = min(all_widths)
+        
+        # Corner lots must be at least as wide as smallest internal lot
+        corner_options = [w for w in enabled_widths if w >= max(11.0, min_internal_width)]
+        
         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:
+        
+        # Try different corner combinations
+        for corner1 in corner_options:
+            for corner2 in corner_options:
+                if abs(corner1 - corner2) > 3.0:  # Skip very unbalanced
                     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)
+                
+                # Calculate internal space
+                internal_width = stage_width - corner1 - corner2
+                if internal_width <= 0:
+                    continue
+                
+                # Find diverse internal solutions
+                internal_solutions = self.find_diverse_combinations(
+                    internal_width, all_widths, max_solutions=20
+                )
+                
+                for internal_widths in internal_solutions:
+                    # Verify no internal lot is wider than corners
+                    max_internal = max(internal_widths) if internal_widths else 0
+                    if max_internal > min(corner1, corner2):
+                        continue  # Skip if internal lots are wider than corners
+                    
+                    # Build complete solution
+                    solution = [(corner1, 'corner')]
+                    solution.extend([(w, 'standard') for w in internal_widths])
+                    solution.append((corner2, 'corner'))
+                    
+                    # Optimize arrangement
+                    optimized = self.optimize_slhc_grouping(solution)
+                    fitness = self.evaluate_solution_with_diversity(optimized, stage_width)
+                    
                     if fitness > best_fitness:
                         best_fitness = fitness
-                        best_solution = solution
-
+                        best_solution = optimized
+        
+        # If no good solution, try without strict corner rules but maintain size hierarchy
+        if not best_solution:
+            all_solutions = []
+            self.find_all_combinations_recursive(stage_width, sorted(enabled_widths), 
+                                               [], all_solutions, 20)
+            
+            for widths in all_solutions[:50]:
+                # Ensure corners are among the largest lots
+                sorted_widths = sorted(widths)
+                if len(sorted_widths) >= 2:
+                    # Put two largest widths at corners
+                    solution = [(sorted_widths[-1], 'corner')]  # Largest
+                    solution.extend([(w, 'standard') for w in sorted_widths[:-2]])
+                    solution.append((sorted_widths[-2], 'corner'))  # Second largest
+                else:
+                    solution = [(w, 'standard') for w in widths]
+                
+                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
+        
         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"""
+        """Find combinations that maximize diversity"""
         all_solutions = []
-        self.find_all_combinations_recursive(target_width, available_widths, [], all_solutions, 20)
-        if not all_solutions:
-            return []
-
-        scored = []
+        self.find_all_combinations_recursive(target_width, available_widths, 
+                                           [], all_solutions, 20)
+        
+        # Sort by diversity (number of unique widths)
+        diverse_solutions = []
         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]]
-
+            unique_count = len(set(sol))
+            diverse_solutions.append((unique_count, sol))
+        
+        # Sort by diversity, then by total lots
+        diverse_solutions.sort(key=lambda x: (x[0], len(x[1])), reverse=True)
+        
+        # Return the most diverse solutions
+        return [sol[1] for sol in diverse_solutions[: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
-
+        """Find exact solution prioritizing diversity"""
+        
+        # Try to use multiple different widths
+        solutions = []
+        
+        # Dynamic programming with diversity tracking
+        dp = {}
+        dp[0] = ([], set())  # (solution, unique_widths)
+        
+        for current_target in range(1, int(target_width) + 1):
+            best_diversity = -1
+            best_solution = None
+            
+            for width in enabled_widths:
+                if width <= current_target and (current_target - width) in dp:
+                    prev_solution, prev_unique = dp[current_target - width]
+                    if len(prev_solution) < max_depth:
+                        new_solution = prev_solution + [width]
+                        new_unique = prev_unique.copy()
+                        new_unique.add(width)
+                        
+                        diversity = len(new_unique)
+                        if diversity > best_diversity:
+                            best_diversity = diversity
+                            best_solution = (new_solution, new_unique)
+            
+            if best_solution:
+                dp[current_target] = best_solution
+        
         if target_width in dp:
             return dp[target_width][0]
-
-        # Fallback to simpler exact‐sum
+        
+        # Fallback to regular solution
         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)
+        """Find exact combination that sums to target_width"""
+        
+        # Quick check for simple solutions
+        for width in enabled_widths:
+            if abs(target_width % width) < 0.001:
+                count = int(target_width / width)
                 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 [width] * count
+        
+        # Dynamic programming solution
+        dp = {}
+        dp[0] = []
+        
+        for current_target in range(1, int(target_width) + 1):
+            for width in enabled_widths:
+                if width <= current_target and (current_target - width) in dp:
+                    prev_solution = dp[current_target - width]
+                    if len(prev_solution) < max_depth:
+                        dp[current_target] = prev_solution + [width]
+        
+        if target_width in dp:
             return dp[target_width]
-
-        # Last‐resort: brute‐force recursion
+        
+        # Try exhaustive search
         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
-
+        self.find_all_combinations_recursive(target_width, sorted(enabled_widths), 
+                                           [], all_solutions, max_depth)
+        
+        if all_solutions:
+            # Return shortest solution
+            return min(all_solutions, key=len)
+        
+        return None
+    
     def find_all_combinations_recursive(self, remaining, widths, current, all_solutions, max_depth):
-        """Recursively build up lists of widths to exactly match remaining"""
+        """Recursively find all exact combinations"""
         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)
+        
+        for i, width in enumerate(widths):
+            if width <= remaining + 0.001:
+                current.append(width)
+                self.find_all_combinations_recursive(remaining - width, 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"""
+        """Optimize lot arrangement with sophisticated rules"""
         if not lots or len(lots) <= 1:
             return lots
-
+        
+        # Separate lots by type
         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))
+        
+        for width, lot_type in lots:
+            if width in self.corner_specific:
+                corner_specific.append((width, lot_type))
+            elif width <= 10.5:
+                slhc_lots.append((width, lot_type))
+            elif width in self.standard_widths + self.premium_widths:
+                standard_lots.append((width, lot_type))
             else:
-                # Custom widths that are not exact matches
-                if 10.8 < w < 17:
-                    custom_lots.append((w, lot_type))
+                # Custom width
+                if width > 10.8 and width < 17:
+                    custom_lots.append((width, lot_type))
                 else:
-                    standard_lots.append((w, lot_type))
-
-        slhc_8_5  = [(w, t) for w, t in slhc_lots if abs(w - 8.5) < 0.1]
+                    standard_lots.append((width, lot_type))
+        
+        # Further separate SLHC by width
+        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]
-
+        
+        # Determine corner placement
         corner_solution = self._determine_best_corners(corner_specific + custom_lots, standard_lots)
-
+        
+        # Build optimized layout
         optimized = []
+        
         # Place first corner
         if corner_solution and corner_solution[0]:
             optimized.append((corner_solution[0][0], 'corner'))
+            # Remove from appropriate list
             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
+        
+        # Add SLHC groups optimally
         optimized.extend(self._arrange_slhc_optimally(slhc_8_5, slhc_10_5))
-
-        # Add remaining standard & custom
+        
+        # Add remaining lots
         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'))
-
+        
         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"""
+        """Determine the best corner placement strategy"""
         all_suitable = corner_suitable + [(w, t) for w, t in standard_lots if w >= 12.5]
+        
         if len(all_suitable) < 2:
             return None
-
+        
+        # Find best matching pair
         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"""
+        """Arrange SLHC lots for optimal garage adjacency"""
         arranged = []
+        
+        # Pair matching widths first
         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:]
+        
+        # Mixed pairing
         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.append(slhc_8_5[0])
+            arranged.append(slhc_10_5[0])
+            slhc_8_5 = slhc_8_5[1:]
+            slhc_10_5 = slhc_10_5[1:]
+        
+        # Add remaining
         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"""
+        """Evaluate fitness with strong emphasis on diversity"""
         if not solution:
             return -float('inf')
-
+        
         total_width = sum(w for w, _ in solution)
         waste = stage_width - total_width
+        
+        # Must have 100% usage
         if abs(waste) > 0.001:
             return -float('inf')
-
+        
         lot_count = len(solution)
+        
+        # Calculate diversity metrics
         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
-
+        
+        # Base fitness
         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
+        
+        # STRONG diversity bonus
+        fitness += unique_widths * 2000  # Big bonus for each unique width
+        fitness -= max_repetition * 500   # Penalty for too many of same width
+        fitness += diversity_ratio * 3000 # Bonus for good diversity ratio
+        
+        # Corner evaluation
         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:
+            first_width = solution[0][0]
+            last_width = solution[-1][0]
+            
+            # Penalty for SLHC on corners
+            if first_width <= 10.5:
+                fitness -= 2000
+            if last_width <= 10.5:
+                fitness -= 2000
+            
+            # Bonus for good corners
+            if first_width >= 11.0:
+                fitness += 1000
+            if last_width >= 11.0:
                 fitness += 1000
-            elif diff <= 2.0:
-                fitness += 500
+            
+            # Balance bonus
+            corner_diff = abs(first_width - last_width)
+            if corner_diff < 0.1:
+                fitness += 1500  # Perfect match
+            elif corner_diff <= 1.0:
+                fitness += 1000  # Very good
+            elif corner_diff <= 2.0:
+                fitness += 500   # Good
             else:
-                fitness -= 500
-
-        # Bonus for adjacent SLHC
+                fitness -= 500   # Poor balance
+        
+        # SLHC grouping bonus
         for i in range(len(solution) - 1):
-            if solution[i][0] <= 10.5 and solution[i + 1][0] <= 10.5:
-                fitness += 300
-
-        # Penalty if a corner‐specific width used internally
+            if solution[i][0] <= 10.5 and solution[i+1][0] <= 10.5:
+                fitness += 300  # Adjacent SLHC bonus
+        
+        # Penalize corner-specific widths used internally
         for i in range(1, len(solution) - 1):
             if solution[i][0] in self.corner_specific:
                 fitness -= 200
-
+        
         return fitness
-
+    
     def generate_report(self, solution, stage_width, stage_depth, manual_allocation=None):
-        """Generate a Markdown‐style report summarizing the layout"""
+        """Generate a professional report"""
         if not solution:
             return None
-
-        custom_widths = [f"{w:.1f}m" for w, _ in solution if w not in self.lot_specifications]
-
+        
+        # Check for custom widths
+        custom_widths = []
+        for width, _ in solution:
+            if width not in self.lot_specifications:
+                custom_widths.append(f"{width:.1f}m")
+        
+        # Calculate diversity
         unique_widths = len(set(w for w, _ in solution))
         width_counts = {}
         for w, _ in solution:
             width_counts[w] = width_counts.get(w, 0) + 1
-
+        
+        # Calculate variance
         total_width = sum(w for w, _ in solution)
         variance = total_width - stage_width
-
+        
         report = f"""
 # SUBDIVISION OPTIMIZATION REPORT
 ## Project Analysis for {stage_width}m × {stage_depth}m Stage
@@ -727,66 +896,426 @@ class AdvancedGridOptimizer:
 - **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:
+### LOT DIVERSITY ANALYSIS
+"""
+        
+        # Sort by count to show distribution
+        sorted_widths = sorted(width_counts.items(), key=lambda x: x[1], reverse=True)
+        for width, count in sorted_widths:
             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"
-
+        
+        # Corner analysis
         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
-
----
-*Report generated: {timestamp}*
-""".format(timestamp=datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
-
+            report += f"\n### CORNER ANALYSIS\n"
+            report += f"- **Front Corner**: {solution[0][0]:.1f}m with 3m × 3m splay\n"
+            report += f"- **Rear Corner**: {solution[-1][0]:.1f}m with 3m × 3m splay\n"
+            report += f"- **Balance**: {abs(solution[0][0] - solution[-1][0]):.1f}m difference\n"
+        
+        report += f"\n### DESIGN FEATURES\n"
+        report += f"- Corner splays provide safe sight lines at intersections\n"
+        report += f"- All lots have identical rear alignment for visual consistency\n"
+        report += f"- Diverse lot mix ensures varied streetscape\n"
+        report += f"- SLHC lots grouped for efficient garbage collection\n"
+        
+        report += f"\n---\n*Report generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*"
+        
         return report
-
+    
     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"""
+        """Process a plan image to extract lot information"""
         if not PLAN_READER_AVAILABLE:
-            # Demo mode: return a mock array and mock lot list
+            # Return mock data for demonstration
             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}',
+                    '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
+            
+            # Create a simple preview 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)',
+            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')
+            ax.set_xlim(0, 1)
+            ax.set_ylim(0, 1)
+            ax.axis('off')
+            
+            # Convert plot to numpy array
             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:**
+```
+pip install opencv-python pytesseract pillow pdf2image
+```
+
+**Sample lots generated for demonstration.**
+"""
+            return preview_img, mock_lots, summary
+        
+        try:
+            # Load image
+            if image_path.endswith('.pdf'):
+                # Convert PDF to image
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    images = convert_from_path(image_path, dpi=300)
+                    if images:
+                        # Convert PIL image to numpy array
+                        img = np.array(images[0])
+                    else:
+                        return None, None, "Failed to convert PDF"
+            else:
+                img = cv2.imread(image_path)
+                if img is None:
+                    return None, None, "Failed to load image"
+            
+            # Convert to RGB if needed
+            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)
+            else:
+                img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            
+            # Process image for lot detection
+            gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+            
+            # Detect lot boundaries
+            lots_detected = self.detect_lot_boundaries(gray, img_rgb, confidence)
+            
+            # Extract text using OCR
+            text_data = self.extract_text_from_plan(gray)
+            
+            # Match lots with dimensions
+            lot_data = self.match_lots_with_dimensions(lots_detected, text_data, scale, auto_detect_scale)
+            
+            # Create annotated preview
+            preview_img = self.create_annotated_preview(img_rgb, lot_data)
+            
+            # Create summary
+            summary = f"""
+### Analysis Complete! 
+- **Lots Detected**: {len(lot_data)}
+- **Scale Used**: 1:{scale if not auto_detect_scale else 'Auto-detected'}
+- **Confidence**: {confidence:.0%}
+
+**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
+            
+        except Exception as e:
+            return None, None, f"Error processing plan: {str(e)}"
+    
+    def detect_lot_boundaries(self, gray_img, rgb_img, confidence):
+        """Detect lot boundaries in the plan"""
+        if not PLAN_READER_AVAILABLE:
+            return []
+        
+        lots = []
+        
+        # Apply edge detection
+        edges = cv2.Canny(gray_img, 50, 150)
+        
+        # Find contours
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Filter and process contours
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if area > 1000:  # Minimum area threshold
+                # Approximate polygon
+                epsilon = 0.02 * cv2.arcLength(contour, True)
+                approx = cv2.approxPolyDP(contour, epsilon, True)
+                
+                # Check if shape is roughly rectangular (4-6 vertices)
+                if 4 <= len(approx) <= 6:
+                    x, y, w, h = cv2.boundingRect(contour)
+                    aspect_ratio = float(w) / h
+                    
+                    # Lots typically have aspect ratios between 0.3 and 3.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):
+        """Extract text from plan using OCR"""
+        if not PLAN_READER_AVAILABLE:
+            return []
+        
+        # Preprocess for better OCR
+        _, thresh = cv2.threshold(gray_img, 150, 255, cv2.THRESH_BINARY)
+        
+        # Use Tesseract OCR
+        try:
+            text = pytesseract.image_to_string(thresh)
+            data = pytesseract.image_to_data(thresh, output_type=pytesseract.Output.DICT)
+            
+            # Extract numbers and dimensions
+            text_elements = []
+            for i in range(len(data['text'])):
+                if int(data['conf'][i]) > 0:
+                    text_val = data['text'][i].strip()
+                    # Look for lot numbers (L followed by digits) and dimensions (numbers possibly with 'm')
+                    is_lot_number = text_val.startswith('L') and text_val[1:].isdigit()
+                    is_dimension = text_val.replace('.', '').replace('m', '').isdigit()
+                    
+                    if is_lot_number or is_dimension:
+                        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:
+            return []
+    
+    def match_lots_with_dimensions(self, lots, text_data, scale, auto_detect_scale):
+        """Match detected lots with their dimensions and numbers"""
+        lot_info = []
+        
+        # Simple matching based on proximity
+        for i, lot in enumerate(lots):
+            x, y, w, h = lot['bbox']
+            lot_center = (x + w/2, y + h/2)
+            
+            # Find nearby text
+            lot_number = None
+            frontage = None
+            depth = None
+            
+            for text in text_data:
+                text_center = (text['x'] + text['w']/2, text['y'] + text['h']/2)
+                distance = np.sqrt((lot_center[0] - text_center[0])**2 + 
+                                 (lot_center[1] - text_center[1])**2)
+                
+                # If text is close to lot
+                if distance < max(w, h) * 0.5:
+                    text_val = text['text']
+                    
+                    # Check if it's a lot number or dimension
+                    if text_val.startswith('L') and text_val[1:].isdigit():
+                        lot_number = text_val
+                    # Check if it's a dimension (number possibly followed by 'm')
+                    elif text_val.replace('.', '').replace('m', '').isdigit():
+                        dim_val = float(text_val.replace('m', ''))
+                        # Assign to frontage or depth based on position
+                        if abs(text_center[1] - lot_center[1]) < h * 0.3:
+                            frontage = dim_val
+                        else:
+                            depth = dim_val
+            
+            # If no lot number found, assign sequential
+            if not lot_number:
+                lot_number = f"L{i+1}"
+            
+            # If no dimensions found, estimate from pixel measurements
+            if not frontage:
+                frontage = round(w / scale * 1000, 1)  # Convert to meters
+            if not depth:
+                depth = round(h / scale * 1000, 1)  # Convert to meters
+            
+            # Determine lot type based on frontage
+            if frontage <= 10.5:
+                lot_type = "SLHC"
+            elif frontage <= 14:
+                lot_type = "Standard"
+            else:
+                lot_type = "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
+        try:
+            def get_lot_number(lot_info):
+                lot_num = lot_info['lot_number']
+                if lot_num.startswith('L'):
+                    return int(lot_num[1:])
+                return 999999  # Put non-standard lot numbers at the end
+            
+            lot_info.sort(key=get_lot_number)
+        except:
+            pass
+        
+        return lot_info
+    
+    def create_annotated_preview(self, img, lot_data):
+        """Create preview image with annotations"""
+        if not PLAN_READER_AVAILABLE:
+            return img
+        
+        annotated = img.copy()
+        
+        # Define colors for different lot types
+        colors = {
+            'SLHC': (255, 0, 0),      # Red
+            'Standard': (0, 255, 0),   # Green
+            'Premium': (0, 0, 255)     # Blue
+        }
+        
+        # Draw lot boundaries and labels
+        for lot in lot_data:
+            if 'bbox' in lot:
+                x, y, w, h = lot['bbox']
+                color = colors.get(lot['type'], (128, 128, 128))
+                
+                # Draw rectangle
+                cv2.rectangle(annotated, (x, y), (x + w, y + h), color, 2)
+                
+                # Draw lot number
+                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):
+        """Convert lot data to DataFrame format"""
+        if not lot_data:
+            return pd.DataFrame(columns=["Lot #", "Frontage (m)", "Depth (m)", "Area (m²)", "Type"])
+        
+        df_data = []
+        for lot in lot_data:
+            df_data.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(df_data)
+    
+    def export_lot_data_to_csv(self, df):
+        """Export lot data to CSV format"""
+        if df is None or df.empty:
+            return None
+        
+        csv_buffer = io.StringIO()
+        df.to_csv(csv_buffer, index=False)
+        return csv_buffer.getvalue()
+    
+    def convert_lot_data_to_stage_format(self, df):
+        """Convert lot data to format suitable for optimizer"""
+        if df is None or df.empty:
+            return None, None
+        
+        # Group by frontage and count
+        frontage_counts = {}
+        for _, row in df.iterrows():
+            frontage = float(row['Frontage (m)'])
+            if frontage in frontage_counts:
+                frontage_counts[frontage] += 1
+            else:
+                frontage_counts[frontage] = 1
+        
+        # Calculate total width
+        total_width = sum(f * c for f, c in frontage_counts.items())
+        
+        # Find common depth (mode)
+        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):
+        """Darken a hex color by a factor"""
+        try:
+            hex_color = hex_color.lstrip('#')
+            rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+            darker_rgb = tuple(int(c * factor) for c in rgb)
+            return '#' + ''.join(f'{c:02x}' for c in darker_rgb)
+        except:
+            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
+    ):
+        # Update color scheme
+        optimizer.current_scheme = color_scheme
+        
+        # Collect enabled widths
+        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, None, pd.DataFrame(), "Please select at least one lot width!", "", ""
+        
+        # Run optimization based on strategy
+        if optimization_strategy == "diversity_focus":
+            optimized_solution = optimizer.optimize_with_flexible_corners(
+                stage_width, enabled_widths, allow_custom_corners
+            )
+        else:  # balanced approach
+            optimized_solution = optimizer.optimize_with_corners_diverse(
+                stage_width, enabled_widths, None
+            )
+        
+        # Store current solution for manual adjustment
+        optimizer.current_solution = optimized_solution
+        
+        # Calculate variance for display
+        if optimized_solution:
+            total_width = sum(w for w, _ in optimized_solution)
+            variance = total_width - stage_width
+        else:
+            variance = None
+        
+        # Verify solution
+        if not optimized_solution or abs(sum(w for w, _ in optimized_solution) - stage_width) > 0.001:
+            # Provide suggestions
+            return None, pd.DataFrame(), f"""
+### ❌ Cannot achieve 100% usage