Update app.py

app.py

@@ -16,8 +16,8 @@ import tempfile
 
 class AdvancedGridOptimizer:
     def __init__(self):
-        # Standard lot widths and their typical depths
-        self.lot_specifications = {
+        # Conventional lot widths and their typical depths
+        self.conventional_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"},
@@ -31,17 +31,39 @@ class AdvancedGridOptimizer:
             16.8: {"depths": [30, 32], "type": "Corner-Premium", "squares": "26-32"}
         }
         
+        # Medium Density lot specifications
+        self.md_rear_loaded_specifications = {
+            4.5: {"depths": [19, 25, 28], "type": "MD-Rear Load", "squares": "85.5-126", "build": "2/2/1"},
+            6.0: {"depths": [19, 25, 28], "type": "MD-Rear Load", "squares": "114-168", "build": "3/2/2"},
+            7.5: {"depths": [25, 28], "type": "MD-Rear Load", "squares": "187.5-210", "build": "3-4/2/2"}
+        }
+        
+        self.md_front_loaded_specifications = {
+            7.0: {"depths": [21], "type": "MD-Front Load", "squares": "147", "build": "3/2/1"},
+            8.0: {"depths": [21], "type": "MD-Front Load", "squares": "168", "build": "3-4/2/2"},
+            8.5: {"depths": [16], "type": "MD-Front Load", "squares": "136", "build": "3/2/1"},
+            10.5: {"depths": [16], "type": "MD-Front Load", "squares": "168", "build": "3-4/2/2"}
+        }
+        
+        # Set initial lot specifications to conventional
+        self.lot_specifications = self.conventional_lot_specifications
+        
         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]
         
+        # Medium density categories
+        self.md_rear_widths = [4.5, 6.0, 7.5]
+        self.md_front_widths = [7.0, 8.0, 8.5, 10.5]
+        
         # 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 RPM brand colors
         self.color_schemes = {
             'rpm_primary': {
+                # Conventional colors
                 8.5: '#802B2B',    # Burgundy for SLHC
                 10.5: '#AB3838',   # Burgundy 75%
                 12.5: '#216767',   # Teal
@@ -51,9 +73,16 @@ class AdvancedGridOptimizer:
                 11.0: '#4F8585',   # Teal 75%
                 13.3: '#545D51',   # RPM Green 75%
                 14.8: '#697687',   # Blue 75%
-                16.8: '#FFCF6D'    # Yellow 75%
+                16.8: '#FFCF6D',   # Yellow 75%
+                # Medium Density colors
+                4.5: '#6B4C8A',    # Purple for MD
+                6.0: '#8A6BB3',    # Purple 75%
+                7.5: '#9F85C7',    # Purple 50%
+                7.0: '#4A7C7E',    # Teal-Blue for MD Front
+                8.0: '#5A9A9C'     # Teal-Blue 75%
             },
             'rpm_contrast': {
+                # Conventional colors
                 8.5: '#D69C9C',    # Burgundy 50%
                 10.5: '#E2C1B7',   # Burgundy 25%
                 12.5: '#95B5B5',   # Teal 50%
@@ -63,9 +92,16 @@ class AdvancedGridOptimizer:
                 11.0: '#D6E3E3',   # Teal 25%
                 13.3: '#B6B8B2',   # RPM Green 25%
                 14.8: '#CCD7E4',   # Blue 25%
-                16.8: '#FFEFCE'    # Yellow 25%
+                16.8: '#FFEFCE',   # Yellow 25%
+                # Medium Density colors
+                4.5: '#B5A6C5',    # Purple 50%
+                6.0: '#C7BDD6',    # Purple 25%
+                7.5: '#DDD6E8',    # Purple 15%
+                7.0: '#8FB8BA',    # Teal-Blue 50%
+                8.0: '#B3D0D2'     # Teal-Blue 25%
             },
             'rpm_monochrome': {
+                # All widths use grayscale
                 8.5: '#2E3E2F',    # RPM Green 100%
                 10.5: '#545D51',   # RPM Green 75%
                 12.5: '#80857B',   # RPM Green 50%
@@ -75,16 +111,40 @@ class AdvancedGridOptimizer:
                 11.0: '#D1D3D4',   # Black 25%
                 13.3: '#216767',   # Teal (accent)
                 14.8: '#415B6E',   # Blue (accent)
-                16.8: '#FF8E3C'    # Yellow (accent)
+                16.8: '#FF8E3C',   # Yellow (accent)
+                # Medium Density
+                4.5: '#4A4B4D',    # Dark gray
+                6.0: '#6B6C6E',    # Medium gray
+                7.5: '#8C8D8F',    # Light gray
+                7.0: '#5C5D5F',    # Gray
+                8.0: '#7D7E80'     # Light gray
             }
         }
         
         self.current_scheme = 'rpm_primary'
         self.current_solution = None  # Store current AI solution
+        self.development_mode = 'conventional'  # conventional or medium_density
+        self.md_load_type = 'front'  # front or rear
+    
+    def set_development_mode(self, mode, load_type=None):
+        """Set the development mode and update lot specifications"""
+        self.development_mode = mode
+        if mode == 'medium_density':
+            if load_type == 'rear':
+                self.lot_specifications = self.md_rear_loaded_specifications
+                self.md_load_type = 'rear'
+            else:
+                self.lot_specifications = self.md_front_loaded_specifications
+                self.md_load_type = 'front'
+        else:
+            self.lot_specifications = self.conventional_lot_specifications
+            self.md_load_type = 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"""
-        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(18, 12), gridspec_kw={'height_ratios': [3, 1]}, 
+        """Create a clean 2D visualization with corner splays and optional laneway"""
+        # Adjust figure size for laneway if needed
+        fig_height = 14 if self.md_load_type == 'rear' else 12
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(18, fig_height), gridspec_kw={'height_ratios': [3, 1]}, 
                                       facecolor='#2E3E2F')
         
         # Main visualization
@@ -95,20 +155,27 @@ class AdvancedGridOptimizer:
         
         # Set up main plot with RPM green background
         ax1.set_xlim(-5, stage_width + 5)
-        ax1.set_ylim(-10, 50)
+        # Adjust y-limits for rear laneway
+        if self.md_load_type == 'rear':
+            ax1.set_ylim(-10, 60)  # Extended for laneway
+        else:
+            ax1.set_ylim(-10, 50)
         ax1.set_facecolor('#2E3E2F')
         
         # Add title with variance if provided
         if show_variance is not None:
             variance_color = '#216767' if abs(show_variance) < 0.001 else '#802B2B'
-            title_text = f"{title}\nGrid Variance: {show_variance:+.1f}m"
+            mode_text = "MD " if self.development_mode == 'medium_density' else ""
+            load_text = f"({self.md_load_type.title()} Loaded) " if self.md_load_type else ""
+            title_text = f"{mode_text}{load_text}{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')
         
         # Add subtle gradient background
         gradient = np.linspace(0.3, 0.1, 100).reshape(1, -1)
-        ax1.imshow(gradient, extent=[-5, stage_width + 5, -10, 50], aspect='auto', 
+        y_max = 60 if self.md_load_type == 'rear' else 50
+        ax1.imshow(gradient, extent=[-5, stage_width + 5, -10, y_max], aspect='auto', 
                    cmap='Greys', alpha=0.3, zorder=0)
         
         # Add street with label
@@ -119,17 +186,45 @@ class AdvancedGridOptimizer:
         ax1.text(stage_width/2, -2, 'STREET', ha='center', va='center', 
                 fontsize=20, color='white', fontweight='bold')
         
-        # Draw lots with corner splays - FIXED ALIGNMENT
+        # Draw lots with corner splays
         splay_size = 3  # 3m corner splay
-        lot_height = 28  # UNIFORM HEIGHT FOR ALL LOTS
+        
+        # Get appropriate depth for current mode
+        if self.development_mode == 'medium_density':
+            # Use first available depth for MD lots
+            lot_height = 28  # Default
+            for width, _ in solution:
+                if width in self.lot_specifications:
+                    lot_height = self.lot_specifications[width]['depths'][0]
+                    break
+        else:
+            lot_height = 28  # Standard height for conventional
+        
+        # Add rear laneway if rear loaded MD
+        if self.md_load_type == 'rear':
+            laneway_y = 8 + lot_height
+            laneway = Rectangle((-5, laneway_y), stage_width + 10, 7, 
+                              facecolor='#3A3A3A', alpha=0.9, zorder=1,
+                              edgecolor='#FFCF6D', linewidth=2, linestyle='--')
+            ax1.add_patch(laneway)
+            ax1.text(stage_width/2, laneway_y + 3.5, 'REAR LANEWAY (7m)', 
+                    ha='center', va='center', fontsize=16, color='#FFCF6D', 
+                    fontweight='bold', alpha=0.9)
         
         for i, (width, lot_type) in enumerate(solution):
             # 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]
+                # Use MD colors if in MD mode
+                if self.development_mode == 'medium_density':
+                    if width <= 6.0:
+                        base_color = colors.get(4.5, '#6B4C8A')
+                    else:
+                        base_color = colors.get(7.0, '#4A7C7E')
+                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)
@@ -139,14 +234,14 @@ class AdvancedGridOptimizer:
             edge_color = 'white'
             linewidth = 4.0 if is_corner else 3.0
             
-            # Create lot shape with SAME HEIGHT for all lots
-            if is_corner:
-                # Corner lot with splay - using same height
+            # Create lot shape with appropriate height
+            if is_corner and self.development_mode == 'conventional':
+                # Corner lot with splay for conventional only
                 if i == 0:  # First corner
                     vertices = [
                         (x_pos + splay_size, 8),  # Start after splay
                         (x_pos + width, 8),
-                        (x_pos + width, 8 + lot_height),  # SAME HEIGHT
+                        (x_pos + width, 8 + lot_height),
                         (x_pos, 8 + lot_height),  # Straight rear
                         (x_pos, 8 + splay_size)   # Splay corner
                     ]
@@ -155,7 +250,7 @@ class AdvancedGridOptimizer:
                         (x_pos, 8),
                         (x_pos + width - splay_size, 8),
                         (x_pos + width, 8 + splay_size),  # Splay corner
-                        (x_pos + width, 8 + lot_height),  # SAME HEIGHT
+                        (x_pos + width, 8 + lot_height),
                         (x_pos, 8 + lot_height)
                     ]
                 
@@ -175,7 +270,7 @@ class AdvancedGridOptimizer:
                     ax1.plot([x_pos + width - splay_size, x_pos + width], 
                             [8, 8 + splay_size], 'white', linewidth=2, alpha=0.8)
             else:
-                # Regular lot with SAME HEIGHT
+                # Regular lot (or MD corner without splay)
                 lot = FancyBboxPatch((x_pos, 8), width, lot_height,
                                     boxstyle="round,pad=0.1",
                                     facecolor=face_color, 
@@ -184,7 +279,7 @@ class AdvancedGridOptimizer:
                                     zorder=3)
                 ax1.add_patch(lot)
             
-            # Add subtle glow (same for all)
+            # Add subtle glow
             glow = FancyBboxPatch((x_pos - 0.2, 7.8), width + 0.4, lot_height + 0.4,
                                  boxstyle="round,pad=0.15",
                                  facecolor='none',
@@ -194,16 +289,13 @@ class AdvancedGridOptimizer:
                                  zorder=2)
             ax1.add_patch(glow)
             
-            # 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='--')
-            
             # Add lot information (positioned consistently)
-            ax1.text(x_pos + width/2, 40, f'L{lot_num}', 
+            info_y_base = 48 if self.md_load_type == 'rear' else 40
+            
+            ax1.text(x_pos + width/2, info_y_base, 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', 
+            ax1.text(x_pos + width/2, info_y_base - 5, f'{width:.1f}m', 
                     ha='center', va='center', fontsize=14, fontweight='bold', color='white')
             
             # Lot type
@@ -218,10 +310,14 @@ class AdvancedGridOptimizer:
                 spec = {**spec, 'type': 'Custom'}
             
             lot_type_text = spec['type']
-            if is_corner:
+            if is_corner and self.development_mode == 'conventional':
                 lot_type_text = "CORNER"
             
-            ax1.text(x_pos + width/2, 23, lot_type_text,
+            # Add build type for MD
+            if self.development_mode == 'medium_density' and 'build' in spec:
+                lot_type_text += f"\n{spec['build']}"
+            
+            ax1.text(x_pos + width/2, info_y_base - 17, 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')
@@ -231,16 +327,27 @@ class AdvancedGridOptimizer:
             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)
             
+            # Add garage indicators for rear loaded
+            if self.md_load_type == 'rear':
+                # Small garage icon at rear
+                garage_y = 8 + lot_height - 6
+                garage = Rectangle((x_pos + width/2 - 1.5, garage_y), 3, 5,
+                                 facecolor='#636466', edgecolor='white', 
+                                 linewidth=1, alpha=0.8, zorder=4)
+                ax1.add_patch(garage)
+            
             x_pos += width
             lot_num += 1
         
         # Add rear alignment line across all lots
-        ax1.plot([0, stage_width], [8 + lot_height, 8 + lot_height], 
-                '#216767', 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='#216767', alpha=0.8,
-                bbox=dict(boxstyle="round,pad=0.3", facecolor='#2E3E2F', 
-                         edgecolor='#216767', alpha=0.8))
+        rear_y = 8 + lot_height
+        if self.md_load_type != 'rear':  # Don't show if laneway present
+            ax1.plot([0, stage_width], [rear_y, rear_y], 
+                    '#216767', linewidth=2, alpha=0.8, linestyle='-')
+            ax1.text(stage_width/2, rear_y + 1, 'REAR ALIGNMENT LINE', 
+                    ha='center', va='bottom', fontsize=12, color='#216767', alpha=0.8,
+                    bbox=dict(boxstyle="round,pad=0.3", facecolor='#2E3E2F', 
+                             edgecolor='#216767', alpha=0.8))
         
         # Add stage dimensions
         arrow_props = dict(arrowstyle='<->', color='white', lw=3)
@@ -263,33 +370,48 @@ class AdvancedGridOptimizer:
         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
-        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
+        if self.development_mode == 'conventional':
+            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
+            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
+        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
         
         # 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}%"
         
+        # Calculate yield
+        if self.development_mode == 'medium_density':
+            # Assume potential for duplex on lots ≥ 7m
+            potential_dwellings = sum(2 if w >= 7.0 else 1 for w, _ in solution)
+            yield_text = f"🏘️ Potential Dwellings: {potential_dwellings}"
+        else:
+            yield_text = f"💰 Revenue: ${total_lots * 0.5:.1f}M - ${total_lots * 1.2:.1f}M"
+        
         metrics_lines = [
             f"📊 TOTAL LOTS: {total_lots}",
             f"📐 LAND EFFICIENCY: {efficiency}",
             f"🎯 DIVERSITY: {diversity_score:.0%} ({unique_widths} types)",
             f"📏 GRID VARIANCE: {variance:+.2f}m",
             "",
-            f"SLHC (≤10.5m): {slhc_count} lots",
-            f"Standard (11-14m): {standard_count} lots",
-            f"Premium (>14m): {premium_count} lots",
+            f"{'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"{'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"🚗 SLHC Pairs: {slhc_pairs}",
-            f"💰 Revenue: ${total_lots * 0.5:.1f}M - ${total_lots * 1.2:.1f}M"
+            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
         ]
         
         col1_text = '\n'.join(metrics_lines[:5])
@@ -358,12 +480,14 @@ class AdvancedGridOptimizer:
             feedback = f"⚠️ Grid is {-variance:.2f}m too narrow. Add {-variance:.2f}m total width."
         
         # Add suggestions if not perfect
+        min_width = 4.5 if self.development_mode == 'medium_density' else 8.5
+        
         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:  # Minimum viable width
+                    if w - variance >= min_width:  # Minimum viable width
                         suggestions.append(f"L{i+1}: reduce from {w:.1f}m to {w-variance:.1f}m")
                 if suggestions:
                     feedback += f"\n\nSuggestions:\n" + "\n".join(suggestions[:3])
@@ -381,54 +505,19 @@ class AdvancedGridOptimizer:
             return ""
         return ", ".join([f"{w:.1f}" for w, _ in solution])
     
-    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')
         
-        # 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)
+        # For MD, corners don't need to be wider than internal
+        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)
         
         # Try variations of corner widths within tolerance
         variations = np.arange(min_corner_width, 
@@ -446,10 +535,11 @@ class AdvancedGridOptimizer:
                 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
+                    # 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
                     
                     # Build complete solution
                     solution = [(round(corner1, 1), 'corner')]
@@ -484,8 +574,14 @@ class AdvancedGridOptimizer:
         
         # Strategy 2: Try flexible corners if enabled
         if allow_custom_corners and standard_internal:
-            # Try variations around each corner-suitable width
-            for base_width in [11.0, 13.3, 14.8, 16.8, 14.0, 16.0]:
+            # For MD, try all widths as potential corners
+            if self.development_mode == 'medium_density':
+                corner_bases = list(enabled_widths)
+            else:
+                # For conventional, use traditional corner widths
+                corner_bases = [11.0, 13.3, 14.8, 16.8, 14.0, 16.0]
+            
+            for base_width in corner_bases:
                 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
@@ -503,10 +599,15 @@ class AdvancedGridOptimizer:
         
         # 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)]
+        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)]
         
         best_solution = None
         best_fitness = -float('inf')
@@ -528,10 +629,11 @@ class AdvancedGridOptimizer:
                 )
                 
                 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
+                    # 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
                     
                     # Build complete solution
                     solution = [(corner1, 'corner')]
@@ -539,31 +641,34 @@ class AdvancedGridOptimizer:
                     solution.append((corner2, 'corner'))
                     
                     # Optimize arrangement
-                    optimized = self.optimize_slhc_grouping(solution)
+                    optimized = self.optimize_lot_grouping(solution)
                     fitness = self.evaluate_solution_with_diversity(optimized, stage_width)
                     
                     if fitness > best_fitness:
                         best_fitness = fitness
                         best_solution = optimized
         
-        # If no good solution, try without strict corner rules but maintain size hierarchy
+        # If no good solution, try without strict corner rules
         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:
+                # For MD, just use the solution as-is
+                if self.development_mode == 'medium_density':
                     solution = [(w, 'standard') for w in widths]
+                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]
                 
-                optimized = self.optimize_slhc_grouping(solution)
+                optimized = self.optimize_lot_grouping(solution)
                 fitness = self.evaluate_solution_with_diversity(optimized, stage_width)
                 
                 if fitness > best_fitness:
@@ -572,6 +677,52 @@ class AdvancedGridOptimizer:
         
         return best_solution
     
+    def optimize_lot_grouping(self, lots):
+        """Optimize lot arrangement based on development mode"""
+        if self.development_mode == 'medium_density':
+            return self.optimize_md_grouping(lots)
+        else:
+            return self.optimize_slhc_grouping(lots)
+    
+    def optimize_md_grouping(self, lots):
+        """Optimize lot arrangement for medium density"""
+        if not lots or len(lots) <= 1:
+            return lots
+        
+        # Separate lots by width
+        narrow_lots = []  # 4.5-6m
+        medium_lots = []  # 7-8m
+        wide_lots = []    # >8m
+        
+        for width, lot_type in lots:
+            if width <= 6.0:
+                narrow_lots.append((width, lot_type))
+            elif width <= 8.0:
+                medium_lots.append((width, lot_type))
+            else:
+                wide_lots.append((width, lot_type))
+        
+        # Build optimized layout
+        optimized = []
+        
+        # For rear loaded, group similar widths for efficient laneway access
+        if self.md_load_type == 'rear':
+            # Group narrow lots together
+            optimized.extend(narrow_lots)
+            optimized.extend(medium_lots)
+            optimized.extend(wide_lots)
+        else:
+            # For front loaded, alternate sizes for variety
+            while narrow_lots or medium_lots or wide_lots:
+                if wide_lots:
+                    optimized.append(wide_lots.pop(0))
+                if narrow_lots:
+                    optimized.append(narrow_lots.pop(0))
+                if medium_lots:
+                    optimized.append(medium_lots.pop(0))
+        
+        return optimized
+    
     def find_diverse_combinations(self, target_width, available_widths, max_solutions=20):
         """Find combinations that maximize diversity"""
         all_solutions = []
@@ -678,7 +829,7 @@ class AdvancedGridOptimizer:
                 current.pop()
     
     def optimize_slhc_grouping(self, lots):
-        """Optimize lot arrangement with sophisticated rules"""
+        """Optimize lot arrangement with sophisticated rules for conventional"""
         if not lots or len(lots) <= 1:
             return lots
         
@@ -812,43 +963,56 @@ class AdvancedGridOptimizer:
         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_width = solution[0][0]
-            last_width = solution[-1][0]
+        # 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
             
-            # Penalty for SLHC on corners
-            if first_width <= 10.5:
-                fitness -= 2000
-            if last_width <= 10.5:
-                fitness -= 2000
+            # 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  # Adjacent SLHC bonus
             
-            # Bonus for good corners
-            if first_width >= 11.0:
-                fitness += 1000
-            if last_width >= 11.0:
-                fitness += 1000
+            # Penalize corner-specific widths used internally
+            for i in range(1, len(solution) - 1):
+                if solution[i][0] in self.corner_specific:
+                    fitness -= 200
+        else:
+            # MD-specific bonuses
+            if self.md_load_type == 'rear':
+                # Bonus for grouping similar widths (efficient laneway access)
+                for i in range(len(solution) - 1):
+                    if abs(solution[i][0] - solution[i+1][0]) < 1.5:
+                        fitness += 200
             
-            # 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
-        
-        # 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  # 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
+            # Bonus for potential duplex lots (≥7m)
+            duplex_count = sum(1 for w, _ in solution if w >= 7.0)
+            fitness += duplex_count * 500
         
         return fitness
     
@@ -873,11 +1037,16 @@ class AdvancedGridOptimizer:
         total_width = sum(w for w, _ in solution)
         variance = total_width - stage_width
         
+        # Mode-specific title
+        mode_text = "MEDIUM DENSITY " if self.development_mode == 'medium_density' else ""
+        load_text = f"({self.md_load_type.upper()} LOADED) " if self.md_load_type else ""
+        
         report = f"""
-# SUBDIVISION OPTIMIZATION REPORT
+# {mode_text}{load_text}SUBDIVISION OPTIMIZATION REPORT
 ## Project Analysis for {stage_width}m × {stage_depth}m Stage
 
 ### EXECUTIVE SUMMARY
+- **Development Type**: {self.development_mode.replace('_', ' ').title()}
 - **Total Lots**: {len(solution)}
 - **Unique Lot Types**: {unique_widths}
 - **Land Efficiency**: {"100%" if abs(variance) < 0.001 else f"{(total_width/stage_width)*100:.1f}%"}
@@ -885,32 +1054,49 @@ 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 ""}
-
-### LOT DIVERSITY ANALYSIS
 """
         
+        # Add MD-specific info
+        if self.development_mode == 'medium_density':
+            potential_dwellings = sum(2 if w >= 7.0 else 1 for w, _ in solution)
+            density = potential_dwellings / (stage_width * stage_depth / 10000)  # per hectare
+            report += f"- **Potential Dwellings**: {potential_dwellings} ({density:.0f} dwellings/ha)\n"
+            report += f"- **Access Type**: {'Rear Laneway (7m)' if self.md_load_type == 'rear' else 'Front Loaded'}\n"
+        
+        report += f"\n### LOT DIVERSITY ANALYSIS\n"
+        
         # 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"
+                build_info = f" [{spec.get('build', 'N/A')}]" if 'build' in spec else ""
+                report += f"- **{width:.1f}m** × {count} ({percentage:.1f}%): {spec['type']}{build_info}\n"
             else:
                 report += f"- **{width:.1f}m** × {count} ({percentage:.1f}%): Custom Width\n"
         
-        # Corner analysis
-        if len(solution) >= 2:
+        # Corner analysis (only for conventional)
+        if self.development_mode == 'conventional' and len(solution) >= 2:
             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"
+        if self.development_mode == 'medium_density':
+            if self.md_load_type == 'rear':
+                report += f"- 7m rear laneway provides vehicle access and services\n"
+                report += f"- Garages positioned at rear for better street presentation\n"
+            else:
+                report += f"- Front loaded design with integrated garages\n"
+            report += f"- Compact lots maximize dwelling yield\n"
+            report += f"- Potential for duplex/triplex on wider lots (≥7m)\n"
+        else:
+            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')}*"
         
@@ -929,30 +1115,68 @@ class AdvancedGridOptimizer:
 def create_advanced_app():
     optimizer = AdvancedGridOptimizer()
     
+    def update_available_widths(development_mode, md_load_type):
+        """Update the available width options based on development mode"""
+        if development_mode == "Medium Density":
+            if md_load_type == "Rear Loaded":
+                # Rear loaded MD widths
+                return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+            else:
+                # Front loaded MD widths
+                return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+        else:
+            # Conventional widths
+            return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    
     def optimize_grid(
         stage_width,
         stage_depth,
+        development_mode,
+        md_load_type,
+        # Conventional widths
         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,
+        # MD rear widths
+        enable_4_5, enable_6_0, enable_7_5,
+        # MD front widths
+        enable_7_0, enable_8_0, enable_md_8_5, enable_md_10_5,
         allow_custom_corners, color_scheme
     ):
+        # Update optimizer mode
+        if development_mode == "Medium Density":
+            optimizer.set_development_mode('medium_density', 'rear' if md_load_type == "Rear Loaded" else 'front')
+        else:
+            optimizer.set_development_mode('conventional')
+        
         # Update color scheme
         optimizer.current_scheme = color_scheme
         
-        # Collect enabled widths
+        # Collect enabled widths based on mode
         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 development_mode == "Conventional Land":
+            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)
+        else:
+            if md_load_type == "Rear Loaded":
+                if enable_4_5: enabled_widths.append(4.5)
+                if enable_6_0: enabled_widths.append(6.0)
+                if enable_7_5: enabled_widths.append(7.5)
+            else:
+                if enable_7_0: enabled_widths.append(7.0)
+                if enable_8_0: enabled_widths.append(8.0)
+                if enable_md_8_5: enabled_widths.append(8.5)
+                if enable_md_10_5: enabled_widths.append(10.5)
         
         if not enabled_widths:
             return None, None, pd.DataFrame(), "Please select at least one lot width!", "", ""
@@ -974,23 +1198,33 @@ def create_advanced_app():
         
         # Verify solution
         if not optimized_solution or abs(sum(w for w, _ in optimized_solution) - stage_width) > 0.001:
-            # Provide suggestions
+            # Provide mode-specific suggestions
+            if development_mode == "Medium Density":
+                width_suggestions = "4.5m, 6m, 7.5m" if md_load_type == "Rear Loaded" else "7m, 8m, 8.5m, 10.5m"
+                stage_suggestions = "54m, 72m, 90m"
+            else:
+                width_suggestions = "8.5m-18m plus corner widths"
+                stage_suggestions = "84m, 105m, 126m"
+            
             return None, pd.DataFrame(), f"""
 ### ❌ Cannot achieve 100% usage with selected widths
 
 **Stage Width**: {stage_width}m  
+**Mode**: {development_mode} {f'({md_load_type})' if development_mode == 'Medium Density' else ''}
 **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
+3. Try common stage widths: {stage_suggestions}
+4. Available widths: {width_suggestions}
 """, "", ""
         
         # Create visualizations with variance indicator
+        title = f"{'MD ' if development_mode == 'Medium Density' else ''}Grid Cut Optimization"
         fig_2d = optimizer.create_enhanced_visualization(
             optimized_solution, stage_width, stage_depth,
-            "RPM Grid Cut Optimization",
+            title,
             show_variance=variance
         )
         
@@ -1017,19 +1251,23 @@ def create_advanced_app():
                     'count': 1,
                     'type': spec.get('type', 'Custom'),
                     'squares': spec.get('squares', 'N/A'),
-                    'area': width * stage_depth
+                    'area': width * stage_depth,
+                    'build': spec.get('build', 'N/A')
                 }
         
         results_data = []
         for width, info in sorted(width_counts.items()):
-            results_data.append({
+            row_data = {
                 '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²"
-            })
+            }
+            if development_mode == "Medium Density":
+                row_data['Build Type'] = info['build']
+            results_data.append(row_data)
         
         results_df = pd.DataFrame(results_data)
         
@@ -1040,31 +1278,30 @@ def create_advanced_app():
         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 development_mode == "Medium Density":
+            # MD specific metrics
+            potential_dwellings = sum(2 if w >= 7.0 else 1 for w, _ in optimized_solution)
+            density = potential_dwellings / (stage_width * stage_depth / 10000)
             
-            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"""
+            summary = f"""
 **Stage**: {stage_width}m × {stage_depth}m = {stage_width * stage_depth}m²
+**Development**: {development_mode} ({md_load_type})
 **Total Lots**: {total_lots}
+**Potential Dwellings**: {potential_dwellings} ({density:.0f}/ha)
 **Unique Lot Types**: {unique_widths}
 **Grid Variance**: {variance:+.2f}m {"✅" if abs(variance) < 0.001 else "⚠️"}
+"""
+        else:
+            # Conventional metrics
+            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)
+            
+            summary = f"""
+**Stage**: {stage_width}m × {stage_depth}m = {stage_width * stage_depth}m²
+**Total Lots**: {total_lots}
+**Unique Lot Types**: {unique_widths}
+**SLHC Pairs**: {slhc_pairs}
+**Grid Variance**: {variance:+.2f}m {"✅" if abs(variance) < 0.001 else "⚠️"}
 """
         
         # Convert solution to string for manual editing
@@ -1072,8 +1309,14 @@ 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, development_mode, md_load_type, color_scheme):
         """Update visualization based on manual adjustment"""
+        # Set mode
+        if development_mode == "Medium Density":
+            optimizer.set_development_mode('medium_density', 'rear' if md_load_type == "Rear Loaded" else 'front')
+        else:
+            optimizer.set_development_mode('conventional')
+        
         optimizer.current_scheme = color_scheme
         
         # Parse manual widths
@@ -1160,7 +1403,23 @@ def create_advanced_app():
         with gr.Row():
             with gr.Column(scale=1):
                 with gr.Group():
-                    gr.Markdown("### 📐 Stage Dimensions")
+                    gr.Markdown("### 📐 Stage Configuration")
+                    
+                    development_mode = gr.Radio(
+                        ["Conventional Land", "Medium Density"],
+                        label="🏘️ Development Mode",
+                        value="Conventional Land",
+                        info="Select the type of development"
+                    )
+                    
+                    md_load_type = gr.Radio(
+                        ["Front Loaded", "Rear Loaded"],
+                        label="🚗 MD Access Type",
+                        value="Front Loaded",
+                        visible=False,
+                        info="Rear loaded includes 7m laneway"
+                    )
+                    
                     stage_width = gr.Number(
                         label="Stage Width (m)", 
                         value=105.0,
@@ -1174,7 +1433,8 @@ def create_advanced_app():
                 
                 gr.Markdown("### 📏 Lot Width Options")
                 
-                with gr.Group():
+                # Conventional widths group
+                with gr.Group(visible=True) as conventional_group:
                     gr.Markdown("**Standard Widths**")
                     with gr.Row():
                         enable_8_5 = gr.Checkbox(label="8.5m SLHC", value=True)
@@ -1184,8 +1444,7 @@ def create_advanced_app():
                         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,
@@ -1197,6 +1456,21 @@ def create_advanced_app():
                     with gr.Row():
                         enable_14_8 = gr.Checkbox(label="14.8m", value=True)
                         enable_16_8 = gr.Checkbox(label="16.8m", value=True)
+                
+                # MD Rear Loaded widths
+                with gr.Group(visible=False) as md_rear_group:
+                    gr.Markdown("**MD Rear Loaded Widths**")
+                    enable_4_5 = gr.Checkbox(label="4.5m (2/2/1)", value=True)
+                    enable_6_0 = gr.Checkbox(label="6.0m (3/2/2)", value=True)
+                    enable_7_5 = gr.Checkbox(label="7.5m (3-4/2/2)", value=True)
+                
+                # MD Front Loaded widths
+                with gr.Group(visible=False) as md_front_group:
+                    gr.Markdown("**MD Front Loaded Widths**")
+                    enable_7_0 = gr.Checkbox(label="7.0m (3/2/1)", value=True)
+                    enable_8_0 = gr.Checkbox(label="8.0m (3-4/2/2)", value=True)
+                    enable_md_8_5 = gr.Checkbox(label="8.5m (3/2/1)", value=True)
+                    enable_md_10_5 = gr.Checkbox(label="10.5m (3-4/2/2)", value=True)
             
             with gr.Column(scale=1):
                 gr.Markdown("### ⚙️ Settings")
@@ -1223,14 +1497,14 @@ def create_advanced_app():
                 
                 gr.Markdown("""
                 ### 💡 Quick Tips:
-                - **Corner Lots**: Always wider than internals
+                - **Conventional**: Traditional lots with corner splays
+                - **Medium Density**: Compact lots for higher yield
+                - **Rear Loaded**: Includes 7m laneway visualization
                 - **Grid Variance**: Shows if layout is perfect (0.0m)
-                - **Manual Adjust**: Edit the result below after optimization
-                - **Diversity Focus**: Maximizes lot variety
                 """)
         
         with gr.Row():
-            plot_2d = gr.Plot(label="2D Layout with Corner Splays")
+            plot_2d = gr.Plot(label="2D Layout Visualization")
         
         # Manual adjustment section
         gr.Markdown("### ✏️ Fine-Tune Result")
@@ -1258,14 +1532,46 @@ def create_advanced_app():
             with gr.Column():
                 report_output = gr.Markdown(label="Professional Report")
         
-        # Wire up the buttons
+        # Wire up development mode changes
+        def handle_mode_change(mode):
+            if mode == "Medium Density":
+                return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+            else:
+                return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+        
+        def handle_md_type_change(md_type):
+            if md_type == "Rear Loaded":
+                return gr.update(visible=True), gr.update(visible=False)
+            else:
+                return gr.update(visible=False), gr.update(visible=True)
+        
+        development_mode.change(
+            handle_mode_change,
+            inputs=[development_mode],
+            outputs=[md_load_type, conventional_group, md_rear_group, md_front_group]
+        )
+        
+        md_load_type.change(
+            handle_md_type_change,
+            inputs=[md_load_type],
+            outputs=[md_rear_group, md_front_group]
+        )
+        
+        # Wire up the optimize button
         optimize_btn.click(
             optimize_grid,
             inputs=[
                 stage_width,
                 stage_depth,
+                development_mode,
+                md_load_type,
+                # Conventional
                 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,
+                # MD Rear
+                enable_4_5, enable_6_0, enable_7_5,
+                # MD Front
+                enable_7_0, enable_8_0, enable_md_8_5, enable_md_10_5,
                 allow_custom_corners, color_scheme
             ],
             outputs=[plot_2d, results_table, summary_output, report_output, manual_widths]
@@ -1273,7 +1579,7 @@ def create_advanced_app():
         
         update_btn.click(
             update_manual_adjustment,
-            inputs=[manual_widths, stage_width, stage_depth, color_scheme],
+            inputs=[manual_widths, stage_width, stage_depth, development_mode, md_load_type, color_scheme],
             outputs=[plot_2d, adjustment_feedback]
         )