Update app.py

app.py

@@ -1318,4 +1318,534 @@ def create_advanced_app():
         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
+### ❌ Cannot achieve 100% usage with selected widths
+
+**Stage Width**: {stage_width}m  
+**Available Widths**: {', '.join([f"{w}m" for w in sorted(enabled_widths)])}
+
+**Try:**
+1. Enable more lot types for flexibility
+2. Enable "Custom Corners" option
+3. Try common stage widths: 84m, 105m, 126m
+""", "", ""
+        
+        # Create visualizations with variance indicator
+        fig_2d = optimizer.create_enhanced_visualization(
+            optimized_solution, stage_width, stage_depth,
+            "AI-Optimized Diverse Subdivision Layout",
+            show_variance=variance
+        )
+        
+        # Create results table
+        width_counts = {}
+        for width, lot_type in optimized_solution:
+            key = f"{width:.1f}m"
+            if key in width_counts:
+                width_counts[key]['count'] += 1
+            else:
+                # Handle both standard and custom widths
+                if width in optimizer.lot_specifications:
+                    spec = optimizer.lot_specifications[width]
+                elif int(width) in optimizer.lot_specifications:
+                    spec = optimizer.lot_specifications[int(width)]
+                else:
+                    # Custom width - find closest
+                    closest = min(optimizer.lot_specifications.keys(), 
+                                key=lambda x: abs(x - width))
+                    spec = optimizer.lot_specifications[closest]
+                    spec = {**spec, 'type': 'Custom', 'squares': 'Custom'}
+                
+                width_counts[key] = {
+                    'count': 1,
+                    'type': spec.get('type', 'Custom'),
+                    'squares': spec.get('squares', 'N/A'),
+                    'area': width * stage_depth
+                }
+        
+        results_data = []
+        for width, info in sorted(width_counts.items()):
+            results_data.append({
+                'Lot Width': width,
+                'Count': info['count'],
+                'Type': info['type'],
+                'Area Each': f"{info['area']:.0f}m²",
+                'Total Width': f"{float(width[:-1]) * info['count']:.1f}m",
+                'Total Area': f"{info['area'] * info['count']:.0f}m²"
+            })
+        
+        results_df = pd.DataFrame(results_data)
+        
+        # Generate report
+        report = optimizer.generate_report(optimized_solution, stage_width, stage_depth, None)
+        
+        # Create summary
+        total_lots = len(optimized_solution)
+        unique_widths = len(set(w for w, _ in optimized_solution))
+        
+        # Count SLHC pairs
+        slhc_pairs = sum(1 for i in range(len(optimized_solution) - 1) 
+                        if optimized_solution[i][0] <= 10.5 and optimized_solution[i+1][0] <= 10.5)
+        
+        # Analyze corners
+        corner_info = "N/A"
+        if len(optimized_solution) >= 2:
+            first = optimized_solution[0][0]
+            last = optimized_solution[-1][0]
+            diff = abs(first - last)
+            
+            if diff < 0.1:
+                corner_info = f"✨ PERFECT ({first:.1f}m × 2)"
+            elif diff <= 1.0:
+                corner_info = f"✅ Excellent ({first:.1f}m + {last:.1f}m)"
+            elif diff <= 2.0:
+                corner_info = f"👍 Good ({first:.1f}m + {last:.1f}m)"
+            else:
+                corner_info = f"⚠️ Unbalanced ({first:.1f}m + {last:.1f}m)"
+        
+        summary = f"""
+**Stage**: {stage_width}m × {stage_depth}m = {stage_width * stage_depth}m²
+**Total Lots**: {total_lots}
+**Unique Lot Types**: {unique_widths}
+**Grid Variance**: {variance:+.2f}m {"✅" if abs(variance) < 0.001 else "⚠️"}
+"""
+        
+        # Convert solution to string for manual editing
+        manual_edit_string = optimizer.solution_to_string(optimized_solution)
+        
+        return fig_2d, results_df, summary, report, manual_edit_string
+    
+    def update_manual_adjustment(manual_widths_text, stage_width, stage_depth, color_scheme):
+        """Update visualization based on manual adjustment"""
+        optimizer.current_scheme = color_scheme
+        
+        # Parse manual widths
+        widths = optimizer.parse_manual_adjustments(manual_widths_text)
+        
+        if not widths:
+            return None, "Please enter lot widths (e.g., '14.0, 8.5, 10.5, 8.5, 14.0')"
+        
+        # Validate and get feedback
+        solution, feedback = optimizer.validate_manual_solution(widths, stage_width)
+        
+        if not solution:
+            return None, feedback
+        
+        # Calculate variance
+        total_width = sum(widths)
+        variance = total_width - stage_width
+        
+        # Create visualization with variance
+        fig = optimizer.create_enhanced_visualization(
+            solution, stage_width, stage_depth,
+            "Manually Adjusted Layout",
+            show_variance=variance
+        )
+        
+        return fig, feedback
+    
+    # Create Gradio interface
+    with gr.Blocks(
+        title="Advanced AI Grid Optimizer", 
+        theme=gr.themes.Base(),
+        css="""
+        .gradio-container {
+            font-family: 'Segoe UI', sans-serif;
+            background: #1a1a1a;
+            color: white;
+        }
+        .gr-button-primary {
+            background: linear-gradient(45deg, #FF073A 30%, #0AEFFF 90%);
+            border: none;
+            box-shadow: 0 3px 5px 2px rgba(255, 7, 58, .3);
+        }
+        h1 {
+            background: linear-gradient(45deg, #FF073A, #0AEFFF);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            text-align: center;
+            font-size: 2.5em;
+        }
+        .gr-form {
+            background: rgba(42, 42, 42, 0.9);
+            border-radius: 10px;
+            padding: 20px;
+            border: 1px solid #444;
+        }
+        .gr-input {
+            background-color: #2a2a2a;
+            color: white;
+            border: 1px solid #444;
+        }
+        .gr-check-radio {
+            background-color: #2a2a2a;
+        }
+        """
+    ) as demo:
+        gr.Markdown("""
+        # 🏗️ Advanced AI Grid Cut Optimizer Pro
+        ### AI-Powered Subdivision Planning with Manual Fine-Tuning
+        """)
+        
+        with gr.Tabs() 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")
+                
+                # 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")
+            
+            with gr.TabItem("📊 Plan Reader"):
+                gr.Markdown("""
+                ## 🏢 AI Plan Reader
+                ### Upload your subdivision plan to automatically extract lot information
+                
+                **Workflow:**
+                1. Upload plan → 2. Review/edit extracted data → 3. Send to optimizer → 4. Optimize layout
+                """)
+                
+                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"
+                        )
+                
+                # Results section
+                gr.Markdown("### 📊 Extracted Lot Data")
+                
+                with gr.Row():
+                    extracted_data = gr.DataFrame(
+                        headers=["Lot #", "Frontage (m)", "Depth (m)", "Area (m²)", "Type"],
+                        label="Detected Lots",
+                        interactive=True
+                    )
+                    
+                    with gr.Column():
+                        extraction_summary = gr.Markdown(
+                            label="Extraction Summary"
+                        )
+                        
+                        export_btn = gr.Button(
+                            "📥 Export to CSV",
+                            variant="secondary"
+                        )
+                        
+                        send_to_optimizer_btn = gr.Button(
+                            "➡️ Send to Optimizer",
+                            variant="primary"
+                        )
+                
+                # 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
+                        )
+        
+        # Wire up the buttons
+        optimize_btn.click(
+            optimize_grid,
+            inputs=[
+                stage_width,
+                stage_depth,
+                enable_8_5, enable_10_5, enable_12_5, enable_14, enable_16, enable_18,
+                enable_corners, enable_11, enable_13_3, enable_14_8, enable_16_8,
+                allow_custom_corners, optimization_strategy, color_scheme
+            ],
+            outputs=[plot_2d, results_table, summary_output, report_output, manual_widths]
+        )
+        
+        update_btn.click(
+            update_manual_adjustment,
+            inputs=[manual_widths, stage_width, stage_depth, color_scheme],
+            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
+if __name__ == "__main__":
+    app = create_advanced_app()
+    app.launch()