mapping_network_from_csv.py

import geopandas as gpd
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from shapely.geometry import Point
import networkx as nx
import csv
import tower

# Membaca shapefile dan data lain
shapefile_path = "shape_Banten/indonesia_Province_level_1.shp"
world = gpd.read_file(shapefile_path)
banten = world[world["shape1"] == 'Banten']
banten_geom = banten.geometry.iloc[0]

provider = "Telkomsel"

# ---------------------------------------------------------------------------------------------
# Mengumpulkan Data Tower
print("[Mengumpulkan Lokasi Tower...]")
tower_positions = tower.get_tower()

print("[Mengumpulkan Data Tower]")
data_tower = tower.towers
data_dBm_tower = [int(x['max_signal_rsrp'].replace(' dBm', '')) for x in data_tower]

# ---------------------------------------------------------------------------------------------
# Membaca data beban tower dari CSV
print("[Membaca Data Beban Tower dari CSV...]")
tower_loads_from_csv = {}
tower_user_counts = {}

with open('tower_load.csv', newline='') as csvfile:
    reader = csv.reader(csvfile)
    for row in reader:
        tower_name = row[0].strip()  # e.g., "Tower_23"
        load_value = float(row[1].strip())
        
        # Extract tower number from "Tower_23" -> 23
        tower_num = int(tower_name.split('_')[1])
        tower_loads_from_csv[tower_num] = load_value
        
        # Estimasi jumlah user berdasarkan beban (asumsi sederhana)
        # Karena CSV hanya punya beban, kita estimasi user count
        # Beban tinggi = user banyak
        tower_user_counts[tower_num] = int(load_value)

print(f"Total towers loaded from CSV: {len(tower_loads_from_csv)}")

# ---------------------------------------------------------------------------------------------
# Buat data sinyal dummy untuk visualisasi (tidak perlu akurat, hanya untuk plot)
# Kita akan distribusikan user berdasarkan beban tower dari CSV
print("[Membuat Data Sinyal untuk Visualisasi...]")
data_sinyal = {
    "latitude": [],
    "longitude": [],
    "signal_strength": [],
    "tower_idx": []
}

import random
random.seed(42)  # Set seed untuk hasil yang konsisten

for tower_idx in range(1, len(tower_positions) + 1):
    user_count = tower_user_counts.get(tower_idx, 0)
    tower_lon, tower_lat = tower_positions[tower_idx - 1]
    
    # Generate user di sekitar tower berdasarkan jumlah user
    for _ in range(user_count):
        # Random offset dari tower (dalam radius kecil)
        offset_lat = random.uniform(-0.05, 0.05)
        offset_lon = random.uniform(-0.05, 0.05)
        
        user_lat = tower_lat + offset_lat
        user_lon = tower_lon + offset_lon
        
        # Pastikan masih dalam banten
        point = Point(user_lon, user_lat)
        if banten_geom.contains(point):
            # Signal strength berdasarkan jarak
            distance = Point(tower_lon, tower_lat).distance(Point(user_lon, user_lat))
            if distance < 0.02:
                signal_strength = random.randint(-80, -60)
            elif distance < 0.05:
                signal_strength = random.randint(-96, -81)
            else:
                signal_strength = random.randint(-110, -97)
            
            data_sinyal["latitude"].append(user_lat)
            data_sinyal["longitude"].append(user_lon)
            data_sinyal["signal_strength"].append(signal_strength)
            data_sinyal["tower_idx"].append(tower_idx)

print(f"Total users generated: {len(data_sinyal['latitude'])}")

# ---------------------------------------------------------------------------------------------
# Buat GeoDataFrame untuk sinyal
df_sinyal = pd.DataFrame(data_sinyal)
geometry = [Point(xy) for xy in zip(df_sinyal["longitude"], df_sinyal["latitude"])]
geo_df_sinyal = gpd.GeoDataFrame(df_sinyal, geometry=geometry)

# ---------------------------------------------------------------------------------------------
# Algoritma NetworkX
G = nx.Graph()

# Menambahkan node untuk tower
for i, (lon, lat) in enumerate(tower_positions, start=1):
    G.add_node(f"Tower_{i}", pos=(lon, lat), type="tower")
    
# Menambahkan node untuk sinyal
for i, row in df_sinyal.iterrows():
    G.add_node(f"Signal_{i}", pos=(row["longitude"], row["latitude"]), 
               type="signal", signal_strength=row["signal_strength"])
    
# ---------------------------------------------------------------------------------------------
# Algoritma Nearest Neighbor
edges = []
for i, row in df_sinyal.iterrows():
    signal_point = Point(row["longitude"], row["latitude"])
    closest_tower = None
    min_distance = float("inf")
    
    for j, (lon, lat) in enumerate(tower_positions):
        tower_point = Point(lon, lat)
        distance = signal_point.distance(tower_point)
        if distance < min_distance:
            min_distance = distance
            closest_tower = f"Tower_{j+1}"
    if closest_tower is not None:
        edges.append((f"Signal_{i}", closest_tower, min_distance))

G.add_weighted_edges_from(edges)

# ---------------------------------------------------------------------------------------------
mst = nx.minimum_spanning_tree(G)
fig, ax = plt.subplots(figsize=(12, 10))
banten.plot(ax=ax, color="lightgrey", edgecolor="black")
ax.set_title(f"Persebaran Sinyal Telkomsel di Banten Berbasis GIS\nMenggunakan Algoritma Network Analysis dan Nearest Neighbor\n(Data dari tower_load.csv)")

# ---------------------------------------------------------------------------------------------
# Plot tower dan beri label nomor
for idx, (lon, lat) in enumerate(tower_positions):
    ax.scatter(lon, lat, color="blue", s=10, label="Tower Provider Telkomsel" if idx == 0 else "")
    ax.text(lon, lat, f"{idx+1}", fontsize=8, ha='left', va='bottom', color='blue')

# Plot sinyal
for i, row in df_sinyal.iterrows():
    lon = row["longitude"]
    lat = row["latitude"]
    distances = [Point(t).distance(Point(lon, lat)) for t in tower_positions]
    min_distance = min(distances)
    get_dBm_tower = data_dBm_tower[distances.index(min_distance)]

    color = "red" if row["signal_strength"] <= get_dBm_tower else \
            "yellow" if row["signal_strength"] <= get_dBm_tower+16 else "green"
    ax.scatter(row["longitude"], row["latitude"], color=color, s=10)

# ---------------------------------------------------------------------------------------------
# Tampilkan statistik
print("\n[Number of Users per Tower (from CSV)]")
for i in range(1, len(tower_positions)+1):
    print(f"Tower_{i}: {tower_user_counts.get(i, 0)} users")

# Konversi hasil beban tiap tower ke DataFrame
tower_load_df = pd.DataFrame({
    "Tower": [f"Tower_{i}" for i in range(1, len(tower_positions)+1)],
    "Beban (Bt)": [tower_loads_from_csv.get(i, 0.0) for i in range(1, len(tower_positions)+1)]
})

# Urutkan dari beban terbesar ke terkecil
tower_load_df = tower_load_df.sort_values(by="Beban (Bt)", ascending=False).reset_index(drop=True)

# Tampilkan tabel
print("\n[Beban Tiap Tower (from CSV)]")
from tabulate import tabulate
tower_load_df["Beban (Bt)"] = tower_load_df["Beban (Bt)"].round(2)
print(tabulate(tower_load_df.head(20), headers='keys', tablefmt='pretty', showindex=False))

# Tampilkan Overload
C = 20
lower_bound = 0.3 * C

urban_towers = list(tower_positions)
status = {}
for i in range(1, len(urban_towers)+1):
    l = tower_user_counts.get(i, 0)
    status[i] = "Overloaded" if l > C else ("Underutilized" if l < lower_bound else "Normal")

N_urban = len(urban_towers)
N_overload_urban = sum(1 for s in status.values() if s == "Overloaded")
percent_overload_urban = (N_overload_urban / N_urban) * 100

print(f"\nPercentage of overloaded towers in urban area: {percent_overload_urban:.2f}%")

# ---------------------------------------------------------------------------------------------
# Visualisasi jaringan dengan NetworkX
print("[Menampilkan Visualisasi...]")
pos = nx.get_node_attributes(G, "pos")
nx.draw_networkx_edges(mst, pos, ax=ax, alpha=0.3, edge_color="gray")

# Ambil Top 10 tower dengan beban terbesar
top10 = tower_load_df.sort_values(by="Beban (Bt)", ascending=False).head(10)

# Buat teks keterangan
text_lines = ["Top 10 Tower dengan Beban Tertinggi:"]
for i, row in top10.iterrows():
    text_lines.append(f"{row['Tower']}: {row['Beban (Bt)']:.2f}")
full_text = "\n".join(text_lines)

# Tambahkan teks ke sisi kanan plot
plt.subplots_adjust(right=0.7)
ax.text(1.05, 0.95, full_text, transform=ax.transAxes,
        fontsize=10, verticalalignment='top',
        bbox=dict(boxstyle="round,pad=0.5", facecolor="white", edgecolor="black"))

# Top 10 by connected users (sama dengan beban karena kita estimasi dari beban)
top10_users = sorted(tower_user_counts.items(), key=lambda x: x[1], reverse=True)[:10]
user_lines = ["Top 10 Towers by Connected Users:"]
for idx, (tower_idx, user_count) in enumerate(top10_users, start=1):
    user_lines.append(f"{idx}. Tower_{tower_idx}: {user_count} users")
user_text = "\n".join(user_lines)
ax.text(
    1.05, 0.55, user_text, transform=ax.transAxes, fontsize=10,
    verticalalignment='top',
    bbox=dict(boxstyle="round,pad=0.5", facecolor="white", edgecolor="black")
)

plt.xlabel("Longitude")
plt.ylabel("Latitude")
legend_elements = [
    Line2D([0], [0], marker='o', color='w', label=f'Tower Provider {provider} (100 tower)',
           markerfacecolor='blue', markersize=10),
    Line2D([0], [0], marker='o', color='w', label='User Sinyal Kuat (RSRP >= -80dBm)',
           markerfacecolor='green', markersize=10),
    Line2D([0], [0], marker='o', color='w', label='User Sinyal Sedang (-96dBm < RSRP < -80dBm)',
           markerfacecolor='yellow', markersize=10),
    Line2D([0], [0], marker='o', color='w', label='User Sinyal Lemah (RSRP <= -96dBm)',
           markerfacecolor='red', markersize=10),
]
plt.legend(handles=legend_elements, loc="upper left")
plt.savefig('result/Telkomsel_Signal_Distribution_from_CSV.png', dpi=300, bbox_inches='tight')
print("\n[Visualisasi disimpan ke: result/Telkomsel_Signal_Distribution_from_CSV.png]")
plt.show()