Update app.py

app.py

@@ -1,3 +1,4 @@
+
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -151,9 +152,8 @@ class AdvancedGridOptimizer:
         colors = self.color_schemes[self.current_scheme]
         
         x_pos = 0
-        lot_num = 1
-        
-        # Set up main plot with RPM green background
+        for i, (width, lot_type) in enumerate(solution):
+            # Get base color
         ax1.set_xlim(-5, stage_width + 5)
         # Adjust y-limits for rear laneway
         if self.md_load_type == 'rear':
@@ -292,43 +292,22 @@ class AdvancedGridOptimizer:
             # Add lot information (positioned inside the lot)
             lot_center_y = 8 + lot_height / 2  # Center of the lot
             
-            # Lot number at top of lot interior
-            ax1.text(x_pos + width/2, lot_center_y + lot_height/3, f'L{lot_num}', 
-                    ha='center', va='center', fontsize=16, fontweight='bold', color='white')
-            
-            # Width in middle
+            # Just show width in center (like conventional)
             ax1.text(x_pos + width/2, lot_center_y, 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))
-                spec = self.lot_specifications[closest_width]
-                spec = {**spec, 'type': 'Custom'}
+                    ha='center', va='center', fontsize=16, fontweight='bold', color='white')
             
-            lot_type_text = spec['type']
+            # Only show CORNER label for corner lots - positioned lower
             if is_corner:
-                lot_type_text = "CORNER"
-            
-            # Add build type for MD
-            if self.development_mode == 'medium_density' and 'build' in spec:
-                lot_type_text += f"\n{spec['build']}"
-            
-            # Type label at bottom of lot interior
-            ax1.text(x_pos + width/2, lot_center_y - lot_height/3, lot_type_text,
-                    ha='center', va='center', fontsize=11, 
-                    bbox=dict(boxstyle="round,pad=0.3", facecolor='#545D51', 
-                             edgecolor='white', alpha=0.9), color='white')
+                ax1.text(x_pos + width/2, 8 + lot_height/4, "CORNER",
+                        ha='center', va='center', fontsize=12, 
+                        bbox=dict(boxstyle="round,pad=0.3", facecolor='#545D51', 
+                                 edgecolor='white', alpha=0.9, linewidth=1.5), 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)
+            # Dimension lines - make more visible
+            dim_y = 8 + lot_height + 2  # Just above the lot
+            ax1.plot([x_pos, x_pos + width], [dim_y, dim_y], 'w-', linewidth=1.5, alpha=0.6)
+            ax1.plot([x_pos, x_pos], [dim_y - 1, dim_y + 1], 'w-', linewidth=1.5, alpha=0.6)
+            ax1.plot([x_pos + width, x_pos + width], [dim_y - 1, dim_y + 1], 'w-', linewidth=1.5, alpha=0.6)
             
             # Add garage indicators for rear loaded
             if self.md_load_type == 'rear':
@@ -340,7 +319,6 @@ class AdvancedGridOptimizer:
                 ax1.add_patch(garage)
             
             x_pos += width
-            lot_num += 1
         
         # Add rear alignment line across all lots
         rear_y = 8 + lot_height
@@ -383,12 +361,18 @@ class AdvancedGridOptimizer:
             for i in range(len(solution) - 1):
                 if solution[i][0] <= 10.5 and solution[i+1][0] <= 10.5:
                     slhc_pairs += 1
+            
+            # Set MD-specific variables to avoid reference errors
+            narrow_count = slhc_count
+            wide_count = premium_count
         else:
             # MD metrics
             narrow_count = sum(1 for w, _ in solution if w <= 6.0)
             standard_count = sum(1 for w, _ in solution if 6.0 < w <= 8.0)
             wide_count = sum(1 for w, _ in solution if w > 8.0)
             slhc_pairs = 0  # Not applicable for MD
+            slhc_count = narrow_count
+            premium_count = wide_count
         
         # Calculate actual total width and variance
         total_width = sum(w for w, _ in solution)
@@ -409,9 +393,9 @@ class AdvancedGridOptimizer:
             f"🎯 DIVERSITY: {diversity_score:.0%} ({unique_widths} types)",
             f"📏 GRID VARIANCE: {variance:+.2f}m",
             "",
-            f"{'Narrow (≤6m)' if self.development_mode == 'medium_density' else 'SLHC (≤10.5m)'}: {narrow_count if self.development_mode == 'medium_density' else slhc_count} lots",
+            f"{'Narrow (≤6m)' if self.development_mode == 'medium_density' else 'SLHC (≤10.5m)'}: {narrow_count} lots",
             f"{'Standard (6-8m)' if self.development_mode == 'medium_density' else 'Standard (11-14m)'}: {standard_count} lots",
-            f"{'Wide (>8m)' if self.development_mode == 'medium_density' else 'Premium (>14m)'}: {wide_count if self.development_mode == 'medium_density' else premium_count} lots",
+            f"{'Wide (>8m)' if self.development_mode == 'medium_density' else 'Premium (>14m)'}: {wide_count} lots",
             "",
             f"{'🚗 Access: ' + ('Rear Laneway' if self.md_load_type == 'rear' else 'Front Loaded') if self.development_mode == 'medium_density' else f'🚗 SLHC Pairs: {slhc_pairs}'}",
             yield_text
@@ -513,14 +497,12 @@ class AdvancedGridOptimizer:
         best_solution = None
         best_fitness = -float('inf')
         
-        # For MD, corners don't need to be wider than internal
+        # Ensure corners are at least as wide as smallest internal lot
         if self.development_mode == 'medium_density':
             min_internal = min(internal_widths) if internal_widths else 4.5
-            min_corner_width = base_corner_width - tolerance
         else:
-            # 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)
+        min_corner_width = max(base_corner_width - tolerance, min_internal)
         
         # Try variations of corner widths within tolerance
         variations = np.arange(min_corner_width, 
@@ -538,11 +520,10 @@ class AdvancedGridOptimizer:
                 internal_solution = self.find_exact_solution_with_diversity(internal_width, internal_widths)
                 
                 if internal_solution:
-                    # For conventional, verify no internal lot is wider than corners
-                    if self.development_mode == 'conventional':
-                        max_internal = max(internal_solution) if internal_solution else 0
-                        if max_internal > min(corner1, corner2):
-                            continue
+                    # 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
                     
                     # Build complete solution
                     solution = [(round(corner1, 1), 'corner')]
@@ -577,9 +558,10 @@ class AdvancedGridOptimizer:
         
         # Strategy 2: Try flexible corners if enabled
         if allow_custom_corners and standard_internal:
-            # For MD, try all widths as potential corners
+            # Use appropriate corner bases for each mode
             if self.development_mode == 'medium_density':
-                corner_bases = list(enabled_widths)
+                # For MD, use the largest available widths as corner bases
+                corner_bases = sorted(enabled_widths, reverse=True)[:4]
             else:
                 # For conventional, use traditional corner widths
                 corner_bases = [11.0, 13.3, 14.8, 16.8, 14.0, 16.0]
@@ -602,15 +584,10 @@ class AdvancedGridOptimizer:
         
         # Separate widths by size
         all_widths = sorted(enabled_widths)
+        min_internal_width = min(all_widths) if all_widths else 4.5
         
-        if self.development_mode == 'medium_density':
-            # For MD, any width can be a corner
-            corner_options = all_widths
-            min_internal_width = min(all_widths) if all_widths else 4.5
-        else:
-            # For conventional, maintain hierarchy
-            min_internal_width = min(all_widths)
-            corner_options = [w for w in enabled_widths if w >= max(11.0, min_internal_width)]
+        # 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 if self.development_mode == 'conventional' else min_internal_width, min_internal_width)]
         
         best_solution = None
         best_fitness = -float('inf')
@@ -632,11 +609,10 @@ class AdvancedGridOptimizer:
                 )
                 
                 for internal_widths in internal_solutions:
-                    # For conventional, verify no internal lot is wider than corners
-                    if self.development_mode == 'conventional':
-                        max_internal = max(internal_widths) if internal_widths else 0
-                        if max_internal > min(corner1, corner2):
-                            continue
+                    # 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')]
@@ -651,25 +627,22 @@ class AdvancedGridOptimizer:
                         best_fitness = fitness
                         best_solution = optimized
         
-        # If no good solution, try without strict corner rules
+        # 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]:
-                # For MD, just use the solution as-is
-                if self.development_mode == 'medium_density':
-                    solution = [(w, 'standard') for w in widths]
+                # 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:
-                    # For conventional, ensure corners are among the largest lots
-                    sorted_widths = sorted(widths)
-                    if len(sorted_widths) >= 2:
-                        solution = [(sorted_widths[-1], 'corner')]
-                        solution.extend([(w, 'standard') for w in sorted_widths[:-2]])
-                        solution.append((sorted_widths[-2], 'corner'))
-                    else:
-                        solution = [(w, 'standard') for w in widths]
+                    solution = [(w, 'standard') for w in widths]
                 
                 optimized = self.optimize_lot_grouping(solution)
                 fitness = self.evaluate_solution_with_diversity(optimized, stage_width)
@@ -966,36 +939,40 @@ class AdvancedGridOptimizer:
         fitness -= max_repetition * 500   # Penalty for too many of same width
         fitness += diversity_ratio * 3000 # Bonus for good diversity ratio
         
-        # Mode-specific evaluation
-        if self.development_mode == 'conventional':
-            # Corner evaluation for conventional
-            if len(solution) >= 2:
-                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
-                
-                # 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   # Poor balance
+        # Corner evaluation - apply to both conventional and MD
+        if len(solution) >= 2:
+            first_width = solution[0][0]
+            last_width = solution[-1][0]
+            
+            # Get max internal width
+            internal_widths = [w for w, t in solution[1:-1]]
+            max_internal = max(internal_widths) if internal_widths else 0
+            
+            # Penalty if corners are not wider than internals
+            if first_width <= max_internal:
+                fitness -= 2000
+            if last_width <= max_internal:
+                fitness -= 2000
+            
+            # Bonus for good corners (wider than internals)
+            if first_width > max_internal:
+                fitness += 1000
+            if last_width > max_internal:
+                fitness += 1000
             
+            # 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   # Poor balance
+        
+        # Mode-specific bonuses
+        if self.development_mode == 'conventional':
             # SLHC grouping bonus
             for i in range(len(solution) - 1):
                 if solution[i][0] <= 10.5 and solution[i+1][0] <= 10.5: