restructure algo folder

algorithms/backend/algorithm.py

@@ -1,780 +0,0 @@
-"""Core land redistribution algorithm implementation.
-
-This module contains the exact algorithm logic from algo.ipynb for:
-- Stage 1: Grid optimization using NSGA-II genetic algorithm
-- Stage 2: Block subdivision using OR-Tools
-- Stage 3: Infrastructure planning
-"""
-
-import random
-import numpy as np
-from typing import List, Tuple, Dict, Any
-from shapely.geometry import Polygon, Point, LineString, MultiPolygon, MultiPoint, mapping
-from shapely.affinity import translate, rotate
-from deap import base, creator, tools, algorithms
-from ortools.sat.python import cp_model
-import networkx as nx
-from scipy.spatial.distance import pdist, squareform
-from scipy.sparse.csgraph import minimum_spanning_tree
-from sklearn.cluster import KMeans
-from shapely.ops import unary_union, voronoi_diagram
-
-
-class GridOptimizer:
-    """Stage 1: Optimize grid layout using NSGA-II genetic algorithm."""
-    
-    def __init__(self, land_polygon: Polygon, lake_polygon: Polygon = None):
-        """
-        Initialize grid optimizer.
-        
-        Args:
-            land_polygon: Main land boundary
-            lake_polygon: Water body to exclude (optional)
-        """
-        self.land_poly = land_polygon
-        self.lake_poly = lake_polygon or Polygon()
-        
-        # Setup DEAP genetic algorithm
-        self._setup_deap()
-    
-    def _setup_deap(self):
-        """Configure DEAP toolbox for multi-objective optimization."""
-        # Create fitness and individual classes
-        if not hasattr(creator, "FitnessMulti"):
-            creator.create("FitnessMulti", base.Fitness, weights=(1.0, -1.0))  # Max area, Min fragments
-        if not hasattr(creator, "Individual"):
-            creator.create("Individual", list, fitness=creator.FitnessMulti)
-        
-        self.toolbox = base.Toolbox()
-        # Gene 1: Block spacing (20m - 40m)
-        self.toolbox.register("attr_spacing", random.uniform, 20, 40)
-        # Gene 2: Rotation angle (0 - 90 degrees)
-        self.toolbox.register("attr_angle", random.uniform, 0, 90)
-        
-        self.toolbox.register("individual", tools.initCycle, creator.Individual,
-                             (self.toolbox.attr_spacing, self.toolbox.attr_angle), n=1)
-        self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual)
-        
-        self.toolbox.register("evaluate", self._evaluate_layout)
-        self.toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=[20, 0], up=[40, 90], eta=20.0)
-        self.toolbox.register("mutate", tools.mutPolynomialBounded, low=[20, 0], up=[40, 90], eta=20.0, indpb=0.2)
-        self.toolbox.register("select", tools.selNSGA2)
-    
-    def generate_grid_candidates(self, spacing: float, angle_deg: float) -> List[Polygon]:
-        """
-        Generate grid blocks at given spacing and rotation.
-        
-        Args:
-            spacing: Grid spacing in meters
-            angle_deg: Rotation angle in degrees
-            
-        Returns:
-            List of block polygons
-        """
-        minx, miny, maxx, maxy = self.land_poly.bounds
-        diameter = ((maxx - minx)**2 + (maxy - miny)**2)**0.5
-        center = self.land_poly.centroid
-        
-        # Create grid ranges
-        x_range = np.arange(minx - diameter, maxx + diameter, spacing)
-        y_range = np.arange(miny - diameter, maxy + diameter, spacing)
-        
-        blocks = []
-        
-        # Create base block at origin
-        base_block = Polygon([(0, 0), (spacing, 0), (spacing, spacing), (0, spacing)])
-        base_block = translate(base_block, -spacing/2, -spacing/2)
-        
-        for x in x_range:
-            for y in y_range:
-                # Translate and rotate block
-                poly = translate(base_block, x, y)
-                poly = rotate(poly, angle_deg, origin=center)
-                
-                # Only keep blocks that intersect land
-                if poly.intersects(self.land_poly):
-                    blocks.append(poly)
-        
-        return blocks
-    
-    def _evaluate_layout(self, individual: List[float]) -> Tuple[float, int]:
-        """
-        Evaluate layout fitness.
-        
-        Objectives:
-        1. Maximize residential area
-        2. Minimize fragmented blocks
-        
-        Args:
-            individual: [spacing, angle]
-            
-        Returns:
-            (total_residential_area, fragmented_blocks)
-        """
-        spacing, angle = individual
-        blocks = self.generate_grid_candidates(spacing, angle)
-        
-        total_residential_area = 0
-        fragmented_blocks = 0
-        
-        for blk in blocks:
-            # Cut with land boundary
-            intersection = blk.intersection(self.land_poly)
-            if intersection.is_empty:
-                continue
-            
-            # Subtract lake
-            usable_part = intersection.difference(self.lake_poly)
-            if usable_part.is_empty:
-                continue
-            
-            # Calculate area ratio
-            original_area = spacing * spacing
-            actual_area = usable_part.area
-            ratio = actual_area / original_area
-            
-            # Classify block quality
-            if ratio > 0.65:
-                # Good block for residential
-                total_residential_area += actual_area
-            elif ratio > 0.1:
-                # Fragmented block (penalize)
-                fragmented_blocks += 1
-        
-        return (total_residential_area, fragmented_blocks)
-    
-    def optimize(self, population_size: int = 30, generations: int = 15) -> Tuple[List[float], List[List[float]]]:
-        """
-        Run NSGA-II optimization.
-        
-        Args:
-            population_size: Population size
-            generations: Number of generations
-            
-        Returns:
-            (best_solution, history)
-        """
-        random.seed(42)
-        pop = self.toolbox.population(n=population_size)
-        
-        history = []
-        
-        # Initial evaluation
-        fits = list(map(self.toolbox.evaluate, pop))
-        for ind, fit in zip(pop, fits):
-            ind.fitness.values = fit
-        
-        # Save best from generation 0
-        best_ind = tools.selBest(pop, 1)[0]
-        history.append(list(best_ind))
-        
-        # Evolution
-        for gen in range(generations):
-            offspring = algorithms.varAnd(pop, self.toolbox, cxpb=0.7, mutpb=0.3)
-            fits = list(map(self.toolbox.evaluate, offspring))
-            for ind, fit in zip(offspring, fits):
-                ind.fitness.values = fit
-            pop = self.toolbox.select(pop + offspring, k=len(pop))
-            
-            # Save best from each generation
-            best_ind = tools.selBest(pop, 1)[0]
-            history.append(list(best_ind))
-        
-        final_best = tools.selBest(pop, 1)[0]
-        return list(final_best), history
-
-
-class SubdivisionSolver:
-    """Stage 2: Optimize block subdivision using OR-Tools."""
-    
-    @staticmethod
-    def solve_subdivision(total_length: float, min_width: float, max_width: float, 
-                         target_width: float, time_limit: float = 5.0) -> List[float]:
-        """
-        Solve optimal lot widths using constraint programming.
-        
-        Args:
-            total_length: Total length to subdivide
-            min_width: Minimum lot width
-            max_width: Maximum lot width
-            target_width: Target lot width
-            time_limit: Solver time limit in seconds
-            
-        Returns:
-            List of lot widths
-        """
-        # Safety check: prevent division by zero
-        if total_length <= 0 or min_width <= 0 or total_length < min_width:
-            return []
-        
-        model = cp_model.CpModel()
-        
-        # Estimate number of lots
-        max_lots = int(total_length / min_width) + 1
-        
-        # Decision variables: lot widths (scaled to integers)
-        scale = 100  # 1cm precision
-        lot_vars = [model.NewIntVar(int(min_width * scale), int(max_width * scale), f'lot_{i}')
-                    for i in range(max_lots)]
-        
-        # Used lot indicators
-        used = [model.NewBoolVar(f'used_{i}') for i in range(max_lots)]
-        
-        # Constraints
-        # Sum of widths must equal total length
-        model.Add(sum(lot_vars[i] for i in range(max_lots)) == int(total_length * scale))
-        
-        # Lot ordering (if used, previous must be used)
-        for i in range(1, max_lots):
-            model.Add(used[i] <= used[i-1])
-        
-        # Connect lot values to usage
-        for i in range(max_lots):
-            model.Add(lot_vars[i] >= int(min_width * scale)).OnlyEnforceIf(used[i])
-            model.Add(lot_vars[i] == 0).OnlyEnforceIf(used[i].Not())
-        
-        # Minimize deviation from target
-        deviations = [model.NewIntVar(0, int((max_width - min_width) * scale), f'dev_{i}')
-                     for i in range(max_lots)]
-        
-        target_scaled = int(target_width * scale)
-        for i in range(max_lots):
-            model.AddAbsEquality(deviations[i], lot_vars[i] - target_scaled)
-        
-        model.Minimize(sum(deviations))
-        
-        # Solve
-        solver = cp_model.CpSolver()
-        solver.parameters.max_time_in_seconds = time_limit
-        status = solver.Solve(model)
-        
-        # Extract solution
-        if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
-            widths = []
-            for i in range(max_lots):
-                if solver.Value(used[i]):
-                    widths.append(solver.Value(lot_vars[i]) / scale)
-            return widths
-        else:
-            # Fallback: uniform division
-            num_lots = int(total_length / target_width)
-            return [total_length / num_lots] * num_lots
-    
-    @staticmethod
-    def subdivide_block(block_geom: Polygon, spacing: float, min_width: float, 
-                       max_width: float, target_width: float, time_limit: float = 5.0) -> Dict[str, Any]:
-        """
-        Subdivide a block into lots.
-        
-        Args:
-            block_geom: Block geometry
-            spacing: Grid spacing
-            min_width: Minimum lot width
-            max_width: Maximum lot width
-            target_width: Target lot width
-            setback: Setback distance in meters (default 6.0)
-            
-        Returns:
-            Dictionary with subdivision info
-        """
-        # Determine block quality
-        original_area = spacing * spacing
-        current_area = block_geom.area
-        ratio = current_area / original_area
-        
-        result = {
-            'geometry': block_geom,
-            'type': 'unknown',
-            'lots': []
-        }
-        
-        # Fragmented blocks become parks
-        if ratio < 0.6:
-            result['type'] = 'park'
-            return result
-        
-        # Good blocks become residential
-        result['type'] = 'residential'
-        
-        # Solve subdivision
-        minx, miny, maxx, maxy = block_geom.bounds
-        total_width = maxx - minx
-        
-        lot_widths = SubdivisionSolver.solve_subdivision(
-            total_width, min_width, max_width, target_width, time_limit
-        )
-        
-        # Create lot geometries
-        current_x = minx
-        setback_dist = 6.0 # Default setback
-        
-        for width in lot_widths:
-            lot_poly = Polygon([
-                (current_x, miny),
-                (current_x + width, miny),
-                (current_x + width, maxy),
-                (current_x, maxy)
-            ])
-            # Clip to block
-            clipped = lot_poly.intersection(block_geom)
-            if not clipped.is_empty:
-                # Calculate setback (buildable area)
-                buildable = clipped.buffer(-setback_dist)
-                if buildable.is_empty:
-                    buildable = None
-                    
-                result['lots'].append({
-                    'geometry': clipped,
-                    'width': width,
-                    'buildable': buildable
-                })
-            current_x += width
-        
-        return result
-
-
-class InfrastructurePlanner:
-    """Stage 3: Plan infrastructure network."""
-    
-    @staticmethod
-    def get_elevation(x: float, y: float) -> float:
-        """Simulate elevation (sloping from NW to SE)."""
-        return 50.0 - (x * 0.02) - (y * 0.03)
-
-    def generate_network(lots: List[Polygon]) -> Tuple[List[Tuple[float, float]], List[LineString]]:
-        """
-        Generate Loop Network for electrical infrastructure (MST + 15% redundancy).
-        Matches notebook's create_loop_network function.
-        
-        Args:
-            lots: List of lot polygons
-            
-        Returns:
-            (points, connection_lines)
-        """
-        if len(lots) < 2:
-            return [], []
-            
-        centroids = [lot.centroid for lot in lots]
-        points = np.array([(p.x, p.y) for p in centroids])
-        
-        # 1. Create full graph with all nearby connections
-        G = nx.Graph()
-        for i, p in enumerate(centroids):
-            G.add_node(i, pos=(p.x, p.y))
-        
-        # Add edges for all pairs within 500m
-        for i in range(len(centroids)):
-            for j in range(i+1, len(centroids)):
-                dist = centroids[i].distance(centroids[j])
-                if dist < 500:
-                    G.add_edge(i, j, weight=dist)
-        
-        # 2. Create MST (Minimum Spanning Tree)
-        if not nx.is_connected(G):
-            # Handle disconnected graph - use largest component
-            components = list(nx.connected_components(G))
-            largest_comp = max(components, key=len)
-            subgraph = G.subgraph(largest_comp).copy()
-            mst = nx.minimum_spanning_tree(subgraph)
-        else:
-            mst = nx.minimum_spanning_tree(G)
-        
-        # 3. CREATE LOOP: Add back 15% of edges for redundancy (safety)
-        all_edges = sorted(G.edges(data=True), key=lambda x: x[2]['weight'])
-        loop_graph = mst.copy()
-        
-        added_count = 0
-        target_extra = int(len(lots) * 0.15)  # 15% extra edges
-        
-        for u, v, data in all_edges:
-            if not loop_graph.has_edge(u, v):
-                loop_graph.add_edge(u, v, **data)
-                added_count += 1
-                if added_count >= target_extra:
-                    break
-        
-        # Convert NetworkX graph to LineString list
-        connections = []
-        for u, v in loop_graph.edges():
-            connections.append(LineString([centroids[u], centroids[v]]))
-            
-        return points.tolist(), connections
-
-    @staticmethod
-    def generate_transformers(lots: List[Polygon], radius: float = 300.0) -> List[Tuple[float, float]]:
-        """
-        Cluster lots to place transformers using K-Means.
-        """
-        if not lots:
-            return []
-            
-        lot_coords = np.array([(lot.centroid.x, lot.centroid.y) for lot in lots])
-        
-        # Estimate number of transformers (approx 1 per 15 lots)
-        num_transformers = max(1, int(len(lots) / 15))
-        
-        if len(lots) < num_transformers:
-            num_transformers = len(lots)
-            
-        kmeans = KMeans(n_clusters=num_transformers, n_init=10).fit(lot_coords)
-        return kmeans.cluster_centers_.tolist()
-
-    @staticmethod
-    def calculate_drainage(lots: List[Polygon], wwtp_centroid: Point) -> List[Dict[str, Any]]:
-        """
-        Calculate drainage flow direction towards Wastewater Treatment Plant (XLNT).
-        """
-        arrows = []
-        if not wwtp_centroid:
-            return arrows
-            
-        for lot in lots:
-            c = lot.centroid
-            dx = wwtp_centroid.x - c.x
-            dy = wwtp_centroid.y - c.y
-            length = (dx**2 + dy**2)**0.5
-            
-            if length > 0:
-                # Normalize vector to 30m arrow length
-                arrows.append({
-                    'start': (c.x, c.y),
-                    'vector': (dx/length * 30, dy/length * 30)
-                })
-        return arrows
-
-class LandRedistributionPipeline:
-    """Main pipeline orchestrating all optimization stages."""
-    
-    def __init__(self, land_polygons: List[Polygon], config: Dict[str, Any]):
-        """
-        Initialize pipeline.
-        
-        Args:
-            land_polygons: Input land plots
-            config: Algorithm configuration
-        """
-        # Merge all input polygons
-        from shapely.ops import unary_union
-        self.land_poly = unary_union(land_polygons)
-        self.config = config
-        self.lake_poly = Polygon()  # No lake by default
-        
-    def generate_road_network(self, num_seeds: int = 15) -> Tuple[Polygon, List[Polygon], List[Polygon]]:
-        """
-        Generate road network using Voronoi diagram (matches notebook's generate_road_network).
-        
-        Args:
-            num_seeds: Number of Voronoi seed points
-            
-        Returns:
-            (road_network, service_blocks, commercial_blocks)
-        """
-        # Constants from notebook
-        ROAD_MAIN_WIDTH = 25.0      # Main road width (m)
-        ROAD_INTERNAL_WIDTH = 15.0  # Internal road width (m)
-        SIDEWALK_WIDTH = 4.0        # Sidewalk width each side (m)
-        TURNING_RADIUS = 15.0       # Turning radius for intersections (m)
-        SERVICE_AREA_RATIO = 0.10   # 10% for service areas
-        MIN_BLOCK_AREA = 5000       # Minimum block area (m2)
-        
-        site = self.land_poly
-        minx, miny, maxx, maxy = site.bounds
-        
-        # 1. Generate random Voronoi seeds
-        seeds = []
-        for _ in range(num_seeds):
-            seeds.append(Point(random.uniform(minx, maxx), random.uniform(miny, maxy)))
-        
-        # 2. Create Voronoi diagram
-        try:
-            regions = voronoi_diagram(MultiPoint(seeds), envelope=site)
-        except:
-            # Fallback if Voronoi fails
-            return Polygon(), [], [site]
-        
-        # 3. Extract edges from Voronoi regions
-        edges = []
-        if hasattr(regions, 'geoms'):
-            for region in regions.geoms:
-                if region.geom_type == 'Polygon':
-                    edges.append(region.exterior)
-        elif regions.geom_type == 'Polygon':
-            edges.append(regions.exterior)
-        
-        # 4. Classify roads and create buffers
-        center = site.centroid
-        road_polys = []
-        
-        all_lines = []
-        for geom in edges:
-            all_lines.append(geom)
-        
-        merged_lines = unary_union(all_lines)
-        
-        # Normalize to list of LineStrings
-        lines_to_process = []
-        if hasattr(merged_lines, 'geoms'):
-            lines_to_process = list(merged_lines.geoms)
-        else:
-            lines_to_process = [merged_lines]
-        
-        for line in lines_to_process:
-            if line.geom_type != 'LineString':
-                continue
-            
-            # Heuristic: roads near center or very long = main roads
-            dist_to_center = line.distance(center)
-            if dist_to_center < 100 or line.length > 400:
-                # Main road: wider + sidewalks
-                width = ROAD_MAIN_WIDTH + 2 * SIDEWALK_WIDTH
-                road_polys.append(line.buffer(width / 2, cap_style=2, join_style=2))
-            else:
-                # Internal road: narrower
-                width = ROAD_INTERNAL_WIDTH + 2 * SIDEWALK_WIDTH
-                road_polys.append(line.buffer(width / 2, cap_style=2, join_style=2))
-        
-        if not road_polys:
-            # No roads generated - fallback
-            return Polygon(), [], [site]
-        
-        network_poly = unary_union(road_polys)
-        
-        # 5. Apply turning radius smoothing (vạt góc)
-        smooth_network = network_poly.buffer(TURNING_RADIUS, join_style=1).buffer(-TURNING_RADIUS, join_style=1)
-        
-        # 6. Extract blocks (land minus roads)
-        blocks_rough = site.difference(smooth_network)
-        
-        service_blocks = []
-        commercial_blocks = []
-        
-        # Normalize blocks list
-        candidates = []
-        if hasattr(blocks_rough, 'geoms'):
-            candidates = list(blocks_rough.geoms)
-        else:
-            candidates = [blocks_rough]
-        
-        # Filter by minimum area
-        valid_blocks = [b for b in candidates if b.geom_type == 'Polygon' and b.area >= MIN_BLOCK_AREA]
-        
-        if not valid_blocks:
-            return smooth_network, [], []
-        
-        # 7. Sort by elevation to find XLNT (lowest)
-        blocks_with_elev = [(b, InfrastructurePlanner.get_elevation(b.centroid.x, b.centroid.y)) for b in valid_blocks]
-        blocks_with_elev.sort(key=lambda x: x[1])
-        
-        # 8. Allocate service areas (10% of total)
-        total_area = sum(b.area for b in valid_blocks)
-        
-        # Safety check: prevent division issues
-        if total_area <= 0 or len(valid_blocks) == 0:
-            return smooth_network, [], valid_blocks
-        
-        service_area_needed = total_area * SERVICE_AREA_RATIO
-        
-        accumulated_service_area = 0
-        for block, elev in blocks_with_elev:
-            if accumulated_service_area < service_area_needed:
-                service_blocks.append(block)
-                accumulated_service_area += block.area
-            else:
-                commercial_blocks.append(block)
-        
-        # Ensure at least one commercial block exists
-        if not commercial_blocks and service_blocks:
-            # Move one service block to commercial
-            commercial_blocks.append(service_blocks.pop())
-        
-        return smooth_network, service_blocks, commercial_blocks
-    
-    def run_stage1(self) -> Dict[str, Any]:
-        """Run grid optimization stage."""
-        optimizer = GridOptimizer(self.land_poly, self.lake_poly)
-        
-        best_solution, history = optimizer.optimize(
-            population_size=self.config.get('population_size', 30),
-            generations=self.config.get('generations', 15)
-        )
-        
-        spacing, angle = best_solution
-        blocks = optimizer.generate_grid_candidates(spacing, angle)
-        
-        # Filter to usable blocks
-        usable_blocks = []
-        for blk in blocks:
-            intersection = blk.intersection(self.land_poly).difference(self.lake_poly)
-            if not intersection.is_empty:
-                usable_blocks.append(intersection)
-        
-        return {
-            'spacing': spacing,
-            'angle': angle,
-            'blocks': usable_blocks,
-            'history': history,
-            'metrics': {
-                'total_blocks': len(usable_blocks),
-                'optimal_spacing': spacing,
-                'optimal_angle': angle
-            }
-        }
-    
-    def run_stage2(self, blocks: List[Polygon], spacing: float) -> Dict[str, Any]:
-        """Run subdivision stage."""
-        all_lots = []
-        parks = []
-        
-        for block in blocks:
-            result = SubdivisionSolver.subdivide_block(
-                block,
-                spacing,
-                self.config.get('min_lot_width', 5.0),
-                self.config.get('max_lot_width', 8.0),
-                self.config.get('target_lot_width', 6.0),
-                self.config.get('ortools_time_limit', 5)
-            )
-            
-            if result['type'] == 'park':
-                parks.append(result['geometry'])
-            else:
-                all_lots.extend(result['lots'])
-        
-        return {
-            'lots': all_lots,
-            'parks': parks,
-            'metrics': {
-                'total_lots': len(all_lots),
-                'total_parks': len(parks),
-                'avg_lot_width': np.mean([lot['width'] for lot in all_lots]) if all_lots else 0
-            }
-        }
-    
-    def classify_blocks(self, blocks: List[Polygon]) -> Dict[str, List[Polygon]]:
-        """
-        Classify blocks into Service (XLNT, Operations) and Commercial.
-        Logic: 
-        - Sort by elevation (lowest -> XLNT)
-        - Reserve 10% for Service/Parking
-        - Rest -> Commercial (Residential/Industrial)
-        """
-        if not blocks:
-            return {'service': [], 'commercial': [], 'xlnt': []}
-            
-        # Sort by elevation
-        sorted_blocks = sorted(blocks, key=lambda b: InfrastructurePlanner.get_elevation(b.centroid.x, b.centroid.y))
-        
-        total_area = sum(b.area for b in blocks)
-        service_area_target = total_area * 0.10
-        current_service_area = 0
-        
-        service_blocks = []
-        commercial_blocks = []
-        xlnt_block = []
-        
-        # Lowest block is XLNT
-        if sorted_blocks:
-            xlnt = sorted_blocks.pop(0)
-            xlnt_block.append(xlnt)
-            current_service_area += xlnt.area
-            
-        # Fill remaining service quota
-        for b in sorted_blocks:
-            if current_service_area < service_area_target:
-                service_blocks.append(b)
-                current_service_area += b.area
-            else:
-                commercial_blocks.append(b)
-                
-        return {
-            'xlnt': xlnt_block,
-            'service': service_blocks,
-            'commercial': commercial_blocks
-        }
-
-    def run_full_pipeline(self) -> Dict[str, Any]:
-        """Run complete optimization pipeline with Voronoi road generation."""
-        # NEW: Stage 0 - Voronoi Road Network Generation
-        road_network, service_blocks_voronoi, commercial_blocks_voronoi = self.generate_road_network(num_seeds=15)
-        
-        # If Voronoi fails, fallback to old approach
-        if not commercial_blocks_voronoi:
-            # Old approach: Grid-based
-            stage1_result = self.run_stage1()
-            classification = self.classify_blocks(stage1_result['blocks'])
-            commercial_blocks_voronoi = classification['commercial']
-            service_blocks_voronoi = classification['service']
-            xlnt_blocks = classification['xlnt']
-            # Old road network
-            all_blocks = stage1_result['blocks']
-            road_network = self.land_poly.difference(unary_union(all_blocks))
-            spacing_for_subdivision = stage1_result['spacing']
-        else:
-            # Voronoi succeeded - separate XLNT from service blocks
-            # XLNT is the first service block (lowest elevation)
-            if service_blocks_voronoi:
-                xlnt_blocks = [service_blocks_voronoi[0]]
-                service_blocks_voronoi = service_blocks_voronoi[1:]
-            else:
-                xlnt_blocks = []
-            
-            # Estimate spacing for subdivision (use average block dimension)
-            if commercial_blocks_voronoi and len(commercial_blocks_voronoi) > 0:
-                avg_area = sum(b.area for b in commercial_blocks_voronoi) / len(commercial_blocks_voronoi)
-                spacing_for_subdivision = max(20.0, (avg_area ** 0.5) * 0.7)  # Heuristic, min 20m
-            else:
-                spacing_for_subdivision = 25.0
-        
-        # Stage 2: Subdivision (only for commercial blocks)
-        stage2_result = self.run_stage2(
-            commercial_blocks_voronoi,
-            spacing_for_subdivision
-        )
-        
-        # Construct final list of all network nodes
-        all_network_nodes = stage2_result['lots'] + \
-                          [{'geometry': b, 'type': 'service'} for b in service_blocks_voronoi] + \
-                          [{'geometry': b, 'type': 'xlnt'} for b in xlnt_blocks]
-        
-        # Extract polygons for Infrastructure
-        infra_polys = [item['geometry'] for item in all_network_nodes]
-        
-        # Stage 3: Infrastructure
-        points, connections = InfrastructurePlanner.generate_network(infra_polys)
-        
-        # Transformers
-        transformers = InfrastructurePlanner.generate_transformers(infra_polys)
-        
-        # Drainage
-        wwtp_center = xlnt_blocks[0].centroid if xlnt_blocks else None
-        drainage = InfrastructurePlanner.calculate_drainage(infra_polys, wwtp_center)
-        
-        return {
-            'stage1': {
-                'blocks': commercial_blocks_voronoi + service_blocks_voronoi + xlnt_blocks,
-                'metrics': {
-                    'total_blocks': len(commercial_blocks_voronoi) + len(service_blocks_voronoi) + len(xlnt_blocks)
-                },
-                'spacing': spacing_for_subdivision,
-                'angle': 0.0  # Voronoi doesn't use angle
-            },
-            'stage2': stage2_result,
-            'classification': {
-                'xlnt_count': len(xlnt_blocks),
-                'service_count': len(service_blocks_voronoi),
-                'commercial_count': len(commercial_blocks_voronoi),
-                'xlnt': xlnt_blocks,
-                'service': service_blocks_voronoi
-            },
-            'stage3': {
-                'points': points,
-                'connections': [list(line.coords) for line in connections],
-                'drainage': drainage,
-                'transformers': transformers,
-                'road_network': mapping(road_network)
-            },
-            'total_lots': stage2_result['metrics']['total_lots'],
-            'service_blocks': [list(b.exterior.coords) for b in service_blocks_voronoi],
-            'xlnt_blocks': [list(b.exterior.coords) for b in xlnt_blocks]
-        }

algorithms/backend/api/__init__.py

@@ -0,0 +1,9 @@
+# API module
+from api.schemas import (
+    AlgorithmConfig,
+    LandPlot,
+    OptimizationRequest,
+    StageResult,
+    OptimizationResponse,
+    HealthResponse,
+)

algorithms/backend/api/routes/__init__.py

@@ -0,0 +1,2 @@
+from api.routes.optimization_routes import router as optim_router
+from api.routes.dxf_routes import router as dxf_router

algorithms/backend/api/routes/dxf_routes.py

@@ -0,0 +1,103 @@
+"""DXF file handling routes."""
+
+import logging
+from fastapi import APIRouter, HTTPException, UploadFile, File
+from fastapi.responses import Response
+
+from utils.dxf_utils import load_boundary_from_dxf, export_to_dxf, validate_dxf
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.post("/upload-dxf")
+async def upload_dxf(file: UploadFile = File(...)):
+    """
+    Upload and parse DXF file to extract boundary polygon.
+    
+    Returns GeoJSON polygon that can be used as input.
+    """
+    try:
+        content = await file.read()
+        
+        is_valid, message = validate_dxf(content)
+        if not is_valid:
+            raise HTTPException(status_code=400, detail=message)
+        
+        polygon = load_boundary_from_dxf(content)
+        
+        if polygon is None:
+            raise HTTPException(
+                status_code=400, 
+                detail="Could not extract boundary polygon from DXF. Make sure it contains closed polylines."
+            )
+        
+        geojson = {
+            "type": "Polygon",
+            "coordinates": [list(polygon.exterior.coords)],
+            "properties": {
+                "source": "dxf",
+                "filename": file.filename,
+                "area": polygon.area
+            }
+        }
+        
+        return {
+            "success": True,
+            "message": f"Successfully extracted boundary from {file.filename}",
+            "polygon": geojson,
+            "area": polygon.area,
+            "bounds": polygon.bounds
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"DXF processing failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to process DXF: {str(e)}")
+
+
+@router.post("/export-dxf")
+async def export_dxf_endpoint(request: dict):
+    """
+    Export optimization results to DXF format.
+    
+    Expects: {"result": OptimizationResponse}
+    Returns: DXF file
+    """
+    try:
+        result = request.get('result')
+        if not result:
+            raise HTTPException(status_code=400, detail="No result data provided")
+        
+        geometries = []
+        
+        if 'final_layout' in result and result['final_layout']:
+            features = result['final_layout'].get('features', [])
+            geometries = features
+        elif 'stages' in result and len(result['stages']) > 0:
+            last_stage = result['stages'][-1]
+            features = last_stage.get('geometry', {}).get('features', [])
+            geometries = features
+        
+        if not geometries:
+            raise HTTPException(status_code=400, detail="No geometries to export")
+        
+        dxf_bytes = export_to_dxf(geometries)
+        
+        if not dxf_bytes:
+            raise HTTPException(status_code=500, detail="Failed to generate DXF")
+        
+        return Response(
+            content=dxf_bytes,
+            media_type="application/dxf",
+            headers={
+                "Content-Disposition": "attachment; filename=land_redistribution.dxf"
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"DXF export failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")

algorithms/backend/{routes.py → api/routes/optimization_routes.py}

@@ -1,19 +1,15 @@
-"""API routes for land redistribution algorithm."""
+"""Optimization API routes."""
 
-from fastapi import APIRouter, HTTPException, UploadFile, File
-from fastapi.responses import Response
-from typing import List
+import logging
 import traceback
+from fastapi import APIRouter, HTTPException
 from shapely.geometry import Polygon, mapping, LineString, Point
 
-from models import (
-    OptimizationRequest,
-    OptimizationResponse,
-    StageResult
-)
-from algorithm import LandRedistributionPipeline
-from dxf_utils import load_boundary_from_dxf, export_to_dxf, validate_dxf
+from api.schemas.request_schemas import OptimizationRequest
+from api.schemas.response_schemas import OptimizationResponse, StageResult
+from pipeline.land_redistribution import LandRedistributionPipeline
 
+logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
@@ -37,8 +33,6 @@ async def optimize_full(request: OptimizationRequest):
     1. Grid optimization (NSGA-II)
     2. Block subdivision (OR-Tools)
     3. Infrastructure planning
-    
-    Returns detailed results with process visualization data.
     """
     try:
         # Convert input land plots to Shapely polygons
@@ -93,8 +87,7 @@ async def optimize_full(request: OptimizationRequest):
                 "properties": lot_props
             })
             
-            # Setback (Network visualization will need this as separate line usually, 
-            # or frontend can render it if passed as property geometry)
+            # Setback
             if lot.get('buildable'):
                 stage2_features.append({
                     "type": "Feature",
@@ -117,7 +110,6 @@ async def optimize_full(request: OptimizationRequest):
                 }
             })
         
-        
         # Add Service Blocks
         for block in result['classification'].get('service', []):
             stage2_features.append({
@@ -176,7 +168,6 @@ async def optimize_full(request: OptimizationRequest):
                     "label": "Transportation Infra"
                 }
             }
-            # PREPEND roads so they are at bottom layer
             stage3_features.insert(0, road_feat)
 
         # Add connection lines
@@ -206,7 +197,6 @@ async def optimize_full(request: OptimizationRequest):
 
         # Add drainage
         for drainage in result['stage3']['drainage']:
-            # Create a line for the arrow
             start = drainage['start']
             vec = drainage['vector']
             end = (start[0] + vec[0], start[1] + vec[1])
@@ -221,7 +211,7 @@ async def optimize_full(request: OptimizationRequest):
             
         stage3_geoms = {
             "type": "FeatureCollection",
-            "features": stage3_features + stage2_features # Include base map
+            "features": stage3_features + stage2_features
         }
         
         stages.append(StageResult(
@@ -235,7 +225,6 @@ async def optimize_full(request: OptimizationRequest):
             parameters={}
         ))
         
-        # Build response
         return OptimizationResponse(
             success=True,
             message="Optimization completed successfully",
@@ -255,6 +244,7 @@ async def optimize_full(request: OptimizationRequest):
         
     except Exception as e:
         error_msg = f"Optimization failed: {str(e)}\n{traceback.format_exc()}"
+        logger.error(error_msg)
         raise HTTPException(status_code=500, detail=error_msg)
 
 
@@ -263,7 +253,6 @@ async def optimize_stage1(request: OptimizationRequest):
     """Run only grid optimization stage."""
     try:
         land_polygons = [land_plot_to_polygon(plot.dict()) for plot in request.land_plots]
-        
         config = request.config.dict()
         pipeline = LandRedistributionPipeline(land_polygons, config)
         
@@ -297,102 +286,5 @@ async def optimize_stage1(request: OptimizationRequest):
         )
         
     except Exception as e:
+        logger.error(f"Stage 1 failed: {e}")
         raise HTTPException(status_code=500, detail=f"Stage 1 failed: {str(e)}")
-
-
-@router.post("/upload-dxf")
-async def upload_dxf(file: UploadFile = File(...)):
-    """
-    Upload and parse DXF file to extract boundary polygon.
-    
-    Returns GeoJSON polygon that can be used as input.
-    """
-    try:
-        # Read file content
-        content = await file.read()
-        
-        # Validate DXF
-        is_valid, message = validate_dxf(content)
-        if not is_valid:
-            raise HTTPException(status_code=400, detail=message)
-        
-        # Load boundary
-        polygon = load_boundary_from_dxf(content)
-        
-        if polygon is None:
-            raise HTTPException(
-                status_code=400, 
-                detail="Could not extract boundary polygon from DXF. Make sure it contains closed polylines."
-            )
-        
-        # Convert to GeoJSON
-        geojson = {
-            "type": "Polygon",
-            "coordinates": [list(polygon.exterior.coords)],
-            "properties": {
-                "source": "dxf",
-                "filename": file.filename,
-                "area": polygon.area
-            }
-        }
-        
-        return {
-            "success": True,
-            "message": f"Successfully extracted boundary from {file.filename}",
-            "polygon": geojson,
-            "area": polygon.area,
-            "bounds": polygon.bounds
-        }
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to process DXF: {str(e)}")
-
-
-@router.post("/export-dxf")
-async def export_dxf_endpoint(request: dict):
-    """
-    Export optimization results to DXF format.
-    
-    Expects: {"result": OptimizationResponse}
-    Returns: DXF file
-    """
-    try:
-        result = request.get('result')
-        if not result:
-            raise HTTPException(status_code=400, detail="No result data provided")
-        
-        # Get final layout or last stage
-        geometries = []
-        
-        if 'final_layout' in result and result['final_layout']:
-            features = result['final_layout'].get('features', [])
-            geometries = features
-        elif 'stages' in result and len(result['stages']) > 0:
-            last_stage = result['stages'][-1]
-            features = last_stage.get('geometry', {}).get('features', [])
-            geometries = features
-        
-        if not geometries:
-            raise HTTPException(status_code=400, detail="No geometries to export")
-        
-        # Export to DXF
-        dxf_bytes = export_to_dxf(geometries)
-        
-        if not dxf_bytes:
-            raise HTTPException(status_code=500, detail="Failed to generate DXF")
-        
-        # Return as downloadable file
-        return Response(
-            content=dxf_bytes,
-            media_type="application/dxf",
-            headers={
-                "Content-Disposition": "attachment; filename=land_redistribution.dxf"
-            }
-        )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")

algorithms/backend/api/schemas/__init__.py

@@ -0,0 +1,2 @@
+from api.schemas.request_schemas import AlgorithmConfig, LandPlot, OptimizationRequest
+from api.schemas.response_schemas import StageResult, OptimizationResponse, HealthResponse

algorithms/backend/{models.py → api/schemas/request_schemas.py}

@@ -1,4 +1,4 @@
-"""Pydantic models for API request/response schemas."""
+"""Request schemas for the API."""
 
 from typing import List, Dict, Any, Optional
 from pydantic import BaseModel, Field
@@ -41,30 +41,3 @@ class OptimizationRequest(BaseModel):
     
     config: AlgorithmConfig = Field(..., description="Algorithm configuration")
     land_plots: List[LandPlot] = Field(..., description="Initial land plots to subdivide")
-
-
-class StageResult(BaseModel):
-    """Result from a single optimization stage."""
-    
-    stage_name: str = Field(..., description="Name of the stage")
-    geometry: Dict[str, Any] = Field(..., description="GeoJSON geometry of results")
-    metrics: Dict[str, float] = Field(..., description="Performance metrics")
-    parameters: Dict[str, Any] = Field(..., description="Parameters used")
-
-
-class OptimizationResponse(BaseModel):
-    """Response model containing optimization results."""
-    
-    success: bool = Field(..., description="Whether optimization succeeded")
-    message: str = Field(..., description="Status message")
-    stages: List[StageResult] = Field(default=[], description="Results from each stage")
-    final_layout: Optional[Dict[str, Any]] = Field(None, description="Final GeoJSON layout")
-    total_lots: Optional[int] = Field(None, description="Total number of lots created")
-    statistics: Optional[Dict[str, Any]] = Field(None, description="Overall statistics")
-
-
-class HealthResponse(BaseModel):
-    """Health check response."""
-    
-    status: str = Field(default="healthy", description="Service status")
-    version: str = Field(default="1.0.0", description="API version")

algorithms/backend/api/schemas/response_schemas.py

@@ -0,0 +1,31 @@
+"""Response schemas for the API."""
+
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+
+class StageResult(BaseModel):
+    """Result from a single optimization stage."""
+    
+    stage_name: str = Field(..., description="Name of the stage")
+    geometry: Dict[str, Any] = Field(..., description="GeoJSON geometry of results")
+    metrics: Dict[str, float] = Field(..., description="Performance metrics")
+    parameters: Dict[str, Any] = Field(..., description="Parameters used")
+
+
+class OptimizationResponse(BaseModel):
+    """Response model containing optimization results."""
+    
+    success: bool = Field(..., description="Whether optimization succeeded")
+    message: str = Field(..., description="Status message")
+    stages: List[StageResult] = Field(default=[], description="Results from each stage")
+    final_layout: Optional[Dict[str, Any]] = Field(None, description="Final GeoJSON layout")
+    total_lots: Optional[int] = Field(None, description="Total number of lots created")
+    statistics: Optional[Dict[str, Any]] = Field(None, description="Overall statistics")
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+    
+    status: str = Field(default="healthy", description="Service status")
+    version: str = Field(default="1.0.0", description="API version")

algorithms/backend/core/__init__.py

@@ -0,0 +1,2 @@
+# Core module exports
+from core.config import settings

algorithms/backend/core/config/__init__.py

@@ -0,0 +1 @@
+from core.config.settings import AlgorithmSettings, RoadSettings, SubdivisionSettings, InfrastructureSettings

algorithms/backend/core/config/settings.py

@@ -0,0 +1,134 @@
+"""
+Algorithm configuration settings and constants.
+
+Contains all configurable parameters for the land redistribution algorithm,
+organized into dataclasses for type safety and clarity.
+"""
+
+from dataclasses import dataclass, field
+from typing import Tuple
+
+
+@dataclass(frozen=True)
+class RoadSettings:
+    """Road and transportation infrastructure settings (TCVN standards)."""
+    
+    # Road widths (meters)
+    main_width: float = 30.0       # Main road - container trucks can pass
+    internal_width: float = 15.0   # Internal road
+    sidewalk_width: float = 4.0    # Sidewalk each side (includes utility trench)
+    turning_radius: float = 15.0   # Corner chamfer radius for intersections
+
+
+@dataclass(frozen=True)
+class SubdivisionSettings:
+    """Block and lot subdivision settings."""
+    
+    # Land allocation
+    service_area_ratio: float = 0.10    # 10% for infrastructure (WWTP, parking, etc.)
+    min_block_area: float = 5000.0      # Minimum block area to subdivide (m²)
+    
+    # Lot dimensions (industrial)
+    min_lot_width: float = 20.0         # Minimum lot frontage (m)
+    max_lot_width: float = 80.0         # Maximum lot frontage (m)
+    target_lot_width: float = 40.0      # Target lot width (m)
+    
+    # Legal/Construction (TCVN)
+    setback_distance: float = 6.0       # Building setback from road (m)
+    fire_safety_gap: float = 4.0        # Fire safety gap between buildings (m)
+    
+    # Solver
+    solver_time_limit: float = 0.5      # OR-Tools time limit per block (seconds)
+
+
+@dataclass(frozen=True)
+class InfrastructureSettings:
+    """Infrastructure planning settings."""
+    
+    # Electrical
+    transformer_radius: float = 300.0   # Effective service radius (m)
+    lots_per_transformer: int = 15      # Approximate lots per transformer
+    
+    # Network
+    loop_redundancy_ratio: float = 0.15 # 15% extra edges for loop network safety
+    max_connection_distance: float = 500.0  # Max distance for lot connections (m)
+    
+    # Drainage
+    drainage_arrow_length: float = 30.0 # Arrow length for visualization (m)
+
+
+@dataclass(frozen=True)
+class OptimizationSettings:
+    """NSGA-II genetic algorithm settings."""
+    
+    # Population
+    population_size: int = 30
+    generations: int = 15
+    
+    # Crossover/Mutation
+    crossover_probability: float = 0.7
+    mutation_probability: float = 0.3
+    eta: float = 20.0  # Distribution index for SBX crossover
+    
+    # Gene bounds
+    spacing_bounds: Tuple[float, float] = (20.0, 40.0)
+    angle_bounds: Tuple[float, float] = (0.0, 90.0)
+    
+    # Block quality thresholds
+    good_block_ratio: float = 0.65      # Ratio for residential/commercial
+    fragmented_block_ratio: float = 0.1 # Below this = too small
+
+
+@dataclass
+class AlgorithmSettings:
+    """Complete algorithm configuration."""
+    
+    road: RoadSettings = field(default_factory=RoadSettings)
+    subdivision: SubdivisionSettings = field(default_factory=SubdivisionSettings)
+    infrastructure: InfrastructureSettings = field(default_factory=InfrastructureSettings)
+    optimization: OptimizationSettings = field(default_factory=OptimizationSettings)
+    
+    # Random seed for reproducibility
+    random_seed: int = 42
+    
+    @classmethod
+    def from_dict(cls, config: dict) -> 'AlgorithmSettings':
+        """Create settings from API config dictionary."""
+        settings = cls()
+        
+        # Map API config to internal settings
+        if 'min_lot_width' in config:
+            settings = cls(
+                subdivision=SubdivisionSettings(
+                    min_lot_width=config.get('min_lot_width', 20.0),
+                    max_lot_width=config.get('max_lot_width', 80.0),
+                    target_lot_width=config.get('target_lot_width', 40.0),
+                    solver_time_limit=config.get('ortools_time_limit', 0.5),
+                ),
+                optimization=OptimizationSettings(
+                    population_size=config.get('population_size', 30),
+                    generations=config.get('generations', 15),
+                ),
+            )
+        
+        return settings
+
+
+# Default settings instance
+DEFAULT_SETTINGS = AlgorithmSettings()
+
+
+# Convenience accessors for backward compatibility
+ROAD_MAIN_WIDTH = DEFAULT_SETTINGS.road.main_width
+ROAD_INTERNAL_WIDTH = DEFAULT_SETTINGS.road.internal_width
+SIDEWALK_WIDTH = DEFAULT_SETTINGS.road.sidewalk_width
+TURNING_RADIUS = DEFAULT_SETTINGS.road.turning_radius
+SERVICE_AREA_RATIO = DEFAULT_SETTINGS.subdivision.service_area_ratio
+MIN_BLOCK_AREA = DEFAULT_SETTINGS.subdivision.min_block_area
+MIN_LOT_WIDTH = DEFAULT_SETTINGS.subdivision.min_lot_width
+MAX_LOT_WIDTH = DEFAULT_SETTINGS.subdivision.max_lot_width
+TARGET_LOT_WIDTH = DEFAULT_SETTINGS.subdivision.target_lot_width
+SETBACK_DISTANCE = DEFAULT_SETTINGS.subdivision.setback_distance
+FIRE_SAFETY_GAP = DEFAULT_SETTINGS.subdivision.fire_safety_gap
+SOLVER_TIME_LIMIT = DEFAULT_SETTINGS.subdivision.solver_time_limit
+TRANSFORMER_RADIUS = DEFAULT_SETTINGS.infrastructure.transformer_radius

algorithms/backend/core/geometry/__init__.py

@@ -0,0 +1,10 @@
+from core.geometry.polygon_utils import (
+    get_elevation,
+    normalize_geometry_list,
+    merge_polygons,
+)
+from core.geometry.voronoi import (
+    generate_voronoi_seeds,
+    create_voronoi_diagram,
+    extract_voronoi_edges,
+)

algorithms/backend/core/geometry/polygon_utils.py

@@ -0,0 +1,137 @@
+"""
+Polygon utility functions for geometry processing.
+
+Provides helper functions for Shapely polygon operations,
+elevation calculations, and geometry normalization.
+"""
+
+import logging
+from typing import List, Union, Optional
+
+from shapely.geometry import Polygon, MultiPolygon, GeometryCollection
+from shapely.ops import unary_union
+
+logger = logging.getLogger(__name__)
+
+
+def get_elevation(x: float, y: float) -> float:
+    """
+    Simulate terrain elevation (sloping from NW to SE).
+    
+    This is a simple linear model: z = 50 - 0.02x - 0.03y
+    Used for determining WWTP placement (lowest point).
+    
+    Args:
+        x: X coordinate
+        y: Y coordinate
+        
+    Returns:
+        Simulated elevation value
+    """
+    return 50.0 - (x * 0.02) - (y * 0.03)
+
+
+def normalize_geometry_list(
+    geometry: Union[Polygon, MultiPolygon, GeometryCollection, None]
+) -> List[Polygon]:
+    """
+    Convert various geometry types to a flat list of Polygons.
+    
+    Handles GeometryCollection, MultiPolygon, single Polygon, or None.
+    
+    Args:
+        geometry: Input geometry of various types
+        
+    Returns:
+        List of Polygon objects (may be empty)
+    """
+    if geometry is None or geometry.is_empty:
+        return []
+    
+    if hasattr(geometry, 'geoms'):
+        # GeometryCollection or MultiPolygon
+        result = []
+        for geom in geometry.geoms:
+            if geom.geom_type == 'Polygon' and not geom.is_empty:
+                result.append(geom)
+        return result
+    elif geometry.geom_type == 'Polygon':
+        return [geometry]
+    else:
+        logger.warning(f"Unexpected geometry type: {geometry.geom_type}")
+        return []
+
+
+def merge_polygons(polygons: List[Polygon]) -> Polygon:
+    """
+    Merge multiple polygons into a single polygon using unary_union.
+    
+    Args:
+        polygons: List of Polygon objects
+        
+    Returns:
+        Merged polygon (may be MultiPolygon if non-contiguous)
+    """
+    if not polygons:
+        return Polygon()
+    
+    if len(polygons) == 1:
+        return polygons[0]
+    
+    return unary_union(polygons)
+
+
+def filter_by_min_area(
+    polygons: List[Polygon], 
+    min_area: float
+) -> List[Polygon]:
+    """
+    Filter polygons by minimum area threshold.
+    
+    Args:
+        polygons: List of polygons to filter
+        min_area: Minimum area threshold (m²)
+        
+    Returns:
+        Filtered list of polygons meeting the area requirement
+    """
+    return [p for p in polygons if p.area >= min_area]
+
+
+def sort_by_elevation(polygons: List[Polygon]) -> List[Polygon]:
+    """
+    Sort polygons by centroid elevation (lowest first).
+    
+    Useful for determining WWTP placement (should be at lowest point).
+    
+    Args:
+        polygons: List of polygons to sort
+        
+    Returns:
+        Sorted list (lowest elevation first)
+    """
+    return sorted(
+        polygons, 
+        key=lambda p: get_elevation(p.centroid.x, p.centroid.y)
+    )
+
+
+def calculate_block_quality_ratio(
+    block: Polygon, 
+    original_area: float
+) -> float:
+    """
+    Calculate quality ratio of a block (actual area / original area).
+    
+    Used to classify blocks as residential, fragmented, or unusable.
+    
+    Args:
+        block: Block polygon
+        original_area: Original (full) block area before clipping
+        
+    Returns:
+        Ratio between 0 and 1
+    """
+    if original_area <= 0:
+        return 0.0
+    return min(1.0, block.area / original_area)

algorithms/backend/core/geometry/voronoi.py

@@ -0,0 +1,173 @@
+"""
+Voronoi diagram generation for road network planning.
+
+Uses Shapely's Voronoi implementation to create organic road layouts
+based on random seed points distributed within the site boundary.
+"""
+
+import random
+import logging
+from typing import List, Tuple, Optional
+
+from shapely.geometry import Point, Polygon, MultiPoint, LineString
+from shapely.ops import voronoi_diagram, unary_union
+
+logger = logging.getLogger(__name__)
+
+
+def generate_voronoi_seeds(
+    site: Polygon,
+    num_seeds: int = 15,
+    seed: Optional[int] = None
+) -> List[Point]:
+    """
+    Generate random seed points for Voronoi diagram.
+    
+    Points are uniformly distributed within the site bounding box.
+    
+    Args:
+        site: Site boundary polygon
+        num_seeds: Number of seed points to generate
+        seed: Random seed for reproducibility (optional)
+        
+    Returns:
+        List of Point objects
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    minx, miny, maxx, maxy = site.bounds
+    
+    seeds = []
+    for _ in range(num_seeds):
+        x = random.uniform(minx, maxx)
+        y = random.uniform(miny, maxy)
+        seeds.append(Point(x, y))
+    
+    return seeds
+
+
+def create_voronoi_diagram(
+    seeds: List[Point],
+    envelope: Polygon
+) -> Optional[object]:
+    """
+    Create Voronoi diagram from seed points.
+    
+    Args:
+        seeds: List of seed Point objects
+        envelope: Bounding envelope for the diagram
+        
+    Returns:
+        Voronoi regions geometry, or None if generation fails
+    """
+    if len(seeds) < 2:
+        logger.warning("Need at least 2 seeds for Voronoi diagram")
+        return None
+    
+    try:
+        multi_point = MultiPoint(seeds)
+        regions = voronoi_diagram(multi_point, envelope=envelope)
+        return regions
+    except Exception as e:
+        logger.error(f"Voronoi diagram generation failed: {e}")
+        return None
+
+
+def extract_voronoi_edges(
+    regions: object
+) -> List[LineString]:
+    """
+    Extract edge LineStrings from Voronoi regions.
+    
+    Collects the exterior rings of all Voronoi cells and merges them.
+    
+    Args:
+        regions: Voronoi diagram geometry (GeometryCollection of Polygons)
+        
+    Returns:
+        List of LineString edges
+    """
+    edges = []
+    
+    if regions is None:
+        return edges
+    
+    # Collect exterior rings from Voronoi polygons
+    if hasattr(regions, 'geoms'):
+        for region in regions.geoms:
+            if region.geom_type == 'Polygon':
+                edges.append(region.exterior)
+    elif regions.geom_type == 'Polygon':
+        edges.append(regions.exterior)
+    
+    if not edges:
+        return []
+    
+    # Merge all lines for unified processing
+    merged = unary_union(edges)
+    
+    # Normalize to list of LineStrings
+    if hasattr(merged, 'geoms'):
+        return [g for g in merged.geoms if g.geom_type == 'LineString']
+    elif merged.geom_type == 'LineString':
+        return [merged]
+    else:
+        return []
+
+
+def classify_road_type(
+    line: LineString,
+    site_center: Point,
+    center_threshold: float = 100.0,
+    length_threshold: float = 400.0
+) -> str:
+    """
+    Classify a road line as 'main' or 'internal'.
+    
+    Heuristic: Roads near center or very long are main roads.
+    
+    Args:
+        line: Road centerline
+        site_center: Center point of the site
+        center_threshold: Distance threshold from center (m)
+        length_threshold: Length threshold (m)
+        
+    Returns:
+        'main' or 'internal'
+    """
+    dist_to_center = line.distance(site_center)
+    
+    if dist_to_center < center_threshold or line.length > length_threshold:
+        return 'main'
+    else:
+        return 'internal'
+
+
+def create_road_buffer(
+    line: LineString,
+    road_type: str,
+    main_width: float = 30.0,
+    internal_width: float = 15.0,
+    sidewalk_width: float = 4.0
+) -> Polygon:
+    """
+    Create road polygon by buffering centerline.
+    
+    Args:
+        line: Road centerline
+        road_type: 'main' or 'internal'
+        main_width: Main road width (m)
+        internal_width: Internal road width (m)
+        sidewalk_width: Sidewalk width each side (m)
+        
+    Returns:
+        Road polygon (buffered centerline)
+    """
+    if road_type == 'main':
+        width = main_width + 2 * sidewalk_width
+    else:
+        width = internal_width + 2 * sidewalk_width
+    
+    # Use flat cap and mitre join for road-like appearance
+    return line.buffer(width / 2, cap_style=2, join_style=2)

algorithms/backend/core/infrastructure/__init__.py

@@ -0,0 +1,3 @@
+from core.infrastructure.network_planner import generate_loop_network
+from core.infrastructure.transformer_planner import generate_transformers
+from core.infrastructure.drainage_planner import calculate_drainage

algorithms/backend/core/infrastructure/drainage_planner.py

@@ -0,0 +1,79 @@
+"""
+Drainage flow planning for gravity-based wastewater systems.
+
+Calculates flow directions from each lot towards the
+Wastewater Treatment Plant (WWTP/XLNT) located at the lowest elevation.
+"""
+
+import logging
+import math
+from typing import List, Dict, Any, Optional
+
+from shapely.geometry import Polygon, Point
+
+from core.config.settings import InfrastructureSettings, DEFAULT_SETTINGS
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_drainage(
+    lots: List[Polygon],
+    wwtp_centroid: Optional[Point],
+    arrow_length: Optional[float] = None
+) -> List[Dict[str, Any]]:
+    """
+    Calculate drainage flow direction towards WWTP (gravity flow).
+    
+    Creates directional arrows from each lot centroid pointing
+    towards the wastewater treatment plant.
+    
+    Args:
+        lots: List of lot polygons
+        wwtp_centroid: Location of WWTP (lowest elevation)
+        arrow_length: Visualization arrow length (m)
+        
+    Returns:
+        List of dicts with 'start' and 'vector' keys
+    """
+    settings = DEFAULT_SETTINGS.infrastructure
+    arrow_len = arrow_length or settings.drainage_arrow_length
+    
+    arrows = []
+    
+    if not wwtp_centroid:
+        logger.warning("No WWTP location provided, skipping drainage calculation")
+        return arrows
+    
+    if not lots:
+        return arrows
+    
+    for lot in lots:
+        try:
+            c = lot.centroid
+            
+            # Vector from lot to WWTP
+            dx = wwtp_centroid.x - c.x
+            dy = wwtp_centroid.y - c.y
+            
+            # Calculate length (with safe division)
+            length = math.sqrt(dx * dx + dy * dy)
+            
+            if length > 0:
+                # Normalize vector and scale to arrow length
+                norm_dx = dx / length * arrow_len
+                norm_dy = dy / length * arrow_len
+                
+                arrows.append({
+                    'start': (c.x, c.y),
+                    'vector': (norm_dx, norm_dy)
+                })
+            else:
+                # Lot is at WWTP location (unlikely but handle it)
+                logger.debug("Lot centroid coincides with WWTP")
+                
+        except Exception as e:
+            logger.warning(f"Error calculating drainage for lot: {e}")
+            continue
+    
+    logger.debug(f"Calculated drainage for {len(arrows)} lots")
+    return arrows

algorithms/backend/core/infrastructure/network_planner.py

@@ -0,0 +1,100 @@
+"""
+Electrical network planning using MST with loop redundancy.
+
+Creates a minimum spanning tree network between lots, then adds
+redundant edges for reliability (loop network).
+"""
+
+import logging
+from typing import List, Tuple
+
+import numpy as np
+import networkx as nx
+from shapely.geometry import Polygon, LineString
+
+from core.config.settings import InfrastructureSettings, DEFAULT_SETTINGS
+
+logger = logging.getLogger(__name__)
+
+
+def generate_loop_network(
+    lots: List[Polygon],
+    max_distance: float = None,
+    redundancy_ratio: float = None
+) -> Tuple[List[List[float]], List[LineString]]:
+    """
+    Generate Loop Network for electrical/utility infrastructure.
+    
+    Creates MST (Minimum Spanning Tree) then adds back 15% of edges
+    for redundancy/safety (loop network pattern).
+    
+    Args:
+        lots: List of lot polygons
+        max_distance: Maximum connection distance (m)
+        redundancy_ratio: Extra edges to add (0.0-1.0)
+        
+    Returns:
+        (points, connection_lines) where:
+        - points: List of [x, y] coordinates
+        - connection_lines: List of LineString connections
+    """
+    settings = DEFAULT_SETTINGS.infrastructure
+    max_dist = max_distance or settings.max_connection_distance
+    redundancy = redundancy_ratio or settings.loop_redundancy_ratio
+    
+    if len(lots) < 2:
+        logger.warning("Need at least 2 lots for network generation")
+        return [], []
+    
+    # Get lot centroids
+    centroids = [lot.centroid for lot in lots]
+    points = [[p.x, p.y] for p in centroids]
+    
+    # Build full graph with nearby connections
+    G = nx.Graph()
+    for i, p in enumerate(centroids):
+        G.add_node(i, pos=(p.x, p.y))
+    
+    # Add edges for all pairs within max distance
+    for i in range(len(centroids)):
+        for j in range(i + 1, len(centroids)):
+            dist = centroids[i].distance(centroids[j])
+            if dist < max_dist:
+                G.add_edge(i, j, weight=dist)
+    
+    # Handle disconnected graph
+    if not nx.is_connected(G):
+        components = list(nx.connected_components(G))
+        largest_comp = max(components, key=len)
+        G = G.subgraph(largest_comp).copy()
+        logger.warning(f"Graph disconnected, using largest component ({len(largest_comp)} nodes)")
+    
+    if G.number_of_edges() == 0:
+        logger.warning("No edges in graph")
+        return points, []
+    
+    # Create Minimum Spanning Tree
+    mst = nx.minimum_spanning_tree(G)
+    
+    # Create Loop: Add back redundant edges for safety
+    all_edges = sorted(G.edges(data=True), key=lambda x: x[2]['weight'])
+    loop_graph = mst.copy()
+    
+    target_extra = int(len(lots) * redundancy)
+    added_count = 0
+    
+    for u, v, data in all_edges:
+        if not loop_graph.has_edge(u, v):
+            loop_graph.add_edge(u, v, **data)
+            added_count += 1
+            if added_count >= target_extra:
+                break
+    
+    # Convert to LineStrings
+    connections = []
+    for u, v in loop_graph.edges():
+        if u < len(centroids) and v < len(centroids):
+            connections.append(LineString([centroids[u], centroids[v]]))
+    
+    logger.debug(f"Generated network: {len(connections)} connections, {added_count} redundant")
+    return points, connections

algorithms/backend/core/infrastructure/transformer_planner.py

@@ -0,0 +1,79 @@
+"""
+Transformer station placement using K-Means clustering.
+
+Optimally positions electrical transformer stations to serve
+lots within a defined service radius.
+"""
+
+import logging
+from typing import List, Tuple, Optional
+
+import numpy as np
+from sklearn.cluster import KMeans
+from shapely.geometry import Polygon
+
+from core.config.settings import InfrastructureSettings, DEFAULT_SETTINGS
+
+logger = logging.getLogger(__name__)
+
+
+def generate_transformers(
+    lots: List[Polygon],
+    lots_per_transformer: Optional[int] = None,
+    service_radius: Optional[float] = None
+) -> List[Tuple[float, float]]:
+    """
+    Cluster lots to determine optimal transformer placements.
+    
+    Uses K-Means clustering with dynamic k based on lot count.
+    
+    Args:
+        lots: List of lot polygons
+        lots_per_transformer: Approximate lots per transformer
+        service_radius: Service radius (for reference, not used in clustering)
+        
+    Returns:
+        List of (x, y) transformer locations
+    """
+    settings = DEFAULT_SETTINGS.infrastructure
+    lots_per_tf = lots_per_transformer or settings.lots_per_transformer
+    
+    if not lots:
+        return []
+    
+    if len(lots) == 1:
+        # Single lot - transformer at centroid
+        c = lots[0].centroid
+        return [(c.x, c.y)]
+    
+    # Get lot centroids
+    lot_coords = np.array([
+        [lot.centroid.x, lot.centroid.y] 
+        for lot in lots
+    ])
+    
+    # Calculate number of transformers
+    num_transformers = max(1, len(lots) // lots_per_tf)
+    
+    # Don't exceed number of lots
+    num_transformers = min(num_transformers, len(lots))
+    
+    # K-Means clustering
+    try:
+        kmeans = KMeans(
+            n_clusters=num_transformers, 
+            n_init=10,
+            random_state=42
+        )
+        kmeans.fit(lot_coords)
+        
+        centers = [tuple(c) for c in kmeans.cluster_centers_]
+        logger.debug(f"Placed {len(centers)} transformers for {len(lots)} lots")
+        return centers
+        
+    except Exception as e:
+        logger.error(f"K-Means clustering failed: {e}")
+        # Fallback: centroid of all lots
+        mean_x = np.mean(lot_coords[:, 0])
+        mean_y = np.mean(lot_coords[:, 1])
+        return [(mean_x, mean_y)]

algorithms/backend/core/optimization/__init__.py

@@ -0,0 +1,2 @@
+from core.optimization.grid_optimizer import GridOptimizer
+from core.optimization.subdivision_solver import SubdivisionSolver

algorithms/backend/core/optimization/grid_optimizer.py

@@ -0,0 +1,240 @@
+"""
+Grid layout optimization using NSGA-II genetic algorithm.
+
+Optimizes grid spacing and rotation angle to maximize usable land area
+while minimizing fragmented blocks.
+"""
+
+import random
+import logging
+from typing import List, Tuple, Optional
+
+import numpy as np
+from shapely.geometry import Polygon, Point
+from shapely.affinity import translate, rotate
+from deap import base, creator, tools, algorithms
+
+from core.config.settings import OptimizationSettings, DEFAULT_SETTINGS
+
+logger = logging.getLogger(__name__)
+
+
+class GridOptimizer:
+    """
+    Stage 1: Optimize grid layout using NSGA-II genetic algorithm.
+    
+    Multi-objective optimization:
+    - Maximize residential/commercial area
+    - Minimize fragmented blocks
+    """
+    
+    def __init__(
+        self, 
+        land_polygon: Polygon, 
+        lake_polygon: Optional[Polygon] = None,
+        settings: Optional[OptimizationSettings] = None
+    ):
+        """
+        Initialize grid optimizer.
+        
+        Args:
+            land_polygon: Main land boundary
+            lake_polygon: Water body to exclude (optional)
+            settings: Optimization settings (uses defaults if None)
+        """
+        self.land_poly = land_polygon
+        self.lake_poly = lake_polygon or Polygon()
+        self.settings = settings or DEFAULT_SETTINGS.optimization
+        
+        self._setup_deap()
+    
+    def _setup_deap(self) -> None:
+        """Configure DEAP toolbox for multi-objective optimization."""
+        # Create fitness and individual classes (check if already exists)
+        if not hasattr(creator, "FitnessMulti"):
+            creator.create("FitnessMulti", base.Fitness, weights=(1.0, -1.0))
+        if not hasattr(creator, "Individual"):
+            creator.create("Individual", list, fitness=creator.FitnessMulti)
+        
+        self.toolbox = base.Toolbox()
+        
+        # Gene definitions
+        spacing_min, spacing_max = self.settings.spacing_bounds
+        angle_min, angle_max = self.settings.angle_bounds
+        
+        self.toolbox.register("attr_spacing", random.uniform, spacing_min, spacing_max)
+        self.toolbox.register("attr_angle", random.uniform, angle_min, angle_max)
+        
+        self.toolbox.register(
+            "individual", 
+            tools.initCycle, 
+            creator.Individual,
+            (self.toolbox.attr_spacing, self.toolbox.attr_angle), 
+            n=1
+        )
+        self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual)
+        
+        # Genetic operators
+        self.toolbox.register("evaluate", self._evaluate_layout)
+        self.toolbox.register(
+            "mate", 
+            tools.cxSimulatedBinaryBounded, 
+            low=[spacing_min, angle_min], 
+            up=[spacing_max, angle_max], 
+            eta=self.settings.eta
+        )
+        self.toolbox.register(
+            "mutate", 
+            tools.mutPolynomialBounded, 
+            low=[spacing_min, angle_min], 
+            up=[spacing_max, angle_max], 
+            eta=self.settings.eta, 
+            indpb=0.2
+        )
+        self.toolbox.register("select", tools.selNSGA2)
+    
+    def generate_grid_candidates(
+        self, 
+        spacing: float, 
+        angle_deg: float
+    ) -> List[Polygon]:
+        """
+        Generate grid blocks at given spacing and rotation.
+        
+        Args:
+            spacing: Grid spacing in meters
+            angle_deg: Rotation angle in degrees
+            
+        Returns:
+            List of block polygons
+        """
+        minx, miny, maxx, maxy = self.land_poly.bounds
+        diameter = ((maxx - minx)**2 + (maxy - miny)**2)**0.5
+        center = self.land_poly.centroid
+        
+        # Create grid ranges (extend beyond bounds to cover after rotation)
+        x_range = np.arange(minx - diameter, maxx + diameter, spacing)
+        y_range = np.arange(miny - diameter, maxy + diameter, spacing)
+        
+        blocks = []
+        
+        # Create base block at origin
+        base_block = Polygon([
+            (0, 0), 
+            (spacing, 0), 
+            (spacing, spacing), 
+            (0, spacing)
+        ])
+        base_block = translate(base_block, -spacing/2, -spacing/2)
+        
+        for x in x_range:
+            for y in y_range:
+                # Translate and rotate block
+                poly = translate(base_block, x, y)
+                poly = rotate(poly, angle_deg, origin=center)
+                
+                # Only keep blocks that intersect land
+                if poly.intersects(self.land_poly):
+                    blocks.append(poly)
+        
+        return blocks
+    
+    def _evaluate_layout(self, individual: List[float]) -> Tuple[float, int]:
+        """
+        Evaluate layout fitness.
+        
+        Objectives:
+        1. Maximize residential area (positive weight)
+        2. Minimize fragmented blocks (negative weight)
+        
+        Args:
+            individual: [spacing, angle]
+            
+        Returns:
+            (total_residential_area, fragmented_blocks)
+        """
+        spacing, angle = individual
+        blocks = self.generate_grid_candidates(spacing, angle)
+        
+        total_residential_area = 0.0
+        fragmented_blocks = 0
+        
+        original_area = spacing * spacing
+        
+        for blk in blocks:
+            # Cut with land boundary
+            intersection = blk.intersection(self.land_poly)
+            if intersection.is_empty:
+                continue
+            
+            # Subtract lake/water body
+            usable_part = intersection.difference(self.lake_poly)
+            if usable_part.is_empty:
+                continue
+            
+            # Calculate area ratio
+            ratio = usable_part.area / original_area
+            
+            # Classify block quality
+            if ratio > self.settings.good_block_ratio:
+                # Good block for residential/commercial
+                total_residential_area += usable_part.area
+            elif ratio > self.settings.fragmented_block_ratio:
+                # Fragmented block (penalize)
+                fragmented_blocks += 1
+        
+        return (total_residential_area, fragmented_blocks)
+    
+    def optimize(
+        self, 
+        population_size: Optional[int] = None, 
+        generations: Optional[int] = None
+    ) -> Tuple[List[float], List[List[float]]]:
+        """
+        Run NSGA-II optimization.
+        
+        Args:
+            population_size: Population size (uses settings if None)
+            generations: Number of generations (uses settings if None)
+            
+        Returns:
+            (best_solution, history) where best_solution is [spacing, angle]
+        """
+        pop_size = population_size or self.settings.population_size
+        num_gens = generations or self.settings.generations
+        
+        random.seed(DEFAULT_SETTINGS.random_seed)
+        pop = self.toolbox.population(n=pop_size)
+        
+        history = []
+        
+        # Initial evaluation
+        fits = list(map(self.toolbox.evaluate, pop))
+        for ind, fit in zip(pop, fits):
+            ind.fitness.values = fit
+        
+        # Save best from generation 0
+        best_ind = tools.selBest(pop, 1)[0]
+        history.append(list(best_ind))
+        
+        # Evolution loop
+        for gen in range(num_gens):
+            offspring = algorithms.varAnd(
+                pop, 
+                self.toolbox, 
+                cxpb=self.settings.crossover_probability, 
+                mutpb=self.settings.mutation_probability
+            )
+            fits = list(map(self.toolbox.evaluate, offspring))
+            for ind, fit in zip(offspring, fits):
+                ind.fitness.values = fit
+            pop = self.toolbox.select(pop + offspring, k=len(pop))
+            
+            # Track best solution per generation
+            best_ind = tools.selBest(pop, 1)[0]
+            history.append(list(best_ind))
+        
+        final_best = tools.selBest(pop, 1)[0]
+        logger.info(f"Optimization complete: spacing={final_best[0]:.2f}, angle={final_best[1]:.2f}")
+        
+        return list(final_best), history

algorithms/backend/core/optimization/subdivision_solver.py

@@ -0,0 +1,222 @@
+"""
+Block subdivision solver using OR-Tools constraint programming.
+
+Optimizes lot widths within blocks to meet target dimensions while
+respecting minimum/maximum constraints.
+"""
+
+import logging
+from typing import List, Dict, Any, Optional
+
+import numpy as np
+from shapely.geometry import Polygon
+from ortools.sat.python import cp_model
+
+from core.config.settings import SubdivisionSettings, DEFAULT_SETTINGS
+
+logger = logging.getLogger(__name__)
+
+
+class SubdivisionSolver:
+    """
+    Stage 2: Optimize block subdivision using OR-Tools CP-SAT solver.
+    
+    Solves for optimal lot widths that:
+    - Sum to total available length
+    - Stay within min/max bounds
+    - Minimize deviation from target width
+    """
+    
+    @staticmethod
+    def solve_subdivision(
+        total_length: float, 
+        min_width: float, 
+        max_width: float, 
+        target_width: float, 
+        time_limit: float = 5.0
+    ) -> List[float]:
+        """
+        Solve optimal lot widths using constraint programming.
+        
+        Args:
+            total_length: Total length to subdivide
+            min_width: Minimum lot width
+            max_width: Maximum lot width
+            target_width: Target lot width
+            time_limit: Solver time limit in seconds
+            
+        Returns:
+            List of lot widths
+        """
+        # Input validation
+        if total_length <= 0:
+            logger.warning("Total length must be positive")
+            return []
+        if min_width <= 0:
+            logger.warning("Minimum width must be positive")
+            return []
+        if total_length < min_width:
+            logger.warning(f"Total length ({total_length}) < min width ({min_width})")
+            return []
+        if min_width > max_width:
+            logger.warning("Min width > max width")
+            return []
+        if target_width < min_width or target_width > max_width:
+            target_width = (min_width + max_width) / 2
+            logger.info(f"Target width adjusted to {target_width}")
+        
+        model = cp_model.CpModel()
+        
+        # Estimate number of lots
+        max_lots = int(total_length / min_width) + 1
+        
+        # Decision variables: lot widths (scaled to integers for CP)
+        scale = 100  # 1cm precision
+        lot_vars = [
+            model.NewIntVar(
+                int(min_width * scale), 
+                int(max_width * scale), 
+                f'lot_{i}'
+            )
+            for i in range(max_lots)
+        ]
+        
+        # Used lot indicators
+        used = [model.NewBoolVar(f'used_{i}') for i in range(max_lots)]
+        
+        # Constraint: Sum of widths equals total length
+        model.Add(
+            sum(lot_vars[i] for i in range(max_lots)) == int(total_length * scale)
+        )
+        
+        # Constraint: Lot ordering (if used[i], then used[i-1] must be true)
+        for i in range(1, max_lots):
+            model.Add(used[i] <= used[i-1])
+        
+        # Constraint: Connect lot values to usage
+        for i in range(max_lots):
+            model.Add(lot_vars[i] >= int(min_width * scale)).OnlyEnforceIf(used[i])
+            model.Add(lot_vars[i] == 0).OnlyEnforceIf(used[i].Not())
+        
+        # Objective: Minimize deviation from target
+        deviations = [
+            model.NewIntVar(0, int((max_width - min_width) * scale), f'dev_{i}')
+            for i in range(max_lots)
+        ]
+        
+        target_scaled = int(target_width * scale)
+        for i in range(max_lots):
+            model.AddAbsEquality(deviations[i], lot_vars[i] - target_scaled)
+        
+        model.Minimize(sum(deviations))
+        
+        # Solve
+        solver = cp_model.CpSolver()
+        solver.parameters.max_time_in_seconds = time_limit
+        status = solver.Solve(model)
+        
+        # Extract solution
+        if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+            widths = []
+            for i in range(max_lots):
+                if solver.Value(used[i]):
+                    widths.append(solver.Value(lot_vars[i]) / scale)
+            logger.debug(f"Subdivision solved: {len(widths)} lots")
+            return widths
+        else:
+            # Fallback: uniform division
+            logger.warning("CP solver failed, using uniform fallback")
+            num_lots = max(1, int(total_length / target_width))
+            return [total_length / num_lots] * num_lots
+    
+    @staticmethod
+    def subdivide_block(
+        block_geom: Polygon, 
+        spacing: float, 
+        min_width: float, 
+        max_width: float, 
+        target_width: float, 
+        time_limit: float = 5.0,
+        setback_dist: float = 6.0
+    ) -> Dict[str, Any]:
+        """
+        Subdivide a block into lots.
+        
+        Args:
+            block_geom: Block geometry
+            spacing: Grid spacing (for quality calculation)
+            min_width: Minimum lot width
+            max_width: Maximum lot width
+            target_width: Target lot width
+            time_limit: Solver time limit
+            setback_dist: Building setback distance
+            
+        Returns:
+            Dictionary with subdivision info:
+            - geometry: Original block
+            - type: 'residential' or 'park'
+            - lots: List of lot info dicts
+        """
+        # Determine block quality
+        original_area = spacing * spacing
+        current_area = block_geom.area
+        
+        # Safety check for division
+        if original_area <= 0:
+            ratio = 0.0
+        else:
+            ratio = current_area / original_area
+        
+        result = {
+            'geometry': block_geom,
+            'type': 'unknown',
+            'lots': []
+        }
+        
+        # Fragmented blocks become parks
+        if ratio < 0.6:
+            result['type'] = 'park'
+            return result
+        
+        # Good blocks become residential/commercial
+        result['type'] = 'residential'
+        
+        # Solve subdivision
+        minx, miny, maxx, maxy = block_geom.bounds
+        total_width = maxx - minx
+        
+        # Adaptive time limit based on block size
+        adaptive_time = min(time_limit, max(0.5, total_width / 100))
+        
+        lot_widths = SubdivisionSolver.solve_subdivision(
+            total_width, min_width, max_width, target_width, adaptive_time
+        )
+        
+        # Create lot geometries
+        current_x = minx
+        
+        for width in lot_widths:
+            lot_poly = Polygon([
+                (current_x, miny),
+                (current_x + width, miny),
+                (current_x + width, maxy),
+                (current_x, maxy)
+            ])
+            
+            # Clip to block boundary
+            clipped = lot_poly.intersection(block_geom)
+            if not clipped.is_empty and clipped.geom_type == 'Polygon':
+                # Calculate setback (buildable area)
+                buildable = clipped.buffer(-setback_dist)
+                if buildable.is_empty or not buildable.is_valid:
+                    buildable = None
+                
+                result['lots'].append({
+                    'geometry': clipped,
+                    'width': width,
+                    'buildable': buildable
+                })
+            
+            current_x += width
+        
+        return result

algorithms/backend/main.py

@@ -1,34 +1,43 @@
 """FastAPI application entry point."""
 
+import logging
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from routes import router
-from models import HealthResponse
+from api.schemas.response_schemas import HealthResponse
+from api.routes import optim_router, dxf_router
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 app = FastAPI(
     title="Land Redistribution Algorithm API",
     description="API for testing land subdivision and redistribution algorithms",
-    version="1.0.0"
+    version="2.0.0"
 )
 
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Allow all origins for development
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
 # Include routes
-app.include_router(router, prefix="/api")
+app.include_router(optim_router, prefix="/api")
+app.include_router(dxf_router, prefix="/api")
 
 
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
     """Health check endpoint."""
-    return HealthResponse(status="healthy", version="1.0.0")
+    return HealthResponse(status="healthy", version="2.0.0")
 
 
 @app.get("/")
@@ -36,7 +45,13 @@ async def root():
     """Root endpoint with API information."""
     return {
         "message": "Land Redistribution Algorithm API",
-        "version": "1.0.0",
+        "version": "2.0.0",
         "docs": "/docs",
         "health": "/health"
     }
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Log startup information."""
+    logger.info("Land Redistribution API started (v2.0.0 - Modular Architecture)")

algorithms/backend/pipeline/__init__.py

@@ -0,0 +1 @@
+from pipeline.land_redistribution import LandRedistributionPipeline

algorithms/backend/pipeline/land_redistribution.py

@@ -0,0 +1,358 @@
+"""
+Main land redistribution pipeline orchestration.
+
+Coordinates all stages of the optimization pipeline:
+1. Road network generation (Voronoi or Grid-based)
+2. Block subdivision (OR-Tools)
+3. Infrastructure planning (MST, Transformers, Drainage)
+"""
+
+import logging
+import random
+from typing import List, Dict, Any, Tuple, Optional
+
+import numpy as np
+from shapely.geometry import Polygon, Point, mapping
+from shapely.ops import unary_union
+
+from core.config.settings import (
+    AlgorithmSettings, 
+    DEFAULT_SETTINGS,
+    ROAD_MAIN_WIDTH,
+    ROAD_INTERNAL_WIDTH,
+    SIDEWALK_WIDTH,
+    TURNING_RADIUS,
+    SERVICE_AREA_RATIO,
+    MIN_BLOCK_AREA,
+)
+from core.geometry.polygon_utils import (
+    get_elevation,
+    normalize_geometry_list,
+    filter_by_min_area,
+    sort_by_elevation,
+)
+from core.geometry.voronoi import (
+    generate_voronoi_seeds,
+    create_voronoi_diagram,
+    extract_voronoi_edges,
+    classify_road_type,
+    create_road_buffer,
+)
+from core.optimization.grid_optimizer import GridOptimizer
+from core.optimization.subdivision_solver import SubdivisionSolver
+from core.infrastructure.network_planner import generate_loop_network
+from core.infrastructure.transformer_planner import generate_transformers
+from core.infrastructure.drainage_planner import calculate_drainage
+
+logger = logging.getLogger(__name__)
+
+
+class LandRedistributionPipeline:
+    """
+    Main pipeline orchestrating all optimization stages.
+    
+    Supports two modes:
+    1. Voronoi-based road network (default, more organic layout)
+    2. Grid-based optimization using NSGA-II (fallback)
+    """
+    
+    def __init__(
+        self, 
+        land_polygons: List[Polygon], 
+        config: Dict[str, Any],
+        settings: Optional[AlgorithmSettings] = None
+    ):
+        """
+        Initialize pipeline.
+        
+        Args:
+            land_polygons: Input land plots
+            config: API configuration dictionary
+            settings: Algorithm settings (optional)
+        """
+        self.land_poly = unary_union(land_polygons)
+        self.config = config
+        self.settings = settings or AlgorithmSettings.from_dict(config)
+        self.lake_poly = Polygon()  # No lake by default
+        
+        logger.info(f"Pipeline initialized with land area: {self.land_poly.area:.2f} m²")
+    
+    def generate_road_network(
+        self, 
+        num_seeds: int = 15
+    ) -> Tuple[Polygon, List[Polygon], List[Polygon]]:
+        """
+        Generate road network using Voronoi diagram.
+        
+        Args:
+            num_seeds: Number of Voronoi seed points
+            
+        Returns:
+            (road_network, service_blocks, commercial_blocks)
+        """
+        site = self.land_poly
+        
+        # Generate Voronoi seeds
+        seeds = generate_voronoi_seeds(site, num_seeds)
+        
+        # Create Voronoi diagram
+        regions = create_voronoi_diagram(seeds, site)
+        if regions is None:
+            logger.warning("Voronoi generation failed, returning empty")
+            return Polygon(), [], [site]
+        
+        # Extract edges
+        edges = extract_voronoi_edges(regions)
+        if not edges:
+            return Polygon(), [], [site]
+        
+        # Create road buffers
+        center = site.centroid
+        road_polys = []
+        
+        for line in edges:
+            road_type = classify_road_type(line, center)
+            road_buffer = create_road_buffer(
+                line, 
+                road_type,
+                main_width=ROAD_MAIN_WIDTH,
+                internal_width=ROAD_INTERNAL_WIDTH,
+                sidewalk_width=SIDEWALK_WIDTH
+            )
+            road_polys.append(road_buffer)
+        
+        if not road_polys:
+            return Polygon(), [], [site]
+        
+        # Merge road network
+        network_poly = unary_union(road_polys)
+        
+        # Apply turning radius smoothing
+        smooth_network = network_poly.buffer(
+            TURNING_RADIUS, join_style=1
+        ).buffer(-TURNING_RADIUS, join_style=1)
+        
+        # Extract blocks (land minus roads)
+        blocks_rough = site.difference(smooth_network)
+        candidates = normalize_geometry_list(blocks_rough)
+        
+        # Filter by minimum area
+        valid_blocks = filter_by_min_area(candidates, MIN_BLOCK_AREA)
+        
+        if not valid_blocks:
+            return smooth_network, [], []
+        
+        # Sort by elevation (lowest first for WWTP)
+        sorted_blocks = sort_by_elevation(valid_blocks)
+        
+        # Allocate service areas (10% of total)
+        total_area = sum(b.area for b in valid_blocks)
+        service_target = total_area * SERVICE_AREA_RATIO
+        
+        service_blocks = []
+        commercial_blocks = []
+        accumulated = 0.0
+        
+        for block in sorted_blocks:
+            if accumulated < service_target:
+                service_blocks.append(block)
+                accumulated += block.area
+            else:
+                commercial_blocks.append(block)
+        
+        # Ensure at least one commercial block
+        if not commercial_blocks and service_blocks:
+            commercial_blocks.append(service_blocks.pop())
+        
+        logger.info(f"Road network: {len(service_blocks)} service, {len(commercial_blocks)} commercial blocks")
+        return smooth_network, service_blocks, commercial_blocks
+    
+    def run_stage1(self) -> Dict[str, Any]:
+        """Run grid optimization stage (NSGA-II)."""
+        optimizer = GridOptimizer(self.land_poly, self.lake_poly)
+        
+        best_solution, history = optimizer.optimize(
+            population_size=self.config.get('population_size', 30),
+            generations=self.config.get('generations', 15)
+        )
+        
+        spacing, angle = best_solution
+        blocks = optimizer.generate_grid_candidates(spacing, angle)
+        
+        # Filter to usable blocks
+        usable_blocks = []
+        for blk in blocks:
+            intersection = blk.intersection(self.land_poly).difference(self.lake_poly)
+            if not intersection.is_empty:
+                usable_blocks.append(intersection)
+        
+        return {
+            'spacing': spacing,
+            'angle': angle,
+            'blocks': usable_blocks,
+            'history': history,
+            'metrics': {
+                'total_blocks': len(usable_blocks),
+                'optimal_spacing': spacing,
+                'optimal_angle': angle
+            }
+        }
+    
+    def run_stage2(
+        self, 
+        blocks: List[Polygon], 
+        spacing: float
+    ) -> Dict[str, Any]:
+        """Run subdivision stage (OR-Tools)."""
+        all_lots = []
+        parks = []
+        
+        for block in blocks:
+            result = SubdivisionSolver.subdivide_block(
+                block,
+                spacing,
+                self.config.get('min_lot_width', 20.0),
+                self.config.get('max_lot_width', 80.0),
+                self.config.get('target_lot_width', 40.0),
+                self.config.get('ortools_time_limit', 5)
+            )
+            
+            if result['type'] == 'park':
+                parks.append(result['geometry'])
+            else:
+                all_lots.extend(result['lots'])
+        
+        avg_width = np.mean([lot['width'] for lot in all_lots]) if all_lots else 0
+        
+        return {
+            'lots': all_lots,
+            'parks': parks,
+            'metrics': {
+                'total_lots': len(all_lots),
+                'total_parks': len(parks),
+                'avg_lot_width': avg_width
+            }
+        }
+    
+    def classify_blocks(
+        self, 
+        blocks: List[Polygon]
+    ) -> Dict[str, List[Polygon]]:
+        """Classify blocks into service and commercial categories."""
+        if not blocks:
+            return {'service': [], 'commercial': [], 'xlnt': []}
+        
+        sorted_blocks = sort_by_elevation(blocks)
+        
+        total_area = sum(b.area for b in blocks)
+        service_target = total_area * SERVICE_AREA_RATIO
+        accumulated = 0.0
+        
+        xlnt_block = []
+        service_blocks = []
+        commercial_blocks = []
+        
+        # Lowest block is XLNT (Wastewater Treatment)
+        if sorted_blocks:
+            xlnt = sorted_blocks.pop(0)
+            xlnt_block.append(xlnt)
+            accumulated += xlnt.area
+        
+        # Fill remaining service quota
+        for b in sorted_blocks:
+            if accumulated < service_target:
+                service_blocks.append(b)
+                accumulated += b.area
+            else:
+                commercial_blocks.append(b)
+        
+        return {
+            'xlnt': xlnt_block,
+            'service': service_blocks,
+            'commercial': commercial_blocks
+        }
+    
+    def run_full_pipeline(self) -> Dict[str, Any]:
+        """Run complete optimization pipeline with Voronoi road generation."""
+        logger.info("Starting full pipeline...")
+        
+        # Stage 0: Voronoi Road Network
+        road_network, service_blocks_voronoi, commercial_blocks_voronoi = \
+            self.generate_road_network(num_seeds=15)
+        
+        # Fallback to grid-based if Voronoi fails
+        if not commercial_blocks_voronoi:
+            logger.info("Voronoi failed, using grid-based approach")
+            stage1_result = self.run_stage1()
+            classification = self.classify_blocks(stage1_result['blocks'])
+            commercial_blocks_voronoi = classification['commercial']
+            service_blocks_voronoi = classification['service']
+            xlnt_blocks = classification['xlnt']
+            all_blocks = stage1_result['blocks']
+            road_network = self.land_poly.difference(unary_union(all_blocks))
+            spacing_for_subdivision = stage1_result['spacing']
+        else:
+            # Separate XLNT from service blocks
+            if service_blocks_voronoi:
+                xlnt_blocks = [service_blocks_voronoi[0]]
+                service_blocks_voronoi = service_blocks_voronoi[1:]
+            else:
+                xlnt_blocks = []
+            
+            # Estimate spacing for subdivision
+            if commercial_blocks_voronoi:
+                avg_area = sum(b.area for b in commercial_blocks_voronoi) / len(commercial_blocks_voronoi)
+                spacing_for_subdivision = max(20.0, (avg_area ** 0.5) * 0.7)
+            else:
+                spacing_for_subdivision = 25.0
+        
+        # Stage 2: Subdivision
+        stage2_result = self.run_stage2(
+            commercial_blocks_voronoi,
+            spacing_for_subdivision
+        )
+        
+        # Collect all polygons for infrastructure
+        all_network_nodes = stage2_result['lots'] + \
+            [{'geometry': b, 'type': 'service'} for b in service_blocks_voronoi] + \
+            [{'geometry': b, 'type': 'xlnt'} for b in xlnt_blocks]
+        
+        infra_polys = [item['geometry'] for item in all_network_nodes]
+        
+        # Stage 3: Infrastructure
+        points, connections = generate_loop_network(infra_polys)
+        transformers = generate_transformers(infra_polys)
+        
+        wwtp_center = xlnt_blocks[0].centroid if xlnt_blocks else None
+        drainage = calculate_drainage(infra_polys, wwtp_center)
+        
+        logger.info(f"Pipeline complete: {len(stage2_result['lots'])} lots, {len(connections)} connections")
+        
+        return {
+            'stage1': {
+                'blocks': commercial_blocks_voronoi + service_blocks_voronoi + xlnt_blocks,
+                'metrics': {
+                    'total_blocks': len(commercial_blocks_voronoi) + len(service_blocks_voronoi) + len(xlnt_blocks)
+                },
+                'spacing': spacing_for_subdivision,
+                'angle': 0.0
+            },
+            'stage2': stage2_result,
+            'classification': {
+                'xlnt_count': len(xlnt_blocks),
+                'service_count': len(service_blocks_voronoi),
+                'commercial_count': len(commercial_blocks_voronoi),
+                'xlnt': xlnt_blocks,
+                'service': service_blocks_voronoi
+            },
+            'stage3': {
+                'points': points,
+                'connections': [list(line.coords) for line in connections],
+                'drainage': drainage,
+                'transformers': transformers,
+                'road_network': mapping(road_network)
+            },
+            'total_lots': stage2_result['metrics']['total_lots'],
+            'service_blocks': [list(b.exterior.coords) for b in service_blocks_voronoi],
+            'xlnt_blocks': [list(b.exterior.coords) for b in xlnt_blocks]
+        }

algorithms/backend/test_basic.py

@@ -3,7 +3,6 @@
 import sys
 import traceback
 
-
 def test_imports():
     """Test that all required packages can be imported."""
     print("Testing imports...")
@@ -16,6 +15,12 @@ def test_imports():
         import matplotlib
         import ortools
         import deap
+        
+        # Test new module imports
+        from core.optimization.grid_optimizer import GridOptimizer
+        from core.optimization.subdivision_solver import SubdivisionSolver
+        from pipeline.land_redistribution import LandRedistributionPipeline
+        
         print("✅ All imports successful")
         return True
     except ImportError as e:
@@ -28,7 +33,8 @@ def test_algorithm():
     print("\nTesting algorithm...")
     try:
         from shapely.geometry import Polygon
-        from algorithm import GridOptimizer, SubdivisionSolver
+        from core.optimization.grid_optimizer import GridOptimizer
+        from core.optimization.subdivision_solver import SubdivisionSolver
         
         # Create simple test polygon
         land_poly = Polygon([(0, 0), (100, 0), (100, 100), (0, 100)])
@@ -54,7 +60,7 @@ def test_api_models():
     """Test Pydantic models."""
     print("\nTesting API models...")
     try:
-        from models import AlgorithmConfig, LandPlot, OptimizationRequest
+        from api.schemas.request_schemas import AlgorithmConfig, LandPlot, OptimizationRequest
         
         # Create test config
         config = AlgorithmConfig()
@@ -81,7 +87,7 @@ def test_api_models():
 
 if __name__ == "__main__":
     print("=" * 50)
-    print("Algorithm Backend Test Suite")
+    print("Algorithm Backend Test Suite (Modular Architecture)")
     print("=" * 50)
     
     results = []

algorithms/backend/{dxf_utils.py → utils/dxf_utils.py}

@@ -109,22 +109,45 @@ def export_to_dxf(geometries: List[dict], output_type: str = 'final') -> bytes:
             # Get coordinates
             if geom and 'coordinates' in geom:
                 coords = geom['coordinates']
-                if coords and len(coords) > 0:
-                    points = coords[0]  # Exterior ring
-                    
-                    # Add as LWPOLYLINE
-                    if len(points) >= 3:
-                        # Convert to 2D points (x, y)
-                        points_2d = [(p[0], p[1]) for p in points]
-                        
-                        # Create closed polyline
-                        msp.add_lwpolyline(
-                            points_2d,
-                            dxfattribs={
-                                'layer': layer,
-                                'closed': True
-                            }
+                geom_geom_type = geom.get('type', 'Polygon')
+                
+                # Handle different geometry types
+                if geom_geom_type == 'Point':
+                    # Point: [x, y]
+                    if isinstance(coords, list) and len(coords) >= 2:
+                        msp.add_circle(
+                            center=(coords[0], coords[1]),
+                            radius=2.0,
+                            dxfattribs={'layer': layer}
                         )
+                elif geom_geom_type == 'LineString':
+                    # LineString: [[x1, y1], [x2, y2], ...]
+                    if isinstance(coords, list) and len(coords) > 0:
+                        if all(isinstance(p, (list, tuple)) and len(p) >= 2 for p in coords):
+                            points_2d = [(p[0], p[1]) for p in coords]
+                            if len(points_2d) >= 2:
+                                msp.add_lwpolyline(
+                                    points_2d,
+                                    dxfattribs={'layer': layer, 'closed': False}
+                                )
+                elif geom_geom_type == 'Polygon':
+                    # Polygon: [[[x1, y1], [x2, y2], ...]]  (exterior ring)
+                    if isinstance(coords, list) and len(coords) > 0:
+                        points = coords[0] if isinstance(coords[0], list) else coords
+                        
+                        # Validate points structure
+                        if isinstance(points, list) and len(points) >= 3:
+                            if all(isinstance(p, (list, tuple)) and len(p) >= 2 for p in points):
+                                points_2d = [(p[0], p[1]) for p in points]
+                                
+                                # Create closed polyline
+                                msp.add_lwpolyline(
+                                    points_2d,
+                                    dxfattribs={
+                                        'layer': layer,
+                                        'closed': True
+                                    }
+                                )
         
         # Save to bytes
         stream = io.StringIO()