Update app.py

app.py

@@ -14,17 +14,6 @@ import io
 import base64
 import tempfile
 
-# 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
@@ -42,6 +31,17 @@ class AdvancedGridOptimizer:
             16.8: {"depths": [30, 32], "type": "Corner-Premium", "squares": "26-32"}
         }
         
+        # Rescode setback requirements
+        self.setback_rules = {
+            'front': 6.0,        # 6m front setback
+            'rear': 6.0,         # 6m rear setback
+            'side': 1.0,         # 1m side setback (single story)
+            'side_2story': 1.5,  # 1.5m side setback (two story)
+            'corner_secondary': 3.0,  # 3m setback on secondary street for corners
+            'garage_front': 5.5,  # 5.5m garage setback from front
+            'alfresco_rear': 3.0  # 3m minimum for alfresco area
+        }
+        
         self.slhc_widths = [8.5, 10.5]
         self.standard_widths = [12.5, 14.0]
         self.premium_widths = [16.0, 18.0]
@@ -93,8 +93,8 @@ class AdvancedGridOptimizer:
         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"""
+    def create_enhanced_visualization(self, solution, stage_width, stage_depth=32, title="Premium Grid Layout", show_variance=None, show_setbacks=True):
+        """Create a clean 2D visualization with corner splays and buildable boundaries"""
         fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(18, 12), gridspec_kw={'height_ratios': [3, 1]}, 
                                       facecolor='#1a1a1a')
         
@@ -134,6 +134,9 @@ class AdvancedGridOptimizer:
         splay_size = 3  # 3m corner splay
         lot_height = 28  # UNIFORM HEIGHT FOR ALL LOTS
         
+        # Track maximum buildable area info
+        max_buildable_areas = []
+        
         for i, (width, lot_type) in enumerate(solution):
             # Get base color
             if width in colors:
@@ -205,6 +208,63 @@ class AdvancedGridOptimizer:
                                  zorder=2)
             ax1.add_patch(glow)
             
+            # Add buildable boundaries if enabled
+            if show_setbacks:
+                # Determine if lot likely has 2 stories
+                two_story = width > 14  # Premium lots likely 2 story
+                side_setback = self.setback_rules['side_2story'] if two_story else self.setback_rules['side']
+                
+                if is_corner:
+                    # Corner lot buildable area
+                    if i == 0:  # First corner
+                        buildable_x = x_pos + max(splay_size + self.setback_rules['corner_secondary'], side_setback)
+                        buildable_y = 8 + self.setback_rules['front']
+                        buildable_width = width - max(splay_size + self.setback_rules['corner_secondary'], side_setback) - side_setback
+                        buildable_height = lot_height - self.setback_rules['front'] - self.setback_rules['rear']
+                    else:  # Last corner
+                        buildable_x = x_pos + side_setback
+                        buildable_y = 8 + self.setback_rules['front']
+                        buildable_width = width - side_setback - max(splay_size + self.setback_rules['corner_secondary'], side_setback)
+                        buildable_height = lot_height - self.setback_rules['front'] - self.setback_rules['rear']
+                else:
+                    # Regular lot buildable area
+                    buildable_x = x_pos + side_setback
+                    buildable_y = 8 + self.setback_rules['front']
+                    buildable_width = width - 2 * side_setback
+                    buildable_height = lot_height - self.setback_rules['front'] - self.setback_rules['rear']
+                
+                # Draw buildable boundary with dotted lines
+                buildable_rect = Rectangle(
+                    (buildable_x, buildable_y),
+                    buildable_width,
+                    buildable_height,
+                    fill=False,
+                    edgecolor='white',
+                    linewidth=1.5,
+                    linestyle='--',
+                    alpha=0.7,
+                    zorder=4
+                )
+                ax1.add_patch(buildable_rect)
+                
+                # Add small label for max house size
+                max_house_area = buildable_width * buildable_height
+                max_buildable_areas.append(max_house_area)
+                
+                # Show dimensions on hover-like annotation
+                ax1.text(buildable_x + buildable_width/2, buildable_y + buildable_height/2,
+                        f'{buildable_width:.1f}×{buildable_height:.1f}m\n({max_house_area:.0f}m²)',
+                        ha='center', va='center', fontsize=8, color='white', alpha=0.5,
+                        bbox=dict(boxstyle="round,pad=0.2", facecolor='black', alpha=0.5))
+                
+                # Add setback dimension indicators
+                # Front setback
+                ax1.plot([x_pos + width*0.1, x_pos + width*0.1], [8, buildable_y], 
+                        'gray', linewidth=0.5, alpha=0.3)
+                ax1.text(x_pos + width*0.1, 8 + self.setback_rules['front']/2, 
+                        f"{self.setback_rules['front']}m", 
+                        ha='right', va='center', fontsize=6, color='gray', alpha=0.5)
+            
             # Add rear alignment line to emphasize equal depth
             rear_y = 8 + lot_height
             ax1.plot([x_pos, x_pos + width], [rear_y, rear_y], 
@@ -253,6 +313,21 @@ class AdvancedGridOptimizer:
                 bbox=dict(boxstyle="round,pad=0.3", facecolor='#1a1a1a', 
                          edgecolor='cyan', alpha=0.8))
         
+        # Add setback legend
+        if show_setbacks:
+            legend_text = (
+                "SETBACK REQUIREMENTS:\n"
+                f"Front: {self.setback_rules['front']}m | Rear: {self.setback_rules['rear']}m\n"
+                f"Side (1 story): {self.setback_rules['side']}m | Side (2 story): {self.setback_rules['side_2story']}m\n"
+                f"Corner secondary street: {self.setback_rules['corner_secondary']}m"
+            )
+            ax1.text(0.02, 0.98, legend_text,
+                    transform=ax1.transAxes,
+                    fontsize=10, color='white', alpha=0.7,
+                    bbox=dict(boxstyle="round,pad=0.5", facecolor='#2a2a2a', 
+                             edgecolor='white', alpha=0.7),
+                    verticalalignment='top')
+        
         # Add stage dimensions
         arrow_props = dict(arrowstyle='<->', color='white', lw=3)
         ax1.annotate('', xy=(0, -6), xytext=(stage_width, -6), arrowprops=arrow_props)
@@ -289,11 +364,21 @@ class AdvancedGridOptimizer:
         variance = total_width - stage_width
         efficiency = "100%" if abs(variance) < 0.001 else f"{(total_width/stage_width)*100:.1f}%"
         
+        # Calculate buildable area stats
+        if max_buildable_areas:
+            avg_buildable = np.mean(max_buildable_areas)
+            min_buildable = min(max_buildable_areas)
+            max_buildable = max(max_buildable_areas)
+            buildable_stats = f"Buildable: {min_buildable:.0f}-{max_buildable:.0f}m² (avg: {avg_buildable:.0f}m²)"
+        else:
+            buildable_stats = "Buildable area calculation pending"
+        
         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"🏠 {buildable_stats}",
             "",
             f"SLHC (≤10.5m): {slhc_count} lots",
             f"Standard (11-14m): {standard_count} lots",
@@ -303,8 +388,8 @@ class AdvancedGridOptimizer:
             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:])
+        col1_text = '\n'.join(metrics_lines[:6])
+        col2_text = '\n'.join(metrics_lines[6:])
         
         ax2.text(0.05, 0.5, col1_text, transform=ax2.transAxes, 
                 fontsize=14, verticalalignment='center', fontweight='bold',
@@ -922,337 +1007,12 @@ class AdvancedGridOptimizer:
         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"- Buildable areas shown with rescode-compliant setbacks\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):
-        """Process a plan image to extract lot information"""
-        if not PLAN_READER_AVAILABLE:
-            # 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}',
-                    'frontage': frontage,
-                    'depth': 32,
-                    'area': frontage * 32,
-                    'type': 'SLHC' if frontage <= 10.5 else 'Standard' if frontage <= 14 else 'Premium'
-                })
-            
-            # 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)', 
-                    ha='center', va='center', fontsize=16, transform=ax.transAxes)
-            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:
@@ -1271,7 +1031,7 @@ def create_advanced_app():
         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
+        allow_custom_corners, optimization_strategy, color_scheme, show_setbacks
     ):
         # Update color scheme
         optimizer.current_scheme = color_scheme
@@ -1329,11 +1089,12 @@ def create_advanced_app():
 3. Try common stage widths: 84m, 105m, 126m
 """, "", ""
         
-        # Create visualizations with variance indicator
+        # Create visualizations with variance indicator and setbacks
         fig_2d = optimizer.create_enhanced_visualization(
             optimized_solution, stage_width, stage_depth,
             "AI-Optimized Diverse Subdivision Layout",
-            show_variance=variance
+            show_variance=variance,
+            show_setbacks=show_setbacks
         )
         
         # Create results table
@@ -1414,7 +1175,7 @@ def create_advanced_app():
         
         return fig_2d, results_df, summary, report, manual_edit_string
     
-    def update_manual_adjustment(manual_widths_text, stage_width, stage_depth, color_scheme):
+    def update_manual_adjustment(manual_widths_text, stage_width, stage_depth, color_scheme, show_setbacks):
         """Update visualization based on manual adjustment"""
         optimizer.current_scheme = color_scheme
         
@@ -1438,7 +1199,8 @@ def create_advanced_app():
         fig = optimizer.create_enhanced_visualization(
             solution, stage_width, stage_depth,
             "Manually Adjusted Layout",
-            show_variance=variance
+            show_variance=variance,
+            show_setbacks=show_setbacks
         )
         
         return fig, feedback
@@ -1483,239 +1245,122 @@ def create_advanced_app():
     ) as demo:
         gr.Markdown("""
         # 🏗️ Advanced AI Grid Cut Optimizer Pro
-        ### AI-Powered Subdivision Planning with Manual Fine-Tuning
+        ### AI-Powered Subdivision Planning with Buildable Boundaries
         """)
         
-        with gr.Tabs() as main_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")
+        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)"
+                    )
                 
-                # Manual adjustment section
-                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"
-                        )
+                gr.Markdown("### 📏 Lot Width Options")
                 
-                with gr.Row():
-                    results_table = gr.DataFrame(label="Lot Distribution Analysis")
+                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.Row():
-                    with gr.Column():
-                        summary_output = gr.Markdown(label="Optimization Summary")
-                    with gr.Column():
-                        report_output = gr.Markdown(label="Professional Report")
+                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.TabItem("📊 Plan Reader"):
-                gr.Markdown("""
-                ## 🏢 AI Plan Reader
-                ### Upload your subdivision plan to automatically extract lot information
+            with gr.Column(scale=1):
+                gr.Markdown("### ⚙️ Advanced Settings")
                 
-                **Workflow:**
-                1. Upload plan → 2. Review/edit extracted data → 3. Send to optimizer → 4. Optimize layout
-                """)
+                allow_custom_corners = gr.Checkbox(
+                    label="🎯 Allow Flexible Corner Widths",
+                    value=True,
+                    info="Enables 13.8m, 13.9m etc. for perfect fits"
+                )
                 
-                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"
-                        )
-                        
-                        # Analysis options
-                        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):
-                        # Preview with annotations
-                        plan_preview = gr.Image(
-                            label="Analyzed Plan Preview",
-                            type="numpy"
-                        )
-                        
-                        analysis_status = gr.Markdown(
-                            value="Upload a plan to begin analysis",
-                            label="Analysis Status"
-                        )
+                show_setbacks = gr.Checkbox(
+                    label="🏠 Show Buildable Boundaries",
+                    value=True,
+                    info="Display maximum house envelope with rescode setbacks"
+                )
                 
-                # Results section
-                gr.Markdown("### 📊 Extracted Lot Data")
+                optimization_strategy = gr.Radio(
+                    ["diversity_focus", "balanced"],
+                    label="Optimization Strategy",
+                    value="diversity_focus",
+                    info="Diversity creates more interesting layouts"
+                )
                 
-                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"
-                        )
+                color_scheme = gr.Radio(
+                    ["modern", "professional", "neon"],
+                    label="🎨 Color Scheme",
+                    value="neon",
+                    info="Neon colors work best with dark background"
+                )
                 
-                # Manual correction section
-                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")
-                    
-                    with gr.Column():
-                        validation_result = gr.Markdown(
-                            label="Data Validation"
-                        )
-                        
-                        export_output = gr.Textbox(
-                            label="CSV Export (Copy and save as .csv file)",
-                            lines=10,
-                            visible=False
-                        )
+                optimize_btn = gr.Button(
+                    "🚀 Optimize with AI", 
+                    variant="primary", 
+                    size="lg",
+                    elem_id="optimize-button"
+                )
+                
+                gr.Markdown("""
+                ### 💡 Quick Tips:
+                - **Buildable Areas**: Dotted lines show max house size
+                - **Setbacks**: Front/Rear: 6m, Side: 1m (1.5m for 2-story)
+                - **Corner Lots**: Extra 3m setback on secondary street
+                - **Manual Adjust**: Edit the result below after optimization
+                """)
+        
+        with gr.Row():
+            plot_2d = gr.Plot(label="2D Layout with Buildable Boundaries")
+        
+        # Manual adjustment section
+        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")
         
         # Wire up the buttons
         optimize_btn.click(
@@ -1725,124 +1370,17 @@ def create_advanced_app():
                 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
+                allow_custom_corners, optimization_strategy, color_scheme, show_setbacks
             ],
             outputs=[plot_2d, results_table, summary_output, report_output, manual_widths]
         )
         
         update_btn.click(
             update_manual_adjustment,
-            inputs=[manual_widths, stage_width, stage_depth, color_scheme],
+            inputs=[manual_widths, stage_width, stage_depth, color_scheme, show_setbacks],
             outputs=[plot_2d, adjustment_feedback]
         )
         
-        # Plan reader functions
-        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)
-            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"
-            
-            # Check for common issues
-            issues = []
-            
-            # Check for missing values
-            if df.isnull().any().any():
-                issues.append("⚠️ Missing values detected")
-            
-            # Check for unrealistic dimensions
-            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")
-            
-            # Check total lots
-            total_lots = len(df)
-            if total_lots < 5:
-                issues.append("ℹ️ Few lots detected - check if all were found")
-            
-            if not issues:
-                return f"✅ Data looks good! {total_lots} lots ready for optimization"
-            else:
-                return "\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²)": [400.0],
-                    "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²)": [400.0],
-                    "Type": ["Standard"]
-                })
-                return pd.concat([df, new_row], ignore_index=True)
-        
-        process_plan_btn.click(
-            process_uploaded_plan,
-            inputs=[plan_upload, scale_input, auto_detect_scale, confidence_threshold],
-            outputs=[plan_preview, extracted_data, analysis_status]
-        )
-        
-        export_btn.click(
-            export_to_csv,
-            inputs=[extracted_data],
-            outputs=[export_output, extraction_summary]
-        )
-        
-        send_to_optimizer_btn.click(
-            send_to_optimizer,
-            inputs=[extracted_data],
-            outputs=[stage_width, stage_depth, extraction_summary]
-        )
-        
-        extracted_data.change(
-            validate_lot_data,
-            inputs=[extracted_data],
-            outputs=[validation_result]
-        )
-        
-        add_lot_btn.click(
-            add_lot_row,
-            inputs=[extracted_data],
-            outputs=[extracted_data]
-        )
-        
     return demo
 
 # Create and launch