{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "6a583153",
      "metadata": {
        "id": "6a583153"
      },
      "source": [
        "# REMB Production Algorithm - Final Reliable Version\n",
        "\n",
        "This notebook combines the **robust and verified algorithms** from `Bản_sao_của_algo (1).ipynb` with the **file upload and DXF export capabilities** from `REMB_Production_Complete.ipynb`.\n",
        "\n",
        "**Features:**\n",
        "- **Reliable Core Logic:** Uses the specific Voronoi and OR-Tools implementation that has been tested and confirmed working.\n",
        "- **Input Flexibility:** Upload DWG/DXF files or generate a random site for testing.\n",
        "- **Output Capability:** Exports results to DXF (CAD) and JSON formats.\n",
        "- **Infrastructure Planning:** Includes electrical loop networks and drainage flow analysis."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "825b1b79",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: shapely in ./venv/lib/python3.11/site-packages (2.0.2)\n",
            "Requirement already satisfied: matplotlib in ./venv/lib/python3.11/site-packages (3.8.2)\n",
            "Requirement already satisfied: networkx in ./venv/lib/python3.11/site-packages (3.6)\n",
            "Requirement already satisfied: ortools in ./venv/lib/python3.11/site-packages (9.8.3296)\n",
            "Requirement already satisfied: scikit-learn in ./venv/lib/python3.11/site-packages (1.7.2)\n",
            "Requirement already satisfied: scipy in ./venv/lib/python3.11/site-packages (1.16.3)\n",
            "Requirement already satisfied: numpy in ./venv/lib/python3.11/site-packages (1.26.2)\n",
            "Requirement already satisfied: ezdxf in ./venv/lib/python3.11/site-packages (1.4.3)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in ./venv/lib/python3.11/site-packages (from matplotlib) (1.3.3)\n",
            "Requirement already satisfied: cycler>=0.10 in ./venv/lib/python3.11/site-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in ./venv/lib/python3.11/site-packages (from matplotlib) (4.61.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in ./venv/lib/python3.11/site-packages (from matplotlib) (1.4.9)\n",
            "Requirement already satisfied: packaging>=20.0 in ./venv/lib/python3.11/site-packages (from matplotlib) (23.2)\n",
            "Requirement already satisfied: pillow>=8 in ./venv/lib/python3.11/site-packages (from matplotlib) (10.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in ./venv/lib/python3.11/site-packages (from matplotlib) (3.2.5)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in ./venv/lib/python3.11/site-packages (from matplotlib) (2.9.0.post0)\n",
            "Requirement already satisfied: absl-py>=2.0.0 in ./venv/lib/python3.11/site-packages (from ortools) (2.3.1)\n",
            "Requirement already satisfied: pandas>=2.0.0 in ./venv/lib/python3.11/site-packages (from ortools) (2.1.4)\n",
            "Requirement already satisfied: protobuf>=4.25.0 in ./venv/lib/python3.11/site-packages (from ortools) (4.25.8)\n",
            "Requirement already satisfied: joblib>=1.2.0 in ./venv/lib/python3.11/site-packages (from scikit-learn) (1.5.2)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in ./venv/lib/python3.11/site-packages (from scikit-learn) (3.6.0)\n",
            "Requirement already satisfied: typing_extensions>=4.6.0 in ./venv/lib/python3.11/site-packages (from ezdxf) (4.15.0)\n",
            "Requirement already satisfied: pytz>=2020.1 in ./venv/lib/python3.11/site-packages (from pandas>=2.0.0->ortools) (2025.2)\n",
            "Requirement already satisfied: tzdata>=2022.1 in ./venv/lib/python3.11/site-packages (from pandas>=2.0.0->ortools) (2025.2)\n",
            "Requirement already satisfied: six>=1.5 in ./venv/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
            "\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.2.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.3\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ]
        }
      ],
      "source": [
        "pip install shapely matplotlib networkx ortools scikit-learn scipy numpy ezdxf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "6014b070",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6014b070",
        "outputId": "33afba78-0d64-47a6-95c9-1e6442fc6622"
      },
      "outputs": [],
      "source": [
        "# Install LibreDWG for DWG conversion (Linux/Colab)\n",
        "import platform\n",
        "if platform.system() == 'Linux':\n",
        "    !apt-get update -qq && apt-get install -y -qq libredwg-tools\n",
        "    print(\"✅ LibreDWG installed for DWG conversion\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "3734c8f8",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3734c8f8",
        "outputId": "bf8b8ce7-6ba2-43f9-ae6a-49affa8b296a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "✅ Configuration loaded successfully\n"
          ]
        }
      ],
      "source": [
        "# 2. IMPORTS & CONFIGURATION\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from shapely.geometry import Polygon, Point, MultiPolygon, LineString, MultiLineString\n",
        "from shapely.ops import unary_union, voronoi_diagram\n",
        "from shapely import affinity\n",
        "import networkx as nx\n",
        "from ortools.sat.python import cp_model\n",
        "from sklearn.cluster import KMeans\n",
        "from scipy.spatial import Voronoi\n",
        "import random, math, os, json, subprocess\n",
        "from datetime import datetime\n",
        "\n",
        "# ==========================================\n",
        "# CẤU HÌNH TIÊU CHUẨN KCN (PRODUCTION CONFIG)\n",
        "# (Taken from Bản_sao_của_algo (1).ipynb)\n",
        "# ==========================================\n",
        "\n",
        "# --- A. Giao thông & Quy hoạch ---\n",
        "ROAD_MAIN_WIDTH = 30.0      # Đường trục chính (m) - Xe container tránh nhau thoải mái\n",
        "ROAD_INTERNAL_WIDTH = 15.0  # Đường nội bộ (m)\n",
        "SIDEWALK_WIDTH = 4.0        # Vỉa hè mỗi bên (m) - Chứa hào kỹ thuật\n",
        "TURNING_RADIUS = 15.0       # Bán kính cua xe Container (m) - Vạt góc ngã tư\n",
        "\n",
        "# --- B. Đất đai & Phân khu chức năng ---\n",
        "SERVICE_AREA_RATIO = 0.10   # 10% đất dành cho Hạ tầng (Nhà điều hành, XLNT, bãi xe)\n",
        "MIN_BLOCK_AREA = 5000       # Diện tích block tối thiểu để chia lô (m2)\n",
        "\n",
        "# --- C. Pháp lý & Xây dựng (TCVN) ---\n",
        "SETBACK_DISTANCE = 6.0      # Chỉ giới xây dựng lùi vào so với chỉ giới đường đỏ (m)\n",
        "FIRE_SAFETY_GAP = 4.0       # Khoảng cách PCCC giữa các nhà xưởng (nếu cần)\n",
        "\n",
        "# --- D. Chia lô (OR-Tools) ---\n",
        "MIN_LOT_WIDTH = 20.0        # Mặt tiền tối thiểu lô công nghiệp\n",
        "MAX_LOT_WIDTH = 80.0\n",
        "TARGET_LOT_WIDTH = 40.0\n",
        "SOLVER_TIME_LIMIT = 2     # [QUAN TRỌNG] Giới hạn 0.5s mỗi block để tránh treo máy\n",
        "\n",
        "# --- E. Hạ tầng kỹ thuật ---\n",
        "TRANSFORMER_RADIUS = 300    # Bán kính phục vụ hiệu quả của 1 trạm biến áp (m)\n",
        "\n",
        "print(\"✅ Configuration loaded successfully\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "8f04b1c9",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8f04b1c9",
        "outputId": "ddda50ba-ff9d-407b-c6d7-67c23c2fb90f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "✅ Helper functions ready\n"
          ]
        }
      ],
      "source": [
        "# 3. HELPER FUNCTIONS (DWG/DXF)\n",
        "\n",
        "def convert_dwg_to_dxf(dwg_path, output_path=None):\n",
        "    \"\"\"Convert DWG to DXF using LibreDWG.\"\"\"\n",
        "    if output_path is None:\n",
        "        output_path = os.path.splitext(dwg_path)[0] + \".dxf\"\n",
        "\n",
        "    try:\n",
        "        result = subprocess.run([\"dwg2dxf\", \"-o\", output_path, dwg_path],\n",
        "                                capture_output=True, text=True, timeout=60)\n",
        "        if result.returncode == 0 and os.path.exists(output_path):\n",
        "            print(f\"✅ DWG converted: {output_path}\")\n",
        "            return output_path\n",
        "    except:\n",
        "        pass\n",
        "\n",
        "    print(f\"⚠️ DWG conversion not available. Please convert {dwg_path} to DXF manually.\")\n",
        "    return None\n",
        "\n",
        "def load_boundary_from_dxf(dxf_path):\n",
        "    \"\"\"Load cadastral boundary from DXF file\"\"\"\n",
        "    try:\n",
        "        import ezdxf\n",
        "        doc = ezdxf.readfile(dxf_path)\n",
        "        msp = doc.modelspace()\n",
        "        largest = None\n",
        "        max_area = 0\n",
        "        for entity in msp:\n",
        "            if entity.dxftype() == 'LWPOLYLINE' and entity.is_closed:\n",
        "                pts = list(entity.get_points(format='xy'))\n",
        "                if len(pts) >= 3:\n",
        "                    poly = Polygon(pts)\n",
        "                    if poly.is_valid and poly.area > max_area:\n",
        "                        max_area = poly.area\n",
        "                        largest = poly\n",
        "        if largest:\n",
        "            print(f\"✅ Boundary loaded: {largest.area/10000:.2f} ha\")\n",
        "            return largest, doc\n",
        "    except Exception as e:\n",
        "        print(f\"❌ Error: {e}\")\n",
        "    return None, None\n",
        "\n",
        "def create_random_site():\n",
        "    # Tạo một đa giác ngẫu nhiên đại diện cho KCN (~50 ha)\n",
        "    angles = np.sort(np.random.rand(8) * 2 * np.pi)\n",
        "    radii = 400 + np.random.rand(8) * 200\n",
        "    points = np.c_[radii * np.cos(angles), radii * np.sin(angles)]\n",
        "    site = Polygon(points)\n",
        "    return site\n",
        "\n",
        "def get_elevation(x, y):\n",
        "    # Hàm giả lập địa hình: Nghiêng từ Tây Bắc xuống Đông Nam\n",
        "    # z = 100 - 0.05x - 0.03y (ví dụ)\n",
        "    return 50.0 - (x * 0.02) - (y * 0.03)\n",
        "\n",
        "print(\"✅ Helper functions ready\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "b8c994fe",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 982
        },
        "id": "b8c994fe",
        "outputId": "542bf2c0-854a-48f9-9efc-8c40b51bf153"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "💻 Phát hiện môi trường Local.\n",
            "📁 Đang mở cửa sổ chọn file...\n",
            "✅ DXF loaded: /Users/nxc/Downloads/Lot Plan Bel air Technical Description.dxf\n",
            "✅ Boundary loaded: 60264.00 ha\n",
            "Site Area: 60264.00 ha\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x1000 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import os\n",
        "import sys\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Giả định hàm convert và load đã được định nghĩa ở các bước trước\n",
        "# from your_module import convert_dwg_to_dxf, load_boundary_from_dxf, create_random_site\n",
        "\n",
        "# 4. INPUT HANDLING: UPLOAD OR RANDOM SITE\n",
        "\n",
        "DXF_PATH = None\n",
        "original_doc = None\n",
        "\n",
        "def select_file_local():\n",
        "    \"\"\"Hàm mở cửa sổ chọn file khi chạy Local\"\"\"\n",
        "    try:\n",
        "        import tkinter as tk\n",
        "        from tkinter import filedialog\n",
        "        \n",
        "        # Tạo cửa sổ gốc nhưng ẩn đi\n",
        "        root = tk.Tk()\n",
        "        root.withdraw()\n",
        "        # Cố gắng đưa cửa sổ lên trên cùng\n",
        "        root.call('wm', 'attributes', '.', '-topmost', True)\n",
        "        \n",
        "        print(\"📁 Đang mở cửa sổ chọn file...\")\n",
        "        file_path = filedialog.askopenfilename(\n",
        "            title=\"Chọn file DWG hoặc DXF\",\n",
        "            filetypes=[(\"CAD Files\", \"*.dwg *.dxf\"), (\"All Files\", \"*.*\")]\n",
        "        )\n",
        "        root.destroy() # Đóng cửa sổ sau khi chọn\n",
        "        return file_path\n",
        "    except Exception as e:\n",
        "        print(f\"⚠️ Không thể mở cửa sổ chọn file: {e}\")\n",
        "        return None\n",
        "\n",
        "try:\n",
        "    # 1. Kiểm tra xem có phải đang chạy trên Google Colab không\n",
        "    import google.colab\n",
        "    IN_COLAB = True\n",
        "except ImportError:\n",
        "    IN_COLAB = False\n",
        "\n",
        "# XỬ LÝ UPLOAD / CHỌN FILE\n",
        "if IN_COLAB:\n",
        "    # --- Logic cho Google Colab ---\n",
        "    try:\n",
        "        from google.colab import files\n",
        "        print(\"📁 Upload file DWG hoặc DXF của bạn (Optional):\")\n",
        "        uploaded = files.upload()\n",
        "        \n",
        "        # Lấy file cuối cùng được upload\n",
        "        if uploaded:\n",
        "            filename = list(uploaded.keys())[0]\n",
        "            if filename.lower().endswith('.dwg'):\n",
        "                print(f\"🔄 Converting DWG: {filename}\")\n",
        "                DXF_PATH = convert_dwg_to_dxf(filename)\n",
        "            elif filename.lower().endswith('.dxf'):\n",
        "                DXF_PATH = filename\n",
        "                print(f\"✅ DXF loaded: {filename}\")\n",
        "            else:\n",
        "                print(f\"⚠️ Unsupported format: {filename}\")\n",
        "        else:\n",
        "            print(\"ℹ️ Không có file nào được chọn.\")\n",
        "    except Exception as e:\n",
        "        print(f\"⚠️ Lỗi khi upload Colab: {e}\")\n",
        "\n",
        "else:\n",
        "    # --- Logic cho Local (Jupyter / VS Code) ---\n",
        "    print(\"💻 Phát hiện môi trường Local.\")\n",
        "    # Hỏi người dùng có muốn chọn file không\n",
        "    choice = input(\"Bạn có muốn chọn file DWG/DXF không? (y/n): \").strip().lower()\n",
        "    \n",
        "    if choice == 'y':\n",
        "        selected_path = select_file_local()\n",
        "        if selected_path:\n",
        "            filename = os.path.basename(selected_path)\n",
        "            # Copy hoặc xử lý file từ đường dẫn đã chọn\n",
        "            if filename.lower().endswith('.dwg'):\n",
        "                print(f\"🔄 Converting DWG: {selected_path}\")\n",
        "                # Lưu ý: Hàm convert cần hỗ trợ đường dẫn đầy đủ\n",
        "                DXF_PATH = convert_dwg_to_dxf(selected_path) \n",
        "            elif filename.lower().endswith('.dxf'):\n",
        "                DXF_PATH = selected_path\n",
        "                print(f\"✅ DXF loaded: {selected_path}\")\n",
        "            else:\n",
        "                print(f\"⚠️ File không được hỗ trợ: {filename}\")\n",
        "        else:\n",
        "            print(\"ℹ️ Đã hủy chọn file.\")\n",
        "    else:\n",
        "        print(\"ℹ️ Bỏ qua chọn file. Sẽ dùng dữ liệu ngẫu nhiên.\")\n",
        "\n",
        "# --- PHẦN XỬ LÝ CHUNG (LOAD SITE) ---\n",
        "\n",
        "# Load or create site\n",
        "if DXF_PATH and os.path.exists(DXF_PATH):\n",
        "    try:\n",
        "        site_polygon, original_doc = load_boundary_from_dxf(DXF_PATH)\n",
        "        if site_polygon is None:\n",
        "            print(\"⚠️ Không đọc được boundary từ file, tạo ngẫu nhiên.\")\n",
        "            site_polygon = create_random_site()\n",
        "    except Exception as e:\n",
        "        print(f\"⚠️ Lỗi khi đọc file DXF: {e}. Tạo ngẫu nhiên.\")\n",
        "        site_polygon = create_random_site()\n",
        "else:\n",
        "    site_polygon = create_random_site()\n",
        "    print(\"ℹ️ Using random site\")\n",
        "\n",
        "minx, miny, maxx, maxy = site_polygon.bounds\n",
        "print(f\"Site Area: {site_polygon.area/10000:.2f} ha\")\n",
        "\n",
        "# Plot site\n",
        "fig, ax = plt.subplots(figsize=(10, 10))\n",
        "x, y = site_polygon.exterior.xy\n",
        "ax.fill(x, y, color='#e0f7fa', alpha=0.5, label='Ranh giới KCN')\n",
        "ax.plot(x, y, color='blue')\n",
        "ax.set_title(\"Khu đất ban đầu\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "752e8f14",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "752e8f14",
        "outputId": "03eb8869-7d55-42b6-c7ce-88d422b7065b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "✅ Số block thương phẩm: 6\n",
            "✅ Số block hạ tầng: 2\n"
          ]
        }
      ],
      "source": [
        "# 5. PHASE 1: ROAD NETWORK GENERATION (Reliable Logic)\n",
        "from shapely.geometry import GeometryCollection\n",
        "\n",
        "def generate_road_network(site, num_seeds=15):\n",
        "    # 1. Tạo hạt Voronoi để chia mạng lưới đường\n",
        "    minx, miny, maxx, maxy = site.bounds\n",
        "    seeds = []\n",
        "    for _ in range(num_seeds):\n",
        "        seeds.append(Point(random.uniform(minx, maxx), random.uniform(miny, maxy)))\n",
        "\n",
        "    # Tạo Voronoi Diagram\n",
        "    # buffer(100) để đảm bảo các điểm nằm trong vùng tính toán\n",
        "    regions = voronoi_diagram(MultiPolygon([site.buffer(100)]), envelope=site.buffer(200))\n",
        "\n",
        "    # 2. Lấy cạnh của Voronoi làm tim đường\n",
        "    edges = []\n",
        "\n",
        "    # --- [FIX LỖI HERE] Xử lý GeometryCollection / MultiPolygon ---\n",
        "    if hasattr(regions, 'geoms'):\n",
        "        # Nếu là tập hợp (Collection), lặp qua .geoms\n",
        "        for region in regions.geoms:\n",
        "            if region.geom_type == 'Polygon':\n",
        "                edges.append(region.exterior)\n",
        "    elif regions.geom_type == 'Polygon':\n",
        "        # Nếu chỉ có 1 Polygon duy nhất\n",
        "        edges.append(regions.exterior)\n",
        "\n",
        "    # Phân loại đường: Trục chính vs Nội bộ\n",
        "    center = site.centroid\n",
        "    road_polys = []\n",
        "\n",
        "    # Hack nhẹ: Union các lines lại để xử lý chung\n",
        "    all_lines = []\n",
        "    for geom in edges:\n",
        "        all_lines.append(geom)\n",
        "\n",
        "    merged_lines = unary_union(all_lines)\n",
        "\n",
        "    # Chuẩn hóa thành list các LineString đơn lẻ để duyệt\n",
        "    lines_to_process = []\n",
        "    if hasattr(merged_lines, 'geoms'):\n",
        "        lines_to_process = list(merged_lines.geoms)\n",
        "    else:\n",
        "        lines_to_process = [merged_lines]\n",
        "\n",
        "    for line in lines_to_process:\n",
        "        if not isinstance(line, (LineString, MultiLineString)):\n",
        "            continue\n",
        "\n",
        "        # Heuristic: Nếu đường đi qua gần tâm hoặc rất dài -> Trục chính\n",
        "        dist_to_center = line.distance(center)\n",
        "        if dist_to_center < 100 or line.length > 400:\n",
        "            # Trục chính: Rộng + Vỉa hè\n",
        "            width = ROAD_MAIN_WIDTH + 2 * SIDEWALK_WIDTH\n",
        "            road_polys.append(line.buffer(width / 2, cap_style=2, join_style=2))\n",
        "        else:\n",
        "            # Nội bộ: Hẹp hơn\n",
        "            width = ROAD_INTERNAL_WIDTH + 2 * SIDEWALK_WIDTH\n",
        "            road_polys.append(line.buffer(width / 2, cap_style=2, join_style=2))\n",
        "\n",
        "    # Hợp nhất mạng lưới đường thành 1 khối polygon\n",
        "    if not road_polys:\n",
        "        # Trường hợp hiếm không tạo được đường nào -> trả về danh sách rỗng để tránh lỗi\n",
        "        return [], [], Polygon()\n",
        "\n",
        "    network_poly = unary_union(road_polys)\n",
        "\n",
        "    # 3. Xử lý Vạt góc (Turning Radius) tại ngã tư\n",
        "    # Kỹ thuật: Buffer dương rồi buffer âm (Rounding corners) hoặc ngược lại\n",
        "    # Ở đây dùng buffer dương (đã làm ở bước trên) -> buffer âm một chút để làm mượt nếu cần,\n",
        "    # hoặc dùng kỹ thuật buffer(R).buffer(-R) để bo tròn góc nhọn giao nhau.\n",
        "    smooth_network = network_poly.buffer(TURNING_RADIUS, join_style=1).buffer(-TURNING_RADIUS, join_style=1)\n",
        "\n",
        "    # Cắt đất thành các Block (Lấy đất gốc trừ đi đường)\n",
        "    blocks_rough = site.difference(smooth_network)\n",
        "\n",
        "    service_blocks = []\n",
        "    commercial_blocks = []\n",
        "\n",
        "    # Chuẩn hóa danh sách block candidates\n",
        "    candidates = []\n",
        "    if hasattr(blocks_rough, 'geoms'):\n",
        "        candidates = list(blocks_rough.geoms)\n",
        "    elif blocks_rough.geom_type == 'Polygon':\n",
        "        candidates = [blocks_rough]\n",
        "\n",
        "    # 4. Phân loại đất (Dành đất cho Hạ tầng)\n",
        "    # Sắp xếp block theo cao độ (thấp nhất ưu tiên làm XLNT)\n",
        "    candidates.sort(key=lambda b: get_elevation(b.centroid.x, b.centroid.y))\n",
        "\n",
        "    total_area = sum([b.area for b in candidates])\n",
        "    current_service_area = 0\n",
        "\n",
        "    # Block thấp nhất -> Trạm xử lý nước thải (WWTP)\n",
        "    if candidates:\n",
        "        wwtp = candidates.pop(0)\n",
        "        service_blocks.append({'geom': wwtp, 'type': 'XLNT (Thấp nhất)'})\n",
        "        current_service_area += wwtp.area\n",
        "\n",
        "    # Các block còn lại\n",
        "    for b in candidates:\n",
        "        # Nếu block quá nhỏ hoặc hình dáng méo mó hoặc cần thêm đất dịch vụ -> Dịch vụ\n",
        "        # (Heuristic: diện tích < 1.5 lần min hoặc chưa đủ chỉ tiêu 10%)\n",
        "        if (current_service_area < total_area * SERVICE_AREA_RATIO) or (b.area < MIN_BLOCK_AREA):\n",
        "             service_blocks.append({'geom': b, 'type': 'Điều hành/Bãi xe'})\n",
        "             current_service_area += b.area\n",
        "        else:\n",
        "            commercial_blocks.append(b)\n",
        "\n",
        "    return commercial_blocks, service_blocks, smooth_network\n",
        "\n",
        "# Chạy hàm\n",
        "blocks, service_blocks, road_network = generate_road_network(site_polygon)\n",
        "print(f\"✅ Số block thương phẩm: {len(blocks)}\")\n",
        "print(f\"✅ Số block hạ tầng: {len(service_blocks)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "e792b3a4",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e792b3a4",
        "outputId": "70fdc462-afeb-40c4-8628-6d000dbb0660"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Đang chia lô...\n",
            "✅ Hoàn tất chia 824 lô đất thương phẩm.\n"
          ]
        }
      ],
      "source": [
        "# 6. PHASE 2: LOT SUBDIVISION (Reliable Logic)\n",
        "\n",
        "def solve_subdivision_with_timelimit(total_len, min_w, max_w, target_w):\n",
        "    \"\"\"Giải thuật toán chia lô với giới hạn thời gian\"\"\"\n",
        "    model = cp_model.CpModel()\n",
        "    max_lots = int(total_len // min_w) + 2\n",
        "\n",
        "    widths = []\n",
        "    is_active = []\n",
        "    diffs = []\n",
        "\n",
        "    for i in range(max_lots):\n",
        "        w = model.NewIntVar(0, int(max_w * 10), f'w_{i}')\n",
        "        active = model.NewBoolVar(f'active_{i}')\n",
        "\n",
        "        model.Add(w >= int(min_w * 10)).OnlyEnforceIf(active)\n",
        "        model.Add(w <= int(max_w * 10)).OnlyEnforceIf(active)\n",
        "        model.Add(w == 0).OnlyEnforceIf(active.Not())\n",
        "\n",
        "        # Cố gắng đạt kích thước Target\n",
        "        diff = model.NewIntVar(0, int(max_w * 10), f'diff_{i}')\n",
        "        model.Add(diff >= w - int(target_w * 10)).OnlyEnforceIf(active)\n",
        "        model.Add(diff >= int(target_w * 10) - w).OnlyEnforceIf(active)\n",
        "        model.Add(diff == 0).OnlyEnforceIf(active.Not())\n",
        "\n",
        "        widths.append(w)\n",
        "        is_active.append(active)\n",
        "        diffs.append(diff)\n",
        "\n",
        "    total_w_var = model.NewIntVar(0, int(total_len * 10), 'total_w')\n",
        "    model.Add(total_w_var == sum(widths))\n",
        "\n",
        "    # Maximize diện tích lấp đầy & Minimize độ lệch chuẩn\n",
        "    model.Maximize(total_w_var * 100 - sum(diffs))\n",
        "\n",
        "    solver = cp_model.CpSolver()\n",
        "    # --- [TIME LIMIT FIX] ---\n",
        "    solver.parameters.max_time_in_seconds = SOLVER_TIME_LIMIT\n",
        "\n",
        "    status = solver.Solve(model)\n",
        "\n",
        "    results = []\n",
        "    if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:\n",
        "        for i in range(max_lots):\n",
        "            if solver.Value(is_active[i]):\n",
        "                results.append(solver.Value(widths[i]) / 10.0)\n",
        "    return results\n",
        "\n",
        "def calculate_legal_params(lot_polygon):\n",
        "    \"\"\"Tính mật độ xây dựng & Chỉ giới\"\"\"\n",
        "    # 1. Chỉ giới xây dựng (Setback)\n",
        "    buildable_area = lot_polygon.buffer(-SETBACK_DISTANCE)\n",
        "\n",
        "    if buildable_area.is_empty:\n",
        "        return None, 0, 0\n",
        "\n",
        "    # 2. Mật độ xây dựng (Quy chuẩn VN - Ví dụ đơn giản hóa)\n",
        "    # Diện tích càng lớn, mật độ cho phép càng giảm\n",
        "    area_m2 = lot_polygon.area\n",
        "    if area_m2 < 3000: density = 0.70  # 70%\n",
        "    elif area_m2 < 10000: density = 0.65 # 65%\n",
        "    else: density = 0.60 # 60%\n",
        "\n",
        "    max_build_area = area_m2 * density\n",
        "\n",
        "    return buildable_area, density * 100, max_build_area\n",
        "\n",
        "final_lots = []\n",
        "buildable_footprints = []\n",
        "\n",
        "print(\"Đang chia lô...\")\n",
        "for idx, block in enumerate(blocks):\n",
        "    rect = block.minimum_rotated_rectangle\n",
        "    x, y = rect.exterior.coords.xy\n",
        "    edge_lengths = [Point(x[i], y[i]).distance(Point(x[i+1], y[i+1])) for i in range(4)]\n",
        "    max_idx = np.argmax(edge_lengths)\n",
        "    total_len = edge_lengths[max_idx]\n",
        "\n",
        "    # Gọi Solver (Time limited)\n",
        "    widths = solve_subdivision_with_timelimit(total_len, MIN_LOT_WIDTH, MAX_LOT_WIDTH, TARGET_LOT_WIDTH)\n",
        "\n",
        "    # Cắt hình học (Logic vector như cũ)\n",
        "    p0 = np.array([x[max_idx], y[max_idx]])\n",
        "    p1 = np.array([x[(max_idx+1)%4], y[(max_idx+1)%4]])\n",
        "    vec = p1 - p0\n",
        "    vec_len = np.linalg.norm(vec)\n",
        "    if vec_len == 0: continue\n",
        "    unit_vec = vec / vec_len\n",
        "    ortho = np.array([-unit_vec[1], unit_vec[0]])\n",
        "\n",
        "    curr = 0\n",
        "    for w in widths:\n",
        "        start = p0 + unit_vec * curr\n",
        "        end = p0 + unit_vec * (curr + w)\n",
        "        cutter = Polygon([start - ortho*500, end - ortho*500, end + ortho*500, start + ortho*500])\n",
        "        lot = block.intersection(cutter)\n",
        "\n",
        "        if not lot.is_empty and lot.area > 500: # Lọc lô vụn\n",
        "             if isinstance(lot, MultiPolygon):\n",
        "                 for g in lot.geoms: final_lots.append(g)\n",
        "             else:\n",
        "                 final_lots.append(lot)\n",
        "        curr += w\n",
        "\n",
        "# Tính toán tham số pháp lý cho từng lô\n",
        "processed_lots = []\n",
        "for lot in final_lots:\n",
        "    b_zone, density, max_area = calculate_legal_params(lot)\n",
        "    if b_zone is not None:\n",
        "        processed_lots.append({\n",
        "            'geom': lot,\n",
        "            'buildable': b_zone,\n",
        "            'density': density,\n",
        "            'max_area': max_area\n",
        "        })\n",
        "\n",
        "print(f\"✅ Hoàn tất chia {len(processed_lots)} lô đất thương phẩm.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "dbc69745",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dbc69745",
        "outputId": "bb6fdcfb-d432-4f85-a590-bcebc50cae20"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "✅ Hoàn tất tính toán hệ thống kỹ thuật (Điện, Nước).\n"
          ]
        }
      ],
      "source": [
        "# 7. PHASE 3: INFRASTRUCTURE (Reliable Logic)\n",
        "\n",
        "# --- A. MẠNG LƯỚI ĐIỆN MẠCH VÒNG (LOOP NETWORK) ---\n",
        "def create_loop_network(lots):\n",
        "    centroids = [l['geom'].centroid for l in lots]\n",
        "    G = nx.Graph()\n",
        "\n",
        "    # Thêm nodes\n",
        "    for i, p in enumerate(centroids):\n",
        "        G.add_node(i, pos=(p.x, p.y))\n",
        "\n",
        "    # Thêm cạnh (dựa trên khoảng cách)\n",
        "    for i in range(len(centroids)):\n",
        "        for j in range(i+1, len(centroids)):\n",
        "            dist = centroids[i].distance(centroids[j])\n",
        "            if dist < 150: # Chỉ nối các lô gần nhau\n",
        "                G.add_edge(i, j, weight=dist)\n",
        "\n",
        "    # 1. Tạo MST (Cây - Minimum Spanning Tree)\n",
        "    # Kiểm tra đồ thị có liên thông không, nếu không thì nối các cụm\n",
        "    if not nx.is_connected(G):\n",
        "        # Fallback đơn giản: nối tất cả vào node 0 (hoặc xử lý phức tạp hơn)\n",
        "        # Ở đây ta bỏ qua các node cô lập để tránh lỗi MST\n",
        "        components = list(nx.connected_components(G))\n",
        "        largest_comp = max(components, key=len)\n",
        "        subgraph = G.subgraph(largest_comp).copy()\n",
        "        mst = nx.minimum_spanning_tree(subgraph)\n",
        "    else:\n",
        "        mst = nx.minimum_spanning_tree(G)\n",
        "\n",
        "    # 2. Tạo Loop (Vòng): Thêm lại 15% số cạnh đã bị loại bỏ để tạo mạch vòng an toàn\n",
        "    all_edges = sorted(G.edges(data=True), key=lambda x: x[2]['weight'])\n",
        "    loop_graph = mst.copy()\n",
        "\n",
        "    added_count = 0\n",
        "    target_extra = int(len(lots) * 0.15) # Thêm 15% cạnh dư thừa\n",
        "\n",
        "    for u, v, data in all_edges:\n",
        "        if not loop_graph.has_edge(u, v):\n",
        "            try:\n",
        "                loop_graph.add_edge(u, v, weight=data['weight'])\n",
        "                added_count += 1\n",
        "                if added_count >= target_extra: break\n",
        "            except:\n",
        "                pass\n",
        "\n",
        "    return loop_graph\n",
        "\n",
        "# Kiểm tra nếu có lô đất thì mới chạy\n",
        "if len(processed_lots) > 0:\n",
        "    infra_graph = create_loop_network(processed_lots)\n",
        "else:\n",
        "    infra_graph = nx.Graph()\n",
        "\n",
        "# --- B. CLUSTER TRẠM BIẾN ÁP (K-MEANS) ---\n",
        "if len(processed_lots) > 0:\n",
        "    lot_coords = np.array([[l['geom'].centroid.x, l['geom'].centroid.y] for l in processed_lots])\n",
        "    # Ước tính số trạm: 1 trạm phục vụ ~15 lô hoặc bán kính 300m\n",
        "    num_transformers = max(1, int(len(processed_lots) / 15))\n",
        "\n",
        "    # KMeans cần ít nhất số sample bằng số cluster\n",
        "    if len(processed_lots) < num_transformers:\n",
        "        num_transformers = len(processed_lots)\n",
        "\n",
        "    kmeans = KMeans(n_clusters=num_transformers, n_init=10).fit(lot_coords)\n",
        "    transformer_locs = kmeans.cluster_centers_\n",
        "else:\n",
        "    transformer_locs = np.array([])\n",
        "\n",
        "# --- C. THOÁT NƯỚC (GRAVITY FLOW) ---\n",
        "# Tìm hướng dòng chảy từ mỗi lô về phía trạm XLNT\n",
        "wwtp_loc = None\n",
        "for s in service_blocks:\n",
        "    if \"XLNT\" in s['type']:\n",
        "        wwtp_loc = s['geom'].centroid\n",
        "        break\n",
        "if wwtp_loc is None: wwtp_loc = site_polygon.centroid # Fallback\n",
        "\n",
        "flow_arrows = []\n",
        "for lot in processed_lots:\n",
        "    c = lot['geom'].centroid\n",
        "    # Vector hướng về XLNT\n",
        "    dx = wwtp_loc.x - c.x\n",
        "    dy = wwtp_loc.y - c.y\n",
        "\n",
        "    # [FIXED] Dùng **2 (bình phương) thay vì *2 (nhân 2)\n",
        "    length = math.sqrt(dx**2 + dy**2)\n",
        "\n",
        "    # Chuẩn hóa vector để vẽ mũi tên ngắn (dài 30m)\n",
        "    if length > 0:\n",
        "        flow_arrows.append((c.x, c.y, dx/length*30, dy/length*30))\n",
        "\n",
        "print(\"✅ Hoàn tất tính toán hệ thống kỹ thuật (Điện, Nước).\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "4fc64f01",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "4fc64f01",
        "outputId": "d573948d-0836-4ecb-d9d3-3d0740082a40"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 2400x2400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# 8. VISUALIZATION (Reliable Logic)\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(24, 24)) # Increased size for better visibility\n",
        "ax.set_aspect('equal')\n",
        "ax.set_facecolor('#f0f0f0')\n",
        "\n",
        "# 1. Vẽ Đường & Vỉa hè\n",
        "for geom in road_network.geoms if isinstance(road_network, MultiPolygon) else [road_network]:\n",
        "    x, y = geom.exterior.xy\n",
        "    ax.fill(x, y, color='#607d8b', alpha=0.3, label='Hạ tầng giao thông') # Đường xám\n",
        "\n",
        "# 2. Vẽ Lô đất thương phẩm & Chỉ giới xây dựng\n",
        "for lot in processed_lots:\n",
        "    # Ranh giới lô đất\n",
        "    x, y = lot['geom'].exterior.xy\n",
        "    ax.plot(x, y, color='black', linewidth=0.5)\n",
        "    ax.fill(x, y, color='#fff9c4', alpha=0.5) # Màu vàng đất CN\n",
        "\n",
        "    # Chỉ giới xây dựng (Setback) - Nét đứt đỏ\n",
        "    if not lot['buildable'].is_empty:\n",
        "        if isinstance(lot['buildable'], Polygon):\n",
        "            bx, by = lot['buildable'].exterior.xy\n",
        "            ax.plot(bx, by, color='red', linestyle='--', linewidth=0.8, alpha=0.7)\n",
        "        elif isinstance(lot['buildable'], MultiPolygon):\n",
        "             for b in lot['buildable'].geoms:\n",
        "                bx, by = b.exterior.xy\n",
        "                ax.plot(bx, by, color='red', linestyle='--', linewidth=0.8, alpha=0.7)\n",
        "\n",
        "# 3. Vẽ Đất Dịch vụ / Kỹ thuật\n",
        "for s in service_blocks:\n",
        "    x, y = s['geom'].exterior.xy\n",
        "    if \"XLNT\" in s['type']:\n",
        "        color = '#b2dfdb' # Xanh nước\n",
        "        label = \"XLNT\"\n",
        "    else:\n",
        "        color = '#d1c4e9' # Tím\n",
        "        label = \"Điều hành\"\n",
        "    ax.fill(x, y, color=color, alpha=0.9)\n",
        "    ax.text(s['geom'].centroid.x, s['geom'].centroid.y, label, ha='center', fontsize=8, color='black', weight='bold')\n",
        "\n",
        "# 4. Vẽ Hạ tầng điện (Mạch vòng)\n",
        "pos = nx.get_node_attributes(infra_graph, 'pos')\n",
        "# Vẽ cạnh (dây điện ngầm)\n",
        "for u, v in infra_graph.edges():\n",
        "    if u in pos and v in pos:\n",
        "        p1 = pos[u]\n",
        "        p2 = pos[v]\n",
        "        ax.plot([p1[0], p2[0]], [p1[1], p2[1]], color='blue', linestyle='-', linewidth=0.5, alpha=0.4)\n",
        "\n",
        "# 5. Vẽ Trạm biến áp (Cluster centers)\n",
        "if len(transformer_locs) > 0:\n",
        "    ax.scatter(transformer_locs[:, 0], transformer_locs[:, 1], c='red', marker='^', s=100, label='Trạm biến áp', zorder=10)\n",
        "\n",
        "# 6. Vẽ Hướng thoát nước (Mũi tên) - Chỉ vẽ đại diện 1 số mũi tên cho đỡ rối\n",
        "for i, (fx, fy, dx, dy) in enumerate(flow_arrows):\n",
        "    if i % 3 == 0: # Lấy mẫu\n",
        "        ax.arrow(fx, fy, dx, dy, head_width=5, head_length=5, fc='cyan', ec='cyan', alpha=0.6)\n",
        "\n",
        "# Chú thích\n",
        "plt.title(\"QUY HOẠCH CHI TIẾT 1/500 (PRODUCTION READY)\\n\"\n",
        "          \"Bao gồm: Đường phân cấp, Vạt góc, Chỉ giới XD, Điện mạch vòng, Thoát nước tự chảy\", fontsize=14)\n",
        "\n",
        "# Legend thủ công\n",
        "from matplotlib.lines import Line2D\n",
        "custom_lines = [Line2D([0], [0], color='#fff9c4', lw=4),\n",
        "                Line2D([0], [0], color='red', linestyle='--', lw=1),\n",
        "                Line2D([0], [0], color='#607d8b', lw=4),\n",
        "                Line2D([0], [0], color='blue', lw=1),\n",
        "                Line2D([0], [0], marker='^', color='w', markerfacecolor='red', markersize=10),\n",
        "                Line2D([0], [0], color='cyan', lw=1, marker='>')]\n",
        "\n",
        "ax.legend(custom_lines, ['Đất CN', 'Chỉ giới XD (Setback)', 'Đường giao thông', 'Cáp điện ngầm (Loop)', 'Trạm biến áp', 'Hướng thoát nước'], loc='lower right')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ea257e45",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        },
        "id": "ea257e45",
        "outputId": "624d6ceb-0734-4f10-c4cd-faa49122cb21"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "✅ JSON saved to optimization_result.json\n",
            "✅ Preserving original DXF data\n",
            "\n",
            "✅ DXF exported: remb_output.dxf\n",
            "   Plots added: 824\n",
            "   Transformers added: 54\n",
            "ℹ️ Output files are in the current directory.\n"
          ]
        },
        {
          "ename": "",
          "evalue": "",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
            "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
            "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
            "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
          ]
        }
      ],
      "source": [
        "# 9. EXPORT RESULTS (DXF & JSON)\n",
        "\n",
        "# --- JSON EXPORT ---\n",
        "result = {\n",
        "    \"timestamp\": datetime.now().isoformat(),\n",
        "    \"site_area_ha\": site_polygon.area / 10000,\n",
        "    \"lots\": [],\n",
        "    \"service_blocks\": [],\n",
        "    \"transformers\": []\n",
        "}\n",
        "\n",
        "for i, lot in enumerate(processed_lots):\n",
        "    geom = lot['geom']\n",
        "    result[\"lots\"].append({\n",
        "        \"id\": i + 1,\n",
        "        \"centroid_x\": geom.centroid.x,\n",
        "        \"centroid_y\": geom.centroid.y,\n",
        "        \"area_m2\": geom.area,\n",
        "        \"buildable_area_m2\": lot['max_area'],\n",
        "        \"density_percent\": lot['density']\n",
        "    })\n",
        "\n",
        "for i, sb in enumerate(service_blocks):\n",
        "    geom = sb['geom']\n",
        "    result[\"service_blocks\"].append({\n",
        "        \"id\": i + 1,\n",
        "        \"type\": sb['type'],\n",
        "        \"centroid_x\": geom.centroid.x,\n",
        "        \"centroid_y\": geom.centroid.y,\n",
        "        \"area_m2\": geom.area\n",
        "    })\n",
        "\n",
        "for i, t in enumerate(transformer_locs):\n",
        "    result[\"transformers\"].append({\n",
        "        \"id\": i + 1,\n",
        "        \"x\": float(t[0]),\n",
        "        \"y\": float(t[1]),\n",
        "        \"service_radius\": TRANSFORMER_RADIUS\n",
        "    })\n",
        "\n",
        "with open('optimization_result.json', 'w') as f:\n",
        "    json.dump(result, f, indent=2)\n",
        "\n",
        "print(\"✅ JSON saved to optimization_result.json\")\n",
        "\n",
        "# --- DXF EXPORT ---\n",
        "def export_to_dxf(output_path, original_doc=None):\n",
        "    \"\"\"Export optimization results to DXF, preserving original data if available\"\"\"\n",
        "    import ezdxf\n",
        "\n",
        "    # Use original doc or create new\n",
        "    if original_doc:\n",
        "        doc = original_doc\n",
        "        print(\"✅ Preserving original DXF data\")\n",
        "    else:\n",
        "        doc = ezdxf.new('R2010')\n",
        "        print(\"ℹ️ Creating new DXF file\")\n",
        "\n",
        "    msp = doc.modelspace()\n",
        "\n",
        "    # Add layers\n",
        "    layers = {\n",
        "        'OPTIMIZED_PLOTS': 3,      # Green\n",
        "        'OPTIMIZED_ROADS': 1,      # Red\n",
        "        'ANNOTATIONS': 7,          # White\n",
        "        'INFRASTRUCTURE': 5,       # Blue\n",
        "    }\n",
        "\n",
        "    for layer_name, color in layers.items():\n",
        "        if layer_name not in doc.layers:\n",
        "            doc.layers.add(layer_name, color=color)\n",
        "\n",
        "    # Add plots\n",
        "    plot_count = 0\n",
        "    for i, lot in enumerate(processed_lots):\n",
        "        geom = lot['geom']\n",
        "        if geom.geom_type == 'Polygon':\n",
        "            points = list(geom.exterior.coords)\n",
        "            msp.add_lwpolyline(points, close=True, dxfattribs={'layer': 'OPTIMIZED_PLOTS'})\n",
        "\n",
        "            # Add label\n",
        "            centroid = geom.centroid\n",
        "            msp.add_text(\n",
        "                f\"Plot_{i+1}\",\n",
        "                dxfattribs={'layer': 'ANNOTATIONS', 'height': 5, 'insert': (centroid.x, centroid.y)}\n",
        "            )\n",
        "            plot_count += 1\n",
        "\n",
        "    # Add transformers\n",
        "    for i, t in enumerate(transformer_locs):\n",
        "        msp.add_circle((float(t[0]), float(t[1])), radius=10, dxfattribs={'layer': 'INFRASTRUCTURE'})\n",
        "        msp.add_text(\n",
        "            f\"TRF_{i+1}\",\n",
        "            dxfattribs={'layer': 'ANNOTATIONS', 'height': 8, 'insert': (float(t[0]), float(t[1]) + 15)}\n",
        "        )\n",
        "\n",
        "    # Add info block\n",
        "    info_y = maxy + 100\n",
        "    info_lines = [\n",
        "        \"OPTIMIZATION RESULTS\",\n",
        "        f\"Date: {datetime.now().strftime('%Y-%m-%d %H:%M')}\",\n",
        "        f\"Plots: {len(processed_lots)}\",\n",
        "    ]\n",
        "    for line in info_lines:\n",
        "        msp.add_text(line, dxfattribs={'layer': 'ANNOTATIONS', 'height': 10, 'insert': (minx, info_y)})\n",
        "        info_y -= 15\n",
        "\n",
        "    # Save\n",
        "    doc.saveas(output_path)\n",
        "    print(f\"\\n✅ DXF exported: {output_path}\")\n",
        "    print(f\"   Plots added: {plot_count}\")\n",
        "    print(f\"   Transformers added: {len(transformer_locs)}\")\n",
        "\n",
        "    return output_path\n",
        "\n",
        "# Export to DXF\n",
        "export_to_dxf('remb_output.dxf', original_doc)\n",
        "\n",
        "# --- DOWNLOAD (Colab) ---\n",
        "try:\n",
        "    from google.colab import files\n",
        "    print(\"📥 Downloading output files...\")\n",
        "    if os.path.exists('optimization_result.json'):\n",
        "        files.download('optimization_result.json')\n",
        "    if os.path.exists('remb_output.dxf'):\n",
        "        files.download('remb_output.dxf')\n",
        "except ImportError:\n",
        "    print(\"ℹ️ Output files are in the current directory.\")"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "venv",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}