Initial commit (clean, no binaries)

.gitignore

@@ -0,0 +1,6 @@
+temp_visuals/
+__pycache__/
+.ipynb_checkpoints/
+*.png
+*.pyc
+

app.py

@@ -0,0 +1,388 @@
+import gradio as gr
+import os
+import shutil
+import random
+import json
+import zipfile
+import networkx as nx
+from datetime import datetime
+
+# Import from our custom modules
+from network_generator import NetworkGenerator, validate_topology
+from visualizer import plot_graph_to_image, IMG_WIDTH_PX, IMG_HEIGHT_PX, TEMP_DIR
+from json_handler import generate_full_json_dict, load_graph_from_json, load_graph_from_data
+
+# ==========================================
+# DIRECTORY MANAGEMENT
+# ==========================================
+PERM_VIS_DIR = "saved_visuals"
+ZIP_DIR = "saved_zips"
+
+os.makedirs(PERM_VIS_DIR, exist_ok=True)
+os.makedirs(ZIP_DIR, exist_ok=True)
+
+def get_local_zips():
+    if not os.path.exists(ZIP_DIR): return []
+    return [f for f in os.listdir(ZIP_DIR) if f.endswith('.zip')]
+
+def extract_jsons_from_zip(zip_path):
+    loaded = []
+    with zipfile.ZipFile(zip_path, 'r') as z:
+        for filename in z.namelist():
+            if filename.endswith('.json'):
+                with z.open(filename) as f:
+                    data = json.load(f)
+                    loaded.append(load_graph_from_data(data, filename))
+    return loaded
+
+# ==========================================
+# UI EVENT HANDLERS
+# ==========================================
+
+def handle_plot_click(evt: gr.SelectData, click_mode, state_data):
+    if not state_data or "graph" not in state_data: 
+        return None, "Generate first.", state_data
+    
+    click_x, click_y = evt.index 
+    width = state_data["width"]
+    height = state_data["height"]
+    
+    norm_x = click_x / IMG_WIDTH_PX
+    norm_y = click_y / IMG_HEIGHT_PX
+    grid_x = int(round(norm_x * (width + 1.0) - 0.5))
+    grid_y = int(round(norm_y * (height + 1.0) - 0.5))
+    
+    # Correction for edge cases
+    if grid_x < 0: grid_x = 0
+    if grid_y < 0: grid_y = 0
+    if grid_x >= width: grid_x = width - 1
+    if grid_y >= height: grid_y = height - 1
+    
+    gen = NetworkGenerator(width, height)
+    gen.graph = state_data["graph"]
+    
+    action_msg = "Ignored"
+    success = False
+    highlight = None
+
+    target_coord = (grid_x, grid_y)
+    
+    if click_mode == "Add/Remove Node":
+        state_data["edge_start"] = None 
+        if gen.graph.has_node(target_coord):
+            success, action_msg = gen.manual_delete_node(*target_coord)
+        else:
+            success, action_msg = gen.manual_add_node(*target_coord)
+            if success: highlight = target_coord
+            
+    elif click_mode == "Add/Remove Edge":
+        if not gen.graph.has_node(target_coord):
+            state_data["edge_start"] = None
+            success = True
+            action_msg = "Selection cleared."
+        else:
+            start_node = state_data.get("edge_start")
+            
+            if start_node is None:
+                state_data["edge_start"] = target_coord
+                highlight = target_coord
+                success = True
+                node_id = gen.get_node_id_str(target_coord)
+                action_msg = f"Node {node_id} selected. Click another node to link."
+            elif start_node == target_coord:
+                state_data["edge_start"] = None
+                success = True
+                action_msg = "Selection cleared."
+            else:
+                success, action_msg = gen.manual_toggle_edge(start_node, target_coord)
+                state_data["edge_start"] = None 
+
+    if success:
+        state_data["graph"] = gen.graph
+        img_path = plot_graph_to_image(gen.graph, width, height, highlight_node=highlight)
+        metrics = f"**Nodes:** {len(gen.graph.nodes())} | **Edges:** {len(gen.graph.edges())} | **Action:** {action_msg}"
+        return img_path, metrics, state_data
+    else:
+        return gr.update(), f"⚠️ Error: {action_msg}", state_data
+
+
+def get_preset_dims(preset_mode, topology):
+    if preset_mode == "Custom": return gr.update(interactive=True), gr.update(interactive=True)
+    dims = (6, 11) if topology=="linear" and preset_mode=="Medium" else (8,8)
+    if preset_mode == "Small": dims = (4, 4)
+    if preset_mode == "Large": dims = (16, 16) if topology!="linear" else (10, 26)
+    return gr.update(value=dims[0], interactive=False), gr.update(value=dims[1], interactive=False)
+
+def update_ui_for_variant(variant, width, height, topology, void_frac):
+    is_custom = (variant == "Custom")
+    
+    # Calculate Capable Edges
+    temp_gen = NetworkGenerator(width, height, "F", topology, void_frac)
+    max_edges = temp_gen.calculate_max_capacity()
+    
+    if is_custom:
+        n, e = temp_gen.calculate_defaults()
+        return (gr.update(interactive=True), 
+                gr.update(value=e, maximum=max_edges, interactive=True),
+                f"Active Grid Capacity: ~{max_edges} edges")
+    else:
+        area = width*height
+        val = 0.60 if area <= 20 else 0.35
+        return (gr.update(value=val, interactive=False), 
+                gr.update(value=0, interactive=False),
+                f"Active Grid Capacity: ~{max_edges} edges")
+
+def generate_and_store(topology, preset, width, height, variant, void_frac, t_edges):
+    try:
+        var_code = "F" if variant == "Fixed" else "R"
+        actual_edges = 0 if variant == "Fixed" else int(t_edges)
+        
+        gen = NetworkGenerator(width, height, var_code, topology, void_frac, target_edges=actual_edges)
+        graph = gen.generate()
+        
+        is_valid, val_msg = validate_topology(graph, topology)
+        val_icon = "✅" if is_valid else "⚠️"
+        
+        # --- NEW PROMINENT STATUS MESSAGING ---
+        status_header = "✅ **Status:** Generation Successful."
+        status_detail = ""
+        
+        if variant == "Custom" and actual_edges > 0:
+            current_edges = len(graph.edges())
+            diff = current_edges - actual_edges
+            
+            if diff < 0:
+                # Undershoot (Saturation)
+                missing = abs(diff)
+                status_header = f"⚠️ **Status:** Saturation Limit Reached (Missing {missing} Edges)"
+                status_detail = (f"The generator saturated at **{current_edges} edges**. It could not place the remaining {missing} edges without crossing existing lines.\n\n"
+                                 f"**Suggestion:** To fit {actual_edges} edges, please **increase the Grid Width/Height** or **decrease Void Fraction** to create more physical space.")
+            elif diff > 0:
+                # Overshoot (Connectivity)
+                extra = diff
+                status_header = f"⚠️ **Status:** Connectivity Forced (Added {extra} Edges)"
+                status_detail = (f"The target was {actual_edges}, but **{current_edges} edges** were required to keep the graph connected.\n"
+                                 f"The system automatically added links to prevent isolated nodes.")
+            else:
+                status_header = f"✅ **Status:** Exact Target Met ({actual_edges} Edges)"
+        # --------------------------------------
+        
+        img_path = plot_graph_to_image(graph, width, height)
+        
+        # Combined Metrics Block
+        metrics = (f"**Nodes:** {len(graph.nodes())} | **Edges:** {len(graph.edges())}\n\n"
+                   f"{val_icon} **Topology:** {val_msg}\n\n"
+                   f"--- \n"
+                   f"{status_header}\n{status_detail}")
+                   
+        state_data = { "graph": graph, "width": width, "height": height, "topology": topology, "edge_start": None }
+        return img_path, metrics, state_data, gr.update(interactive=True)
+    except Exception as e:
+        return None, f"Error: {e}", None, gr.update(interactive=False)
+
+def run_batch_generation(count, topology, width, height, variant, min_v, max_v, min_e, max_e):
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    dir_name = f"batch_{timestamp}"
+    temp_build_dir = os.path.join(ZIP_DIR, dir_name)
+    os.makedirs(temp_build_dir, exist_ok=True)
+    var_code = "F" if variant == "Fixed" else "R"
+    
+    try:
+        for i in range(int(count)):
+            if variant == "Custom":
+                t_e = random.randint(int(min_e), int(max_e))
+                current_void = random.uniform(float(min_v), float(max_v))
+            else:
+                t_e = 0
+                current_void = min_v 
+                
+            gen = NetworkGenerator(width, height, var_code, topology, current_void, target_edges=t_e)
+            G = gen.generate()
+            
+            json_content = generate_full_json_dict(G, loop=i+1)
+            with open(os.path.join(temp_build_dir, f"inst_{i+1}.json"), 'w') as f:
+                json.dump(json_content, f, indent=4)
+        
+        zip_base_name = os.path.join(ZIP_DIR, dir_name)
+        zip_path = shutil.make_archive(zip_base_name, 'zip', temp_build_dir)
+        shutil.rmtree(temp_build_dir) 
+        
+        return zip_path, gr.update(choices=get_local_zips())
+    except Exception as e:
+        return None, gr.update()
+
+def save_permanent_visual(state_data):
+    if not state_data or "graph" not in state_data: return "No graph to save."
+    img_path = plot_graph_to_image(state_data["graph"], state_data["width"], state_data["height"], save_dir=PERM_VIS_DIR)
+    return f"Saved successfully to {img_path}"
+
+def save_single_json_action(state_data):
+    if not state_data or "graph" not in state_data: return None
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    json_content = generate_full_json_dict(state_data["graph"], loop=1)
+    fname = f"single_network_{timestamp}.json"
+    with open(fname, 'w') as f:
+        json.dump(json_content, f, indent=4)
+    return fname
+
+def process_uploaded_files(files):
+    if not files:
+        return None, "No files uploaded.", gr.update(interactive=False), gr.update(interactive=False), [], 0
+    
+    loaded_data = []
+    for f in files:
+        try:
+            if f.name.endswith('.zip'):
+                loaded_data.extend(extract_jsons_from_zip(f.name))
+            else:
+                loaded_data.append(load_graph_from_json(f.name))
+        except Exception as e:
+            print(f"Failed to load {f.name}: {e}")
+            
+    if not loaded_data:
+        return None, "Failed to parse files.", gr.update(interactive=False), gr.update(interactive=False), [], 0
+        
+    img_path, info_text = render_loaded_graph(0, loaded_data)
+    return img_path, info_text, gr.update(interactive=True), gr.update(interactive=True), loaded_data, 0
+
+def process_local_zip_selection(zip_filename):
+    if not zip_filename:
+        return None, "No ZIP selected.", gr.update(interactive=False), gr.update(interactive=False), [], 0
+        
+    zip_path = os.path.join(ZIP_DIR, zip_filename)
+    try:
+        loaded_data = extract_jsons_from_zip(zip_path)
+    except Exception as e:
+        return None, f"Failed to read ZIP: {e}", gr.update(interactive=False), gr.update(interactive=False), [], 0
+        
+    if not loaded_data:
+        return None, "ZIP was empty or invalid.", gr.update(interactive=False), gr.update(interactive=False), [], 0
+
+    img_path, info_text = render_loaded_graph(0, loaded_data)
+    return img_path, info_text, gr.update(interactive=True), gr.update(interactive=True), loaded_data, 0
+
+def change_loaded_graph(direction, current_idx, loaded_data):
+    if not loaded_data: 
+        return None, "No data.", gr.update(), gr.update(), current_idx
+    
+    new_idx = current_idx + direction
+    if new_idx < 0: new_idx = len(loaded_data) - 1
+    if new_idx >= len(loaded_data): new_idx = 0
+    
+    img_path, info_text = render_loaded_graph(new_idx, loaded_data)
+    return img_path, info_text, gr.update(interactive=True), gr.update(interactive=True), new_idx
+
+def render_loaded_graph(idx, loaded_data):
+    data = loaded_data[idx]
+    G = data["graph"]
+    w = data["width"]
+    h = data["height"]
+    name = data["name"]
+    img_path = plot_graph_to_image(G, w, h, title=f"Loaded: {name}", save_dir=TEMP_DIR)
+    info_text = f"**Viewing {idx + 1} of {len(loaded_data)}**\n\nFile: `{name}`\nNodes: {len(G.nodes())} | Edges: {len(G.edges())}"
+    return img_path, info_text
+
+# ==========================================
+# 5. GRADIO UI LAYOUT
+# ==========================================
+with gr.Blocks(title="Interactive Network Generator") as demo:
+    state = gr.State({"edge_start": None})
+    load_state = gr.State([])
+    load_idx = gr.State(0)
+    
+    gr.Markdown("# Interactive Network Generator")
+    
+    with gr.Tabs():
+        with gr.Tab("Generate & Edit"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 1. Configuration")
+                    topology = gr.Dropdown(["highly_connected", "bottlenecks", "linear"], value="highly_connected", label="Topology")
+                    preset = gr.Radio(["Small", "Medium", "Large", "Custom"], value="Medium", label="Preset")
+                    
+                    with gr.Row():
+                        width = gr.Number(8, label="Grid Width", interactive=False, precision=0)
+                        height = gr.Number(8, label="Grid Height", interactive=False, precision=0)
+                    
+                    with gr.Group():
+                        variant = gr.Dropdown(["Fixed", "Custom"], value="Fixed", label="Variant", info="Custom unlocks Overrides.")
+                        void_frac = gr.Slider(0.0, 0.9, 0.35, step=0.05, label="Void Fraction (Controls Nodes)", interactive=False)
+                        t_edges = gr.Slider(0, 800, 0, step=1, label="Target Edges (0 = Auto)", interactive=False)
+                        capacity_info = gr.Markdown("Active Grid Capacity: N/A")
+                    
+                    gen_btn = gr.Button("Generate Network", variant="primary")
+                    with gr.Row():
+                        save_json_btn = gr.Button("Download JSON", interactive=False)
+                        save_vis_btn = gr.Button("💾 Save Visual Locally", interactive=False)
+                    save_msg = gr.Markdown()
+                    json_file = gr.File(label="Saved JSON", visible=False)
+
+                with gr.Column(scale=2):
+                    metrics = gr.Markdown("Ready to generate.")
+                    click_mode = gr.Radio(["Add/Remove Node", "Add/Remove Edge"], value="Add/Remove Node", label="Mouse Interaction Mode",
+                                          info="For Edges: Click Node 1, then Node 2. Click empty space to cancel selection.")
+                    plot_img = gr.Image(label="Interactive Graph", interactive=False, height=800, width=800)
+
+        with gr.Tab("Batch Export"):
+            gr.Markdown(f"Generates multiple JSON files into a single ZIP. Automatically saves to your `{ZIP_DIR}/` directory.")
+            with gr.Row():
+                with gr.Column():
+                    batch_count = gr.Slider(1, 50, 5, step=1, label="Generation Count")
+                    with gr.Group():
+                        gr.Markdown("### Range Controls (Custom Variant Only)")
+                        with gr.Row():
+                            b_min_void = gr.Slider(0.0, 0.9, 0.1, step=0.05, label="Min Void Fraction")
+                            b_max_void = gr.Slider(0.0, 0.9, 0.6, step=0.05, label="Max Void Fraction")
+                        with gr.Row():
+                            b_min_edges = gr.Number(10, label="Min Target Edges", precision=0)
+                            b_max_edges = gr.Number(100, label="Max Target Edges", precision=0)
+                    batch_btn = gr.Button("Generate Batch ZIP", variant="primary")
+                    file_out = gr.File(label="Download ZIP")
+
+        with gr.Tab("Load & View JSON"):
+            gr.Markdown("Upload JSON/ZIP files or choose a previously generated local ZIP from the dropdown.")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    upload_files = gr.File(label="Upload JSON(s) or ZIP(s)", file_count="multiple", file_types=[".json", ".zip"])
+                    gr.Markdown("---")
+                    with gr.Row():
+                        local_zips = gr.Dropdown(choices=get_local_zips(), label="Select a local ZIP", interactive=True)
+                        refresh_zip_btn = gr.Button("🔄 Refresh List")
+                    gr.Markdown("---")
+                    with gr.Row():
+                        btn_prev = gr.Button("⬅️ Prev", interactive=False)
+                        btn_next = gr.Button("Next ➡️", interactive=False)
+                    load_info = gr.Markdown("No files loaded.")
+                with gr.Column(scale=2):
+                    load_plot = gr.Image(label="Loaded Graph", interactive=False, height=800, width=800)
+
+    # EVENTS
+    inputs_dims = [preset, topology]
+    preset.change(get_preset_dims, inputs_dims, [width, height])
+    topology.change(get_preset_dims, inputs_dims, [width, height])
+    
+    inputs_var = [variant, width, height, topology, void_frac]
+    variant.change(update_ui_for_variant, inputs_var, [void_frac, t_edges, capacity_info])
+    width.change(update_ui_for_variant, inputs_var, [void_frac, t_edges, capacity_info])
+    height.change(update_ui_for_variant, inputs_var, [void_frac, t_edges, capacity_info])
+    topology.change(update_ui_for_variant, inputs_var, [void_frac, t_edges, capacity_info])
+    void_frac.change(update_ui_for_variant, inputs_var, [void_frac, t_edges, capacity_info])
+
+    gen_args = [topology, preset, width, height, variant, void_frac, t_edges]
+    gen_btn.click(generate_and_store, gen_args, [plot_img, metrics, state, save_json_btn])
+    plot_img.select(handle_plot_click, [click_mode, state], [plot_img, metrics, state])
+
+    save_json_btn.click(save_single_json_action, [state], [json_file]).then(lambda: gr.update(visible=True), None, [json_file])
+    save_vis_btn.click(save_permanent_visual, [state], [save_msg])
+
+    batch_args = [batch_count, topology, width, height, variant, b_min_void, b_max_void, b_min_edges, b_max_edges]
+    batch_btn.click(run_batch_generation, batch_args, [file_out, local_zips])
+    
+    upload_files.upload(process_uploaded_files, [upload_files], [load_plot, load_info, btn_prev, btn_next, load_state, load_idx])
+    refresh_zip_btn.click(lambda: gr.update(choices=get_local_zips()), None, [local_zips])
+    local_zips.change(process_local_zip_selection, [local_zips], [load_plot, load_info, btn_prev, btn_next, load_state, load_idx])
+    btn_prev.click(lambda idx, data: change_loaded_graph(-1, idx, data), [load_idx, load_state], [load_plot, load_info, btn_prev, btn_next, load_idx])
+    btn_next.click(lambda idx, data: change_loaded_graph(1, idx, data), [load_idx, load_state], [load_plot, load_info, btn_prev, btn_next, load_idx])
+
+if __name__ == "__main__":
+    demo.launch()

json_handler.py

@@ -0,0 +1,101 @@
+import json
+import random
+import networkx as nx
+import os
+from visualizer import get_sorted_nodes
+
+def prepare_edges_for_json(G):
+    nodes_list = get_sorted_nodes(G)
+    nodes_list_dict = {str(i+1): node for i, node in enumerate(nodes_list)}
+    coord_to_id = {v: k for k, v in nodes_list_dict.items()}
+    edges_formatted = []
+    for u, v in G.edges():
+        if u in coord_to_id and v in coord_to_id:
+            edges_formatted.append({"room1": coord_to_id[u], "room2": coord_to_id[v]})
+    return edges_formatted, list(nodes_list_dict.keys()), nodes_list_dict
+
+def prepare_parameter_for_json(G, I, nodes_list_dict):
+    n_count = len(G.nodes())
+    if n_count == 0:
+        return [], [], [], [], [], [], [], [], [], []
+        
+    weights = [n_count / (n_count * (1 + (((i + 1) * 2) / 30))) for i in range(n_count)]
+    m_weights = random.choices(I, weights=weights, k=5)
+    t_weights_probs = [n_count / (n_count * (1 + (((i + 1) * 2) / 5))) for i in range(10)]
+    t_weights = random.choices(range(1, 11), weights=t_weights_probs, k=5)
+
+    dismantled, conditioningDuration, assignment, help_list = [], [], [], []
+
+    for m in range(5):
+        dismantled.append({"m": str(m + 1), "i": str(m_weights[m]), "t": t_weights[m], "value": 1})
+        conditioningDuration.append({"m": str(m + 1), "value": 1})
+        x = random.randint(1, 3)
+        if m > 2:
+            if 1 not in help_list: x = 1
+            if 2 not in help_list: x = 2
+            if 3 not in help_list: x = 3
+        help_list.append(x)
+        assignment.append({"m": str(m + 1), "r": str(x), "value": 1})
+
+    t_weights_del = random.choices(range(1, 11), weights=t_weights_probs[:10], k=3)
+    delivered = [{"r": str(r+1), "i": "1", "t": t_weights_del[r], "value": 1} for r in range(3)]
+    conditioningCapacity = [{"r": str(r+1), "value": 1} for r in range(3)]
+
+    CostMT, CostMB, CostRT, CostRB, Coord = [], [], [], [], []
+    for i in range(n_count):
+        s_id = str(i + 1)
+        CostMT.append({"i": s_id, "value": random.choice([2, 5])})
+        CostMB.append({"i": s_id, "value": random.choice([5, 10, 30])})
+        CostRT.append({"i": s_id, "value": random.choice([4, 10])})
+        CostRB.append({"i": s_id, "value": 1000 if i==0 else random.choice([20, 30, 100])})
+        if s_id in nodes_list_dict:
+            Coord.append({"i": s_id, "Coordinates": nodes_list_dict[s_id]})
+
+    return dismantled, assignment, delivered, conditioningCapacity, conditioningDuration, CostMT, CostMB, CostRT, CostRB, Coord
+
+def generate_full_json_dict(G, loop=0):
+    edges, I, nodes_list_dict = prepare_edges_for_json(G)
+    dismantled, assignment, delivered, condCap, condDur, CostMT, CostMB, CostRT, CostRB, Coord = prepare_parameter_for_json(G, I, nodes_list_dict)
+    sets = {
+        "I": I, "E": {"bidirectional": True, "seed": 1, "edges": edges},
+        "M": ["1", "2", "3", "4", "5"], "R": ["1", "2", "3"]
+    }
+    params = {
+        "defaults": { "V": 1000, "CostMB": 100, "CostMT": 20, "CostRB": 300, "CostRT": 50 },
+        "t_max": 100, "V": [{"m": "1", "i": "1", "value": 42}],
+        "dismantled": dismantled, "delivered": delivered,
+        "conditioningCapacity": condCap, "conditioningDuration": condDur,
+        "assignment": assignment, "Coord": Coord,
+        "CostMT": CostMT, "CostMB": CostMB, "CostRT": CostRT, "CostRB": CostRB, "CostZR": 9, "CostZH": 5
+    }
+    return {"description": "Generated by Gradio", "sets": sets, "params": params}
+
+def load_graph_from_data(data, name):
+    """Core function to parse loaded JSON data into a NetworkX graph."""
+    G = nx.Graph()
+    id_to_coord = {}
+
+    if "params" in data and "Coord" in data["params"]:
+        for item in data["params"]["Coord"]:
+            coord = tuple(item["Coordinates"])
+            id_to_coord[item["i"]] = coord
+            G.add_node(coord)
+
+    if "sets" in data and "E" in data["sets"] and "edges" in data["sets"]["E"]:
+        for edge in data["sets"]["E"]["edges"]:
+            r1 = edge["room1"]
+            r2 = edge["room2"]
+            if r1 in id_to_coord and r2 in id_to_coord:
+                G.add_edge(id_to_coord[r1], id_to_coord[r2])
+
+    width = max([n[0] for n in G.nodes()]) if len(G.nodes()) > 0 else 10
+    height = max([n[1] for n in G.nodes()]) if len(G.nodes()) > 0 else 10
+    width = int(width + max(2, width * 0.1))
+    height = int(height + max(2, height * 0.1))
+
+    return {"name": name, "graph": G, "width": width, "height": height}
+
+def load_graph_from_json(filepath):
+    with open(filepath, 'r') as f:
+        data = json.load(f)
+    return load_graph_from_data(data, os.path.basename(filepath))

network_generator.py

@@ -0,0 +1,403 @@
+import networkx as nx
+import random
+from visualizer import get_sorted_nodes
+
+def validate_topology(G, topology):
+    n = len(G.nodes())
+    e = len(G.edges())
+    if n < 3: return True, "Graph too small for strict validation."
+    
+    avg_deg = (2.0 * e) / n
+    
+    if topology == "highly_connected":
+        if avg_deg < 2.5:
+            return False, f"Graph is sparse (Avg Degree: {avg_deg:.1f}) for 'Highly Connected'. Add more target edges."
+            
+    elif topology == "bottlenecks":
+        bridges = list(nx.bridges(G))
+        if len(bridges) == 0 and avg_deg > 3.0:
+            return False, "Graph lacks distinct bottleneck links (bridges) and is too dense. Reduce target edges."
+            
+    elif topology == "linear":
+        max_deg = max([d for n, d in G.degree()]) if len(G.nodes()) > 0 else 0
+        if max_deg > 4 or avg_deg > 2.5:
+            return False, f"Graph contains hub nodes (Max Degree: {max_deg}) or is too dense for 'Linear'. Reduce edges."
+            
+    return True, "Topology matches definition."
+
+class NetworkGenerator:
+    def __init__(self, width=10, height=10, variant="F", topology="highly_connected", 
+                 node_drop_fraction=0.1, target_edges=0,
+                 bottleneck_cluster_count=None, bottleneck_edges_per_link=1):
+        
+        self.variant = variant.upper() 
+        self.topology = topology.lower()
+        self.width = int(width)
+        self.height = int(height)
+        
+        self.node_drop_fraction = float(node_drop_fraction)
+        self.target_edges = int(target_edges)
+        self.node_factor = 0.4 
+        
+        if bottleneck_cluster_count is None:
+            area = self.width * self.height
+            self.bottleneck_cluster_count = max(2, int(area / 18))
+        else:
+            self.bottleneck_cluster_count = int(bottleneck_cluster_count)
+            
+        self.bottleneck_edges_per_link = int(bottleneck_edges_per_link)
+        self.graph = None
+        self.active_positions = None 
+
+    # def calculate_defaults(self):
+    #     total_possible = (self.width + 1) * (self.height + 1)
+    #     scale = {"highly_connected": 1.2, "bottlenecks": 0.85, "linear": 0.75}.get(self.topology, 1.0)
+        
+    #     if self.topology == "highly_connected": vf = max(0.0, self.node_drop_fraction * 0.8)
+    #     elif self.topology == "linear": vf = min(0.95, self.node_drop_fraction * 1.2)
+    #     else: vf = self.node_drop_fraction
+        
+    #     est_nodes = int(self.node_factor * scale * total_possible * (1.0 - vf))
+        
+    #     if self.topology == "highly_connected": est_edges = int(3.5 * est_nodes)
+    #     elif self.topology == "bottlenecks": est_edges = int(1.8 * est_nodes)
+    #     else: est_edges = int(1.5 * est_nodes)
+        
+    #     return est_nodes, est_edges
+
+    def calculate_defaults(self):
+        total_possible = self.width * self.height
+        scale = {"highly_connected": 1.2, "bottlenecks": 0.85, "linear": 0.75}.get(self.topology, 1.0)
+        
+        # NEW: Use the unified fraction method we just updated above
+        vf = self._effective_node_drop_fraction()
+        
+        est_nodes = int(self.node_factor * scale * total_possible * (1.0 - vf))
+        if self.topology == "highly_connected": est_edges = int(3.5 * est_nodes)
+        elif self.topology == "bottlenecks": est_edges = int(1.8 * est_nodes)
+        else: est_edges = int(1.5 * est_nodes)
+        return est_nodes, est_edges
+        
+    def calculate_max_capacity(self):
+        """Estimates max possible edges for planar-like spatial graph."""
+        total_possible_nodes = int(self.width * self.height * (1.0 - self.node_drop_fraction))
+        if self.topology == "highly_connected":
+            return int(total_possible_nodes * 4.5)
+        return int(total_possible_nodes * 3.0)
+
+    def generate(self):
+        max_attempts = 15 
+        for attempt in range(max_attempts):
+            self._build_node_mask()
+            self._initialize_graph()
+            self._add_nodes()
+
+            nodes = list(self.graph.nodes())
+            if len(nodes) < 2: continue
+
+            if self.topology == "bottlenecks":
+                self._build_bottleneck_clusters(nodes)
+            else:
+                self._connect_all_nodes_by_nearby_growth(nodes)
+                self._add_edges()
+
+            self._remove_intersections()
+            
+            if self.target_edges > 0:
+                self._adjust_edges_to_target()
+            else:
+                self._enforce_edge_budget()
+
+            if not nx.is_connected(self.graph):
+                self._force_connect_components()
+            
+            self._remove_intersections() 
+            
+            if nx.is_connected(self.graph):
+                return self.graph
+
+        raise RuntimeError("Failed to generate valid network. Loosen overrides.")
+
+    # def _effective_node_drop_fraction(self):
+    #     base = self.node_drop_fraction
+    #     if self.topology == "highly_connected": return max(0.0, base * 0.8)
+    #     if self.topology == "linear": return min(0.95, base * 1.2)
+    #     return base
+
+    def _effective_node_drop_fraction(self):
+        base = self.node_drop_fraction
+        
+        # Fix: app.py passes "R" when the "Custom" variant is selected
+        if self.variant == "R":
+            return base
+            
+        # Safety net for 'Fixed' ("F") presets
+        if self.topology == "highly_connected": return max(0.0, base * 0.8)
+        if self.topology == "linear": return min(0.95, base * 1.2)
+        return base
+
+    def _build_node_mask(self):
+        all_positions = [(x, y) for x in range(self.width) for y in range(self.height)]
+        drop_frac = self._effective_node_drop_fraction()
+        drop = int(drop_frac * len(all_positions))
+        deactivated = set(random.sample(all_positions, drop)) if drop > 0 else set()
+        self.active_positions = set(all_positions) - deactivated
+
+    def _initialize_graph(self):
+        self.graph = nx.Graph()
+        margin_x = max(1, self.width // 4)
+        margin_y = max(1, self.height // 4)
+        low_x, high_x = margin_x, self.width - 1 - margin_x
+        low_y, high_y = margin_y, self.height - 1 - margin_y
+        
+        if low_x > high_x: low_x, high_x = 0, self.width - 1
+        if low_y > high_y: low_y, high_y = 0, self.height - 1
+
+        middle_active = [p for p in self.active_positions if low_x <= p[0] <= high_x and low_y <= p[1] <= high_y]
+        
+        if middle_active: seed = random.choice(middle_active)
+        elif self.active_positions: seed = random.choice(list(self.active_positions))
+        else: return 
+        self.graph.add_node(tuple(seed))
+
+    def _add_nodes(self):
+        for n in self.active_positions:
+            if not self.graph.has_node(n):
+                self.graph.add_node(n)
+
+    def _connect_all_nodes_by_nearby_growth(self, nodes):
+        connected = set()
+        remaining = set(nodes)
+        if not remaining: return
+        current = random.choice(nodes)
+        connected.add(current)
+        remaining.remove(current)
+
+        while remaining:
+            candidates = []
+            for n in remaining:
+                closest_dist = min([abs(n[0]-c[0]) + abs(n[1]-c[1]) for c in connected])
+                if closest_dist <= 4:
+                    candidates.append(n)
+            
+            if not candidates:
+                 best_n = min(remaining, key=lambda r: min(abs(r[0]-c[0]) + abs(r[1]-c[1]) for c in connected))
+                 candidates.append(best_n)
+
+            candidate = random.choice(candidates)
+            neighbors = sorted(list(connected), key=lambda c: abs(c[0]-candidate[0]) + abs(c[1]-candidate[1]))
+            for n in neighbors[:3]:
+                if not self._would_create_intersection(n, candidate):
+                    self.graph.add_edge(n, candidate)
+                    break
+            else:
+                self.graph.add_edge(neighbors[0], candidate)
+
+            connected.add(candidate)
+            remaining.remove(candidate)
+
+    def _compute_edge_count(self):
+        if self.target_edges > 0: return self.target_edges
+        n = len(self.graph.nodes())
+        if self.topology == "highly_connected": return int(3.5 * n)
+        if self.topology == "bottlenecks": return int(1.8 * n)
+        return int(random.uniform(1.2, 2.0) * n)
+
+    def _add_edges(self):
+        nodes = list(self.graph.nodes())
+        if self.topology == "highly_connected": self._add_cluster_dense(nodes, self._compute_edge_count())
+        elif self.topology == "linear": self._make_linear(nodes)
+
+    def _make_linear(self, nodes):
+        nodes_sorted = sorted(nodes, key=lambda x: (x[0], x[1]))
+        if not nodes_sorted: return
+        prev = nodes_sorted[0]
+        for nxt in nodes_sorted[1:]:
+            if not self._would_create_intersection(prev, nxt): self.graph.add_edge(prev, nxt)
+            prev = nxt
+
+    def _add_cluster_dense(self, nodes, max_edges):
+        edges_added = 0
+        nodes = list(nodes)
+        random.shuffle(nodes)
+        dist_limit = 10 if self.target_edges > 0 else 4
+        
+        for i in range(len(nodes)):
+            for j in range(i + 1, len(nodes)):
+                if self.target_edges == 0 and edges_added >= max_edges: return
+                n1, n2 = nodes[i], nodes[j]
+                dist = max(abs(n1[0]-n2[0]), abs(n1[1]-n2[1]))
+                if dist <= dist_limit: 
+                    if not self._would_create_intersection(n1, n2):
+                        self.graph.add_edge(n1, n2)
+                        edges_added += 1
+
+    def _build_bottleneck_clusters(self, nodes):
+        self.graph.remove_edges_from(list(self.graph.edges()))
+        clusters, centers = self._spatial_cluster_nodes(nodes, k=self.bottleneck_cluster_count)
+        for cluster in clusters:
+            if len(cluster) < 2: continue
+            # FIX: Call main connectivity directly
+            self._connect_all_nodes_by_nearby_growth(cluster)
+            self._add_cluster_dense(list(cluster), max_edges=max(1, int(3.5 * len(cluster))))
+        
+        order = sorted(range(len(clusters)), key=lambda i: (centers[i][0], centers[i][1]))
+        for a_idx, b_idx in zip(order[:-1], order[1:]):
+            self._add_bottleneck_links(clusters[a_idx], clusters[b_idx], self.bottleneck_edges_per_link)
+        
+        if not nx.is_connected(self.graph): self._force_connect_components()
+
+    def _force_connect_components(self):
+        components = list(nx.connected_components(self.graph))
+        while len(components) > 1:
+            c1, c2 = list(components[0]), list(components[1])
+            best_pair, min_dist = None, float('inf')
+            s1 = c1 if len(c1)<30 else random.sample(c1, 30)
+            s2 = c2 if len(c2)<30 else random.sample(c2, 30)
+            for u in s1:
+                for v in s2:
+                    d = (u[0]-v[0])**2 + (u[1]-v[1])**2
+                    if d < min_dist and not self._would_create_intersection(u, v):
+                        min_dist, best_pair = d, (u, v)
+            if best_pair: self.graph.add_edge(best_pair[0], best_pair[1])
+            else: break 
+            prev_len = len(components)
+            components = list(nx.connected_components(self.graph))
+            if len(components) == prev_len: break
+
+    def _spatial_cluster_nodes(self, nodes, k):
+        nodes = list(nodes)
+        if k >= len(nodes): return [[n] for n in nodes], nodes[:]
+        centers = random.sample(nodes, k)
+        clusters = [[] for _ in range(k)]
+        for n in nodes:
+            best_i = min(range(k), key=lambda i: max(abs(n[0]-centers[i][0]), abs(n[1]-centers[i][1])))
+            clusters[best_i].append(n)
+        return clusters, centers
+
+    def _add_bottleneck_links(self, cluster_a, cluster_b, m):
+        pairs = []
+        for u in cluster_a:
+            for v in cluster_b:
+                dist = max(abs(u[0]-v[0]), abs(u[1]-v[1]))
+                pairs.append((dist, u, v))
+        pairs.sort(key=lambda t: t[0])
+        added = 0
+        for _, u, v in pairs:
+            if added >= m: break
+            if not self.graph.has_edge(u, v) and not self._would_create_intersection(u, v): 
+                self.graph.add_edge(u, v)
+                added += 1
+
+    def _remove_intersections(self):
+        pass_no = 0
+        while pass_no < 5:
+            pass_no += 1
+            edges = list(self.graph.edges())
+            intersections = []
+            check_edges = random.sample(edges, 400) if len(edges) > 600 else edges
+            for i in range(len(check_edges)):
+                for j in range(i+1, len(check_edges)):
+                    e1, e2 = check_edges[i], check_edges[j]
+                    if self._segments_intersect(e1[0], e1[1], e2[0], e2[1]): intersections.append((e1, e2))
+            if not intersections: break
+            for e1, e2 in intersections:
+                if not self.graph.has_edge(*e1) or not self.graph.has_edge(*e2): continue
+                l1 = (e1[0][0]-e1[1][0])**2 + (e1[0][1]-e1[1][1])**2
+                l2 = (e2[0][0]-e2[1][0])**2 + (e2[0][1]-e2[1][1])**2
+                rem = e1 if l1 > l2 else e2
+                self.graph.remove_edge(*rem)
+
+    def _adjust_edges_to_target(self):
+        current_edges = list(self.graph.edges())
+        curr_count = len(current_edges)
+        if curr_count > self.target_edges:
+            to_remove = curr_count - self.target_edges
+            sorted_edges = sorted(current_edges, key=lambda e: (e[0][0]-e[1][0])**2 + (e[0][1]-e[1][1])**2, reverse=True)
+            for e in sorted_edges:
+                if len(self.graph.edges()) <= self.target_edges: break
+                self.graph.remove_edge(*e)
+                if not nx.is_connected(self.graph): self.graph.add_edge(*e) 
+        elif curr_count < self.target_edges:
+            needed = self.target_edges - curr_count
+            nodes = list(self.graph.nodes())
+            attempts = 0
+            while len(self.graph.edges()) < self.target_edges and attempts < (needed * 30):
+                attempts += 1
+                u = random.choice(nodes)
+                candidates = sorted(nodes, key=lambda n: (n[0]-u[0])**2 + (n[1]-u[1])**2)
+                if len(candidates) < 2: continue
+                v = random.choice(candidates[1:min(len(candidates), 10)])
+                if not self.graph.has_edge(u, v) and not self._would_create_intersection(u, v):
+                    self.graph.add_edge(u, v)
+
+    def _enforce_edge_budget(self):
+        budget = self._compute_edge_count()
+        while len(self.graph.edges()) > budget:
+            edges = list(self.graph.edges())
+            rem = random.choice(edges)
+            self.graph.remove_edge(*rem)
+            if not nx.is_connected(self.graph):
+                self.graph.add_edge(*rem)
+                break 
+
+    def _segments_intersect(self, a, b, c, d):
+        if a == c or a == d or b == c or b == d: return False
+        def ccw(A,B,C): return (C[1]-A[1]) * (B[0]-A[0]) > (B[1]-A[1]) * (C[0]-A[0])
+        return ccw(a,c,d) != ccw(b,c,d) and ccw(a,b,c) != ccw(a,b,d)
+
+    def _would_create_intersection(self, u, v):
+        for a, b in self.graph.edges():
+            if u == a or u == b or v == a or v == b: continue
+            if self._segments_intersect(u, v, a, b): return True
+        return False
+
+    def _get_intersecting_edge(self, u, v):
+        for a, b in self.graph.edges():
+            if u == a or u == b or v == a or v == b: continue
+            if self._segments_intersect(u, v, a, b): return (a, b)
+        return None
+
+    def get_node_id_str(self, node):
+        sorted_nodes = get_sorted_nodes(self.graph)
+        if node in sorted_nodes:
+            return str(sorted_nodes.index(node) + 1)
+        return "?"
+
+    def manual_add_node(self, x, y):
+        x, y = int(x), int(y)
+        # FIX: Bounds check against Width-1
+        if not (0 <= x < self.width and 0 <= y < self.height): return False, "Out of bounds."
+        if self.graph.has_node((x, y)): return False, "Already exists."
+        self.graph.add_node((x, y))
+        nodes = list(self.graph.nodes())
+        if len(nodes) > 1:
+            closest = min([n for n in nodes if n != (x,y)], key=lambda n: (n[0]-x)**2 + (n[1]-y)**2)
+            if not self._would_create_intersection((x,y), closest): self.graph.add_edge((x,y), closest)
+        return True, "Node added."
+
+    def manual_delete_node(self, x, y):
+        x, y = int(x), int(y)
+        if not self.graph.has_node((x, y)): return False, "Node not found."
+        self.graph.remove_node((x, y))
+        if len(self.graph.nodes()) > 1 and not nx.is_connected(self.graph):
+            self._force_connect_components()
+        return True, "Node removed."
+        
+    def manual_toggle_edge(self, u, v):
+        if self.graph.has_edge(u, v):
+            self.graph.remove_edge(u, v)
+            if not nx.is_connected(self.graph): 
+                self.graph.add_edge(u, v)
+                return False, "Cannot remove edge (breaks connectivity)."
+            return True, "Edge removed."
+        else:
+            intersecting_edge = self._get_intersecting_edge(u, v)
+            if not intersecting_edge:
+                self.graph.add_edge(u, v)
+                return True, "Edge added."
+            else:
+                a, b = intersecting_edge
+                id_a = self.get_node_id_str(a)
+                id_b = self.get_node_id_str(b)
+                return False, f"Intersect with {id_a}-{id_b}."

preprocess.py

@@ -0,0 +1,70 @@
+import os
+import sys
+import numpy as np
+import networkx as nx
+
+from network_generator import NetworkGenerator
+from visualizer import get_sorted_nodes
+
+def create_renovation_dataset():
+    print("Generating 10 graphs. Accepting any valid room count...")
+    
+    all_distance_matrices = []
+    all_coord_matrices = []
+    
+    success_count = 0
+    
+    while success_count < 10:
+        sys.stdout.write('.')
+        sys.stdout.flush()
+            
+        try:
+            # We let your generator do what it does best.
+            # We keep target_edges reasonable (75) so it doesn't get stuck drawing crossing lines.
+            gen = NetworkGenerator(
+                width=8, 
+                height=8, 
+                variant="Custom", 
+                topology="highly_connected", 
+                node_drop_fraction=0.2,
+                target_edges=75  
+            )
+            G = gen.generate()
+            
+            sorted_nodes = get_sorted_nodes(G)
+            num_nodes = len(sorted_nodes)
+            
+            # Convert to ML Matrices
+            coords = np.array(sorted_nodes, dtype=np.float32)
+            dist_matrix = np.zeros((num_nodes, num_nodes), dtype=np.float32)
+            
+            for u, v in G.edges():
+                idx_u = sorted_nodes.index(u)
+                idx_v = sorted_nodes.index(v)
+                dist = np.sqrt((u[0] - v[0])**2 + (u[1] - v[1])**2)
+                dist_matrix[idx_u][idx_v] = dist
+                dist_matrix[idx_v][idx_u] = dist
+                
+            all_coord_matrices.append(coords)
+            all_distance_matrices.append(dist_matrix)
+            
+            success_count += 1
+            print(f"\n✅ Graph {success_count} generated with {num_nodes} rooms!")
+                
+        except Exception as e:
+            # If the generator fails to find a valid layout, quietly try again
+            continue
+
+    # Because our matrices might be slightly different sizes (e.g., 51 vs 52), 
+    # we save them as 'object' arrays so NumPy doesn't complain.
+    os.makedirs("dataset", exist_ok=True)
+    np.savez_compressed(
+        "dataset/renovation_data.npz", 
+        distances=np.array(all_distance_matrices, dtype=object), 
+        coords=np.array(all_coord_matrices, dtype=object)
+    )
+    
+    print("\n🎉 Done! Data saved to dataset/renovation_data.npz")
+
+if __name__ == "__main__":
+    create_renovation_dataset()

sandbox.ipynb

@@ -0,0 +1,258 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b59335ea-e22a-41ac-8120-744a8ade2621",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading data from dataset/renovation_data.npz...\n",
+      "Loaded 10 graphs. We will solve Graph #1.\n",
+      "Graph #1 has 54 rooms.\n",
+      "Entrance Identified: Room 0 at coordinates [0. 0.]\n",
+      "Unleashing 50 ants for 100 iterations...\n",
+      "Iteration 000 | Best Route: 138 total moves\n",
+      "Iteration 010 | Best Route: 67 total moves\n",
+      "Iteration 020 | Best Route: 67 total moves\n",
+      "Iteration 030 | Best Route: 64 total moves\n",
+      "Iteration 040 | Best Route: 63 total moves\n",
+      "Iteration 050 | Best Route: 63 total moves\n",
+      "Iteration 060 | Best Route: 63 total moves\n",
+      "Iteration 070 | Best Route: 63 total moves\n",
+      "Iteration 080 | Best Route: 63 total moves\n",
+      "Iteration 090 | Best Route: 63 total moves\n",
+      "\n",
+      "✅ Simulation Complete!\n",
+      "Shortest path found covers all rooms in 63 total moves.\n",
+      "\n",
+      "🗺️  Map saved successfully! Check your folder for 'temp_visuals/optimized_directional_renovation_route.png'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "matplotlib.use('Agg') \n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.sparse.csgraph import shortest_path\n",
+    "\n",
+    "# --- NEW HELPER: Reconstructs the exact physical hallways walked ---\n",
+    "def get_physical_path(start, end, preds):\n",
+    "    path = []\n",
+    "    curr = end\n",
+    "    while curr != start and curr >= 0:\n",
+    "        path.append(curr)\n",
+    "        curr = preds[start, curr]\n",
+    "    path.reverse()\n",
+    "    return path\n",
+    "\n",
+    "def run_ant_colony(distances, coords, n_ants=50, n_iterations=100, decay=0.1, alpha=1.0, beta=2.0):\n",
+    "    n_nodes = distances.shape[0]\n",
+    "    \n",
+    "    # 1. The \"Smart GPS\" (NOW WITH return_predecessors=True)\n",
+    "    dist_matrix_for_pathing = np.where(distances == 0, np.inf, distances)\n",
+    "    np.fill_diagonal(dist_matrix_for_pathing, 0)\n",
+    "    all_pairs_distances, predecessors = shortest_path(csgraph=dist_matrix_for_pathing, directed=False, return_predecessors=True)\n",
+    "    \n",
+    "    # 2. Initialize Pheromones\n",
+    "    pheromones = np.ones((n_nodes, n_nodes)) * 0.1\n",
+    "    \n",
+    "    best_macro_tour = None\n",
+    "    best_length = float('inf')\n",
+    "    \n",
+    "    # Entrance Logic\n",
+    "    start_node = np.lexsort((coords[:, 0], coords[:, 1]))[0]\n",
+    "    print(f\"Entrance Identified: Room {start_node} at coordinates {coords[start_node]}\")\n",
+    "    print(f\"Unleashing {n_ants} ants for {n_iterations} iterations...\")\n",
+    "    \n",
+    "    for iteration in range(n_iterations):\n",
+    "        all_tours = []\n",
+    "        all_lengths = []\n",
+    "        \n",
+    "        for ant in range(n_ants):\n",
+    "            unvisited = set(range(n_nodes))\n",
+    "            current_node = start_node \n",
+    "            tour = [current_node]\n",
+    "            unvisited.remove(current_node)\n",
+    "            tour_length = 0.0\n",
+    "            \n",
+    "            while unvisited:\n",
+    "                candidates = list(unvisited)\n",
+    "                \n",
+    "                pher_values = pheromones[current_node, candidates]\n",
+    "                dist_values = all_pairs_distances[current_node, candidates]\n",
+    "                heuristic = 1.0 / (dist_values + 1e-10) \n",
+    "                \n",
+    "                probabilities = (pher_values ** alpha) * (heuristic ** beta)\n",
+    "                \n",
+    "                if probabilities.sum() == 0:\n",
+    "                    probabilities = np.ones(len(candidates)) / len(candidates)\n",
+    "                else:\n",
+    "                    probabilities /= probabilities.sum() \n",
+    "                \n",
+    "                next_node = np.random.choice(candidates, p=probabilities)\n",
+    "                \n",
+    "                tour.append(next_node)\n",
+    "                tour_length += all_pairs_distances[current_node, next_node]\n",
+    "                unvisited.remove(next_node)\n",
+    "                current_node = next_node\n",
+    "                \n",
+    "            tour_length += all_pairs_distances[tour[-1], tour[0]]\n",
+    "            tour.append(tour[0])\n",
+    "            \n",
+    "            all_tours.append(tour)\n",
+    "            all_lengths.append(tour_length)\n",
+    "            \n",
+    "            if tour_length < best_length:\n",
+    "                best_length = tour_length\n",
+    "                best_macro_tour = tour\n",
+    "                \n",
+    "        pheromones *= (1.0 - decay) \n",
+    "        \n",
+    "        for tour, length in zip(all_tours, all_lengths):\n",
+    "            deposit_amount = 100.0 / length \n",
+    "            for i in range(len(tour) - 1):\n",
+    "                u, v = tour[i], tour[i+1]\n",
+    "                pheromones[u, v] += deposit_amount\n",
+    "                pheromones[v, u] += deposit_amount \n",
+    "                \n",
+    "        if iteration % 10 == 0:\n",
+    "            print(f\"Iteration {iteration:03d} | Best Route: {int(best_length)} total moves\")\n",
+    "            \n",
+    "    # --- NEW: UNPACK THE MACRO TOUR INTO PHYSICAL STEPS ---\n",
+    "    physical_tour = [best_macro_tour[0]]\n",
+    "    for i in range(len(best_macro_tour) - 1):\n",
+    "        start_n = best_macro_tour[i]\n",
+    "        end_n = best_macro_tour[i+1]\n",
+    "        # Inject the actual hallway nodes into the array\n",
+    "        segment = get_physical_path(start_n, end_n, predecessors)\n",
+    "        physical_tour.extend(segment)\n",
+    "        \n",
+    "    return physical_tour, best_length, all_pairs_distances\n",
+    "\n",
+    "def draw_base_graph_edges(ax, distances, coords, color='red'):\n",
+    "    n_nodes = distances.shape[0]\n",
+    "    for u in range(n_nodes):\n",
+    "        for v in range(u + 1, n_nodes): \n",
+    "            if distances[u, v] > 0 and distances[u, v] != np.inf:\n",
+    "                start_c = coords[u]\n",
+    "                end_c = coords[v]\n",
+    "                ax.annotate(\"\", xy=end_c, xytext=start_c, \n",
+    "                            arrowprops=dict(arrowstyle=\"-\", color=color, linewidth=4.0, alpha=0.6, zorder=1))\n",
+    "\n",
+    "def visualize_tour(coords, physical_tour, title, distances):\n",
+    "    fig, ax = plt.figure(figsize=(10, 10)), plt.gca()\n",
+    "    \n",
+    "    xs = coords[:, 0]\n",
+    "    ys = coords[:, 1]\n",
+    "    \n",
+    "    draw_base_graph_edges(ax, distances, coords)\n",
+    "    ax.scatter(xs, ys, c='blue', s=100, zorder=5)\n",
+    "    \n",
+    "    entrance_idx = physical_tour[0]\n",
+    "    ax.scatter(coords[entrance_idx, 0], coords[entrance_idx, 1], c='yellow', edgecolors='black', s=400, marker='*', zorder=10, label=\"Entrance\")\n",
+    "    \n",
+    "    # The physical_tour now ONLY contains strictly adjacent nodes!\n",
+    "    tour_coords = coords[physical_tour]\n",
+    "    \n",
+    "    for i in range(len(tour_coords) - 1):\n",
+    "        start_c = tour_coords[i]\n",
+    "        end_c = tour_coords[i+1]\n",
+    "        \n",
+    "        dx = end_c[0] - start_c[0]\n",
+    "        dy = end_c[1] - start_c[1]\n",
+    "        \n",
+    "        # Draw the continuous dashed line between adjacent rooms\n",
+    "        ax.plot([start_c[0], end_c[0]], [start_c[1], end_c[1]], \n",
+    "                color=\"blue\", linewidth=2.0, linestyle=\"--\", zorder=6)\n",
+    "        \n",
+    "        # Drop the arrowhead exactly at the 50% midpoint\n",
+    "        mid_x = start_c[0] + dx * 0.50\n",
+    "        mid_y = start_c[1] + dy * 0.50\n",
+    "        target_x = start_c[0] + dx * 0.51\n",
+    "        target_y = start_c[1] + dy * 0.51\n",
+    "        \n",
+    "        ax.annotate(\"\", xy=(target_x, target_y), xytext=(mid_x, mid_y),\n",
+    "                    arrowprops=dict(arrowstyle=\"-|>,head_width=0.4,head_length=0.8\", \n",
+    "                                    color=\"blue\", linewidth=2.0, zorder=7))\n",
+    "\n",
+    "    ax.set_title(title, pad=20, fontsize=14, fontweight='bold')\n",
+    "    ax.invert_yaxis() \n",
+    "    ax.grid(True, linestyle=':', alpha=0.6)\n",
+    "    \n",
+    "    from matplotlib.lines import Line2D\n",
+    "    custom_lines = [Line2D([0], [0], color=\"blue\", linewidth=2.0, linestyle=\"--\"),\n",
+    "                    Line2D([0], [0], marker='*', color='w', markerfacecolor='yellow', markeredgecolor='black', markersize=15),\n",
+    "                    Line2D([0], [0], color=\"red\", linewidth=4.0, alpha=0.6)]\n",
+    "    ax.legend(custom_lines, ['Worker Route', 'Entrance', 'Available Hallways'], loc=\"best\")\n",
+    "    \n",
+    "    save_dir = \"temp_visuals\"\n",
+    "    os.makedirs(save_dir, exist_ok=True)\n",
+    "    save_filename = os.path.join(save_dir, \"optimized_directional_renovation_route.png\")\n",
+    "    \n",
+    "    plt.savefig(save_filename, bbox_inches='tight')\n",
+    "    print(f\"\\n🗺️  Map saved successfully! Check your folder for '{save_filename}'\")\n",
+    "    plt.close()\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    dataset_path = os.path.join(\"dataset\", \"renovation_data.npz\")\n",
+    "    print(f\"Loading data from {dataset_path}...\")\n",
+    "    \n",
+    "    data = np.load(dataset_path, allow_pickle=True)\n",
+    "    distances_array = data['distances']\n",
+    "    coords_array = data['coords']\n",
+    "    \n",
+    "    print(f\"Loaded {len(distances_array)} graphs. We will solve Graph #1.\")\n",
+    "    \n",
+    "    original_distances = np.array(distances_array[3], dtype=np.float64)\n",
+    "    test_coords = np.array(coords_array[0], dtype=np.float64)\n",
+    "    \n",
+    "    # 1 Move = 1 Travel Meter\n",
+    "    test_distances = np.where(original_distances > 0, 1.0, 0.0)\n",
+    "    \n",
+    "    print(f\"Graph #1 has {test_distances.shape[0]} rooms.\")\n",
+    "    \n",
+    "    physical_tour, best_length, all_pairs_distances = run_ant_colony(test_distances, test_coords)\n",
+    "    \n",
+    "    print(\"\\n✅ Simulation Complete!\")\n",
+    "    print(f\"Shortest path found covers all rooms in {int(best_length)} total moves.\")\n",
+    "    \n",
+    "    visualize_tour(test_coords, physical_tour, f\"Ant Colony Optimized Renovation Route\\nTotal Moves: {int(best_length)}\", original_distances)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ccdb2d47-4f26-4486-8ff3-a934b7db2e47",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (hivt)",
+   "language": "python",
+   "name": "hivt"
+  },
+  "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.10.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

solver.py

@@ -0,0 +1,189 @@
+import os
+import numpy as np
+import matplotlib
+matplotlib.use('Agg') 
+import matplotlib.pyplot as plt
+from scipy.sparse.csgraph import shortest_path
+
+# --- NEW HELPER: Reconstructs the exact physical hallways walked ---
+def get_physical_path(start, end, preds):
+    path = []
+    curr = end
+    while curr != start and curr >= 0:
+        path.append(curr)
+        curr = preds[start, curr]
+    path.reverse()
+    return path
+
+def run_ant_colony(distances, coords, n_ants=50, n_iterations=100, decay=0.1, alpha=1.0, beta=2.0):
+    n_nodes = distances.shape[0]
+    
+    # 1. The "Smart GPS" (NOW WITH return_predecessors=True)
+    dist_matrix_for_pathing = np.where(distances == 0, np.inf, distances)
+    np.fill_diagonal(dist_matrix_for_pathing, 0)
+    all_pairs_distances, predecessors = shortest_path(csgraph=dist_matrix_for_pathing, directed=False, return_predecessors=True)
+    
+    # 2. Initialize Pheromones
+    pheromones = np.ones((n_nodes, n_nodes)) * 0.1
+    
+    best_macro_tour = None
+    best_length = float('inf')
+    
+    # Entrance Logic
+    start_node = np.lexsort((coords[:, 0], coords[:, 1]))[0]
+    print(f"Entrance Identified: Room {start_node} at coordinates {coords[start_node]}")
+    print(f"Unleashing {n_ants} ants for {n_iterations} iterations...")
+    
+    for iteration in range(n_iterations):
+        all_tours = []
+        all_lengths = []
+        
+        for ant in range(n_ants):
+            unvisited = set(range(n_nodes))
+            current_node = start_node 
+            tour = [current_node]
+            unvisited.remove(current_node)
+            tour_length = 0.0
+            
+            while unvisited:
+                candidates = list(unvisited)
+                
+                pher_values = pheromones[current_node, candidates]
+                dist_values = all_pairs_distances[current_node, candidates]
+                heuristic = 1.0 / (dist_values + 1e-10) 
+                
+                probabilities = (pher_values ** alpha) * (heuristic ** beta)
+                
+                if probabilities.sum() == 0:
+                    probabilities = np.ones(len(candidates)) / len(candidates)
+                else:
+                    probabilities /= probabilities.sum() 
+                
+                next_node = np.random.choice(candidates, p=probabilities)
+                
+                tour.append(next_node)
+                tour_length += all_pairs_distances[current_node, next_node]
+                unvisited.remove(next_node)
+                current_node = next_node
+                
+            tour_length += all_pairs_distances[tour[-1], tour[0]]
+            tour.append(tour[0])
+            
+            all_tours.append(tour)
+            all_lengths.append(tour_length)
+            
+            if tour_length < best_length:
+                best_length = tour_length
+                best_macro_tour = tour
+                
+        pheromones *= (1.0 - decay) 
+        
+        for tour, length in zip(all_tours, all_lengths):
+            deposit_amount = 100.0 / length 
+            for i in range(len(tour) - 1):
+                u, v = tour[i], tour[i+1]
+                pheromones[u, v] += deposit_amount
+                pheromones[v, u] += deposit_amount 
+                
+        if iteration % 10 == 0:
+            print(f"Iteration {iteration:03d} | Best Route: {int(best_length)} total moves")
+            
+    # --- NEW: UNPACK THE MACRO TOUR INTO PHYSICAL STEPS ---
+    physical_tour = [best_macro_tour[0]]
+    for i in range(len(best_macro_tour) - 1):
+        start_n = best_macro_tour[i]
+        end_n = best_macro_tour[i+1]
+        # Inject the actual hallway nodes into the array
+        segment = get_physical_path(start_n, end_n, predecessors)
+        physical_tour.extend(segment)
+        
+    return physical_tour, best_length, all_pairs_distances
+
+def draw_base_graph_edges(ax, distances, coords, color='red'):
+    n_nodes = distances.shape[0]
+    for u in range(n_nodes):
+        for v in range(u + 1, n_nodes): 
+            if distances[u, v] > 0 and distances[u, v] != np.inf:
+                start_c = coords[u]
+                end_c = coords[v]
+                ax.annotate("", xy=end_c, xytext=start_c, 
+                            arrowprops=dict(arrowstyle="-", color=color, linewidth=4.0, alpha=0.6, zorder=1))
+
+def visualize_tour(coords, physical_tour, title, distances):
+    fig, ax = plt.figure(figsize=(10, 10)), plt.gca()
+    
+    xs = coords[:, 0]
+    ys = coords[:, 1]
+    
+    draw_base_graph_edges(ax, distances, coords)
+    ax.scatter(xs, ys, c='blue', s=100, zorder=5)
+    
+    entrance_idx = physical_tour[0]
+    ax.scatter(coords[entrance_idx, 0], coords[entrance_idx, 1], c='yellow', edgecolors='black', s=400, marker='*', zorder=10, label="Entrance")
+    
+    # The physical_tour now ONLY contains strictly adjacent nodes!
+    tour_coords = coords[physical_tour]
+    
+    for i in range(len(tour_coords) - 1):
+        start_c = tour_coords[i]
+        end_c = tour_coords[i+1]
+        
+        dx = end_c[0] - start_c[0]
+        dy = end_c[1] - start_c[1]
+        
+        # Draw the continuous dashed line between adjacent rooms
+        ax.plot([start_c[0], end_c[0]], [start_c[1], end_c[1]], 
+                color="blue", linewidth=2.0, linestyle="--", zorder=6)
+        
+        # Drop the arrowhead exactly at the 50% midpoint
+        mid_x = start_c[0] + dx * 0.50
+        mid_y = start_c[1] + dy * 0.50
+        target_x = start_c[0] + dx * 0.51
+        target_y = start_c[1] + dy * 0.51
+        
+        ax.annotate("", xy=(target_x, target_y), xytext=(mid_x, mid_y),
+                    arrowprops=dict(arrowstyle="-|>,head_width=0.4,head_length=0.8", 
+                                    color="blue", linewidth=2.0, zorder=7))
+
+    ax.set_title(title, pad=20, fontsize=14, fontweight='bold')
+    ax.invert_yaxis() 
+    ax.grid(True, linestyle=':', alpha=0.6)
+    
+    from matplotlib.lines import Line2D
+    custom_lines = [Line2D([0], [0], color="blue", linewidth=2.0, linestyle="--"),
+                    Line2D([0], [0], marker='*', color='w', markerfacecolor='yellow', markeredgecolor='black', markersize=15),
+                    Line2D([0], [0], color="red", linewidth=4.0, alpha=0.6)]
+    ax.legend(custom_lines, ['Worker Route', 'Entrance', 'Available Hallways'], loc="best")
+    
+    save_dir = "temp_visuals"
+    os.makedirs(save_dir, exist_ok=True)
+    save_filename = os.path.join(save_dir, "optimized_directional_renovation_route.png")
+    
+    plt.savefig(save_filename, bbox_inches='tight')
+    print(f"\n🗺️  Map saved successfully! Check your folder for '{save_filename}'")
+    plt.close()
+
+if __name__ == "__main__":
+    dataset_path = os.path.join("dataset", "renovation_data.npz")
+    print(f"Loading data from {dataset_path}...")
+    
+    data = np.load(dataset_path, allow_pickle=True)
+    distances_array = data['distances']
+    coords_array = data['coords']
+    
+    print(f"Loaded {len(distances_array)} graphs. We will solve Graph #1.")
+    
+    original_distances = np.array(distances_array[0], dtype=np.float64)
+    test_coords = np.array(coords_array[0], dtype=np.float64)
+    
+    # 1 Move = 1 Travel Meter
+    test_distances = np.where(original_distances > 0, 1.0, 0.0)
+    
+    print(f"Graph #1 has {test_distances.shape[0]} rooms.")
+    
+    physical_tour, best_length, all_pairs_distances = run_ant_colony(test_distances, test_coords)
+    
+    print("\n✅ Simulation Complete!")
+    print(f"Shortest path found covers all rooms in {int(best_length)} total moves.")
+    
+    visualize_tour(test_coords, physical_tour, f"Ant Colony Optimized Renovation Route\nTotal Moves: {int(best_length)}", original_distances)

visualizer.py

@@ -0,0 +1,66 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+from datetime import datetime
+import os
+import shutil
+
+IMG_WIDTH_PX = 800
+IMG_HEIGHT_PX = 800
+TEMP_DIR = "temp_visuals"
+
+# --- NEW CLEANUP LOGIC ---
+# Wipe the folder clean when the app starts, then recreate it
+if os.path.exists(TEMP_DIR):
+    shutil.rmtree(TEMP_DIR)
+os.makedirs(TEMP_DIR, exist_ok=True)
+# -------------------------
+
+def get_sorted_nodes(G):
+    """Returns nodes sorted by X, then Y to ensure consistent IDs."""
+    return sorted(list(G.nodes()), key=lambda l: (l[0], l[1]))
+
+def plot_graph_to_image(graph, width, height, title="Network", highlight_node=None, save_dir=TEMP_DIR):
+    """Generates a matplotlib plot and saves it as an image file."""
+    dpi = 100
+    fig = plt.figure(figsize=(IMG_WIDTH_PX/dpi, IMG_HEIGHT_PX/dpi), dpi=dpi)
+    ax = fig.add_axes([0, 0, 1, 1]) 
+    
+    pos = {node: (node[0], node[1]) for node in graph.nodes()}
+    
+    # Dynamic sizing to prevent jamming
+    max_dim = max(width, height)
+    if max_dim <= 6:
+        n_sz, f_sz, h_sz = 900, 12, 1100
+    elif max_dim <= 10:
+        n_sz, f_sz, h_sz = 500, 9, 650
+    elif max_dim <= 16:
+        n_sz, f_sz, h_sz = 200, 7, 280
+    elif max_dim <= 24:
+        n_sz, f_sz, h_sz = 100, 5, 140
+    else:
+        n_sz, f_sz, h_sz = 50, 4, 80
+
+    nx.draw_networkx_edges(graph, pos, ax=ax, width=2, alpha=0.6, edge_color="#333")
+    
+    normal_nodes = [n for n in graph.nodes() if n != highlight_node]
+    nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=normal_nodes, node_size=n_sz, node_color="#4F46E5", edgecolors="white", linewidths=1.5)
+    
+    if highlight_node and graph.has_node(highlight_node):
+        nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=[highlight_node], node_size=h_sz, node_color="#EF4444", edgecolors="white", linewidths=2.0)
+    
+    sorted_nodes = get_sorted_nodes(graph)
+    labels = {node: str(i+1) for i, node in enumerate(sorted_nodes)}
+    nx.draw_networkx_labels(graph, pos, labels, ax=ax, font_size=f_sz, font_color="white", font_weight="bold")
+    
+    ax.set_xlim(-0.5, width + 0.5)
+    ax.set_ylim(height + 0.5, -0.5)
+    ax.grid(True, linestyle=':', alpha=0.3)
+    ax.set_axis_on()
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    prefix = "temp_plot" if save_dir == TEMP_DIR else "saved_plot"
+    fname = os.path.join(save_dir, f"{prefix}_{timestamp}.png")
+    
+    plt.savefig(fname)
+    plt.close(fig)
+    return fname