Spaces:
Runtime error
Runtime error
Updated app.py to v10.4
Browse files
app.py
CHANGED
|
@@ -23,9 +23,9 @@ import pytz
|
|
| 23 |
app = Flask(__name__)
|
| 24 |
CORS(app)
|
| 25 |
|
| 26 |
-
print("🚀 COOLRIDE ENGINE V10.
|
| 27 |
|
| 28 |
-
# 1. LOAD THE MAP
|
| 29 |
MAP_PATH = "Data/singapore_final.graphml.gz"
|
| 30 |
if os.path.exists(MAP_PATH):
|
| 31 |
print(f" 📂 Loading Graph: {MAP_PATH}...")
|
|
@@ -34,46 +34,54 @@ if os.path.exists(MAP_PATH):
|
|
| 34 |
else:
|
| 35 |
raise FileNotFoundError("CRITICAL: singapore_final.graphml.gz not found!")
|
| 36 |
|
| 37 |
-
# 2. LOAD
|
| 38 |
-
print(" 🌳 Indexing
|
| 39 |
|
| 40 |
-
# Trees
|
| 41 |
try:
|
| 42 |
trees_df = pd.read_csv("Data/trees.csv")
|
| 43 |
-
#
|
| 44 |
geometry = [Point(xy) for xy in zip(trees_df.lng, trees_df.lat)]
|
| 45 |
trees_gdf = gpd.GeoDataFrame(trees_df, geometry=geometry, crs="EPSG:4326")
|
| 46 |
tree_index = STRtree(trees_gdf.geometry)
|
| 47 |
-
print(f" ✅ Indexed {len(trees_gdf):,}
|
| 48 |
except Exception as e:
|
| 49 |
print(f" ⚠️ Tree load failed: {e}")
|
| 50 |
tree_index = None
|
| 51 |
|
| 52 |
-
# Water
|
| 53 |
try:
|
| 54 |
water_gdf = gpd.read_file("Data/URA_Waterbody.geojson")
|
| 55 |
water_index = STRtree(water_gdf.geometry)
|
| 56 |
-
print(f" ✅ Indexed {len(water_gdf):,}
|
| 57 |
except:
|
| 58 |
water_index = None
|
| 59 |
print(" ⚠️ Water load failed.")
|
| 60 |
|
| 61 |
-
#
|
| 62 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 63 |
try:
|
| 64 |
hawkers = gpd.read_file("Data/hawker_centres.geojson")
|
| 65 |
for _, row in hawkers.iterrows():
|
| 66 |
-
# Handle different GeoJSON structures
|
| 67 |
name = row.get('Name', row.get('name', 'Hawker Centre'))
|
| 68 |
pt = row.geometry.centroid
|
| 69 |
-
|
| 70 |
|
| 71 |
marts = gpd.read_file("Data/supermarkets.geojson")
|
| 72 |
for _, row in marts.iterrows():
|
| 73 |
name = row.get('Name', row.get('name', 'Supermarket'))
|
| 74 |
pt = row.geometry.centroid
|
| 75 |
-
|
| 76 |
-
print(f" ✅ Loaded {len(
|
| 77 |
except:
|
| 78 |
print(" ⚠️ Amenities load failed.")
|
| 79 |
|
|
@@ -82,138 +90,145 @@ except:
|
|
| 82 |
# ==========================================
|
| 83 |
|
| 84 |
def get_realtime_weather():
|
| 85 |
-
"""Fetches live Temp from NEA API
|
| 86 |
try:
|
| 87 |
url = "https://api.data.gov.sg/v1/environment/air-temperature"
|
| 88 |
-
data = requests.get(url, timeout=
|
| 89 |
readings = data['items'][0]['readings']
|
| 90 |
-
# Average all stations for a general SG temp
|
| 91 |
temps = [r['value'] for r in readings]
|
| 92 |
-
|
| 93 |
-
return avg_temp
|
| 94 |
except:
|
| 95 |
-
return 31.
|
| 96 |
|
| 97 |
def calculate_sun_factor(edge_bearing, dt):
|
| 98 |
-
"""Calculates
|
| 99 |
-
if dt.hour < 7 or dt.hour > 19: return 0
|
| 100 |
-
|
| 101 |
-
# Get Sun Azimuth
|
| 102 |
altitude = solar.get_altitude(1.3521, 103.8198, dt)
|
| 103 |
azimuth = solar.get_azimuth(1.3521, 103.8198, dt)
|
| 104 |
-
|
| 105 |
if altitude < 0: return 0
|
| 106 |
|
| 107 |
-
# If edge bearing is close to sun azimuth, you are exposed
|
| 108 |
diff = abs(edge_bearing - azimuth)
|
| 109 |
if diff > 180: diff = 360 - diff
|
| 110 |
|
| 111 |
-
#
|
| 112 |
-
# Return penalty factor (0.0 to 1.0)
|
| 113 |
return max(0, (90 - diff) / 90) * 0.2
|
| 114 |
|
| 115 |
def get_cool_cost(u, v, data, dt):
|
| 116 |
-
"""
|
|
|
|
|
|
|
|
|
|
| 117 |
length = data.get('length', 10)
|
| 118 |
|
| 119 |
-
# 1. BASELINE:
|
|
|
|
| 120 |
highway = data.get('highway', '')
|
| 121 |
-
if highway in ['cycleway', 'path', 'track']:
|
| 122 |
-
base_weight = 0.4 # Cool
|
| 123 |
-
elif highway in ['residential', 'service']:
|
| 124 |
-
base_weight = 0.7 # Moderate
|
| 125 |
-
else:
|
| 126 |
-
base_weight = 1.0 # Hot (Primary roads)
|
| 127 |
-
|
| 128 |
-
# 2. SURFACE MODIFIER (From your new data!)
|
| 129 |
surface = data.get('surface', 'unknown')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 130 |
if surface in ['paving_stones', 'concrete', 'grass']:
|
| 131 |
-
base_weight -= 0.1 #
|
| 132 |
elif surface == 'asphalt':
|
| 133 |
-
base_weight += 0.05 #
|
| 134 |
|
| 135 |
-
#
|
| 136 |
-
# We check the midpoint of the edge against our R-Tree Index
|
| 137 |
-
# (This is the efficient "Slicing")
|
| 138 |
bonus = 0
|
| 139 |
-
|
| 140 |
if 'geometry' in data:
|
| 141 |
midpoint = data['geometry'].interpolate(0.5, normalized=True)
|
| 142 |
else:
|
| 143 |
midpoint = Point(G.nodes[u]['x'], G.nodes[u]['y'])
|
| 144 |
|
| 145 |
-
# Tree
|
| 146 |
if tree_index:
|
| 147 |
nearest_idx = tree_index.nearest(midpoint)
|
| 148 |
-
# Check distance to nearest tree
|
| 149 |
nearest_tree = trees_gdf.iloc[nearest_idx].geometry
|
| 150 |
-
if midpoint.distance(nearest_tree) < 0.0002: #
|
| 151 |
-
bonus += 0.
|
| 152 |
|
| 153 |
-
# Water
|
| 154 |
if water_index:
|
| 155 |
nearest_w_idx = water_index.nearest(midpoint)
|
| 156 |
nearest_water = water_gdf.iloc[nearest_w_idx].geometry
|
| 157 |
-
if midpoint.distance(nearest_water) < 0.0005: #
|
| 158 |
-
bonus += 0.
|
| 159 |
|
| 160 |
-
#
|
| 161 |
-
if
|
| 162 |
-
|
|
|
|
|
|
|
|
|
|
| 163 |
|
| 164 |
-
#
|
| 165 |
-
# We estimate bearing between nodes
|
| 166 |
lat1, lon1 = G.nodes[u]['y'], G.nodes[u]['x']
|
| 167 |
lat2, lon2 = G.nodes[v]['y'], G.nodes[v]['x']
|
| 168 |
bearing = ox.bearing.calculate_bearing(lat1, lon1, lat2, lon2)
|
| 169 |
sun_penalty = calculate_sun_factor(bearing, dt)
|
| 170 |
|
|
|
|
|
|
|
| 171 |
final_weight = max(0.1, base_weight - bonus + sun_penalty)
|
| 172 |
return length * final_weight
|
| 173 |
|
| 174 |
# ==========================================
|
| 175 |
-
# 🛣️
|
| 176 |
# ==========================================
|
| 177 |
|
| 178 |
@app.route('/')
|
| 179 |
def index():
|
| 180 |
return render_template('index.html')
|
| 181 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 182 |
@app.route('/api/route', methods=['POST'])
|
| 183 |
def calculate_route():
|
| 184 |
try:
|
| 185 |
data = request.json
|
| 186 |
-
print(f"📨
|
| 187 |
|
| 188 |
-
|
| 189 |
-
|
| 190 |
-
|
| 191 |
-
|
| 192 |
|
| 193 |
-
|
|
|
|
|
|
|
|
|
|
| 194 |
sgt = pytz.timezone('Asia/Singapore')
|
| 195 |
now = datetime.now(sgt)
|
| 196 |
|
| 197 |
# 1. FIND NODES
|
| 198 |
-
orig = ox.distance.nearest_nodes(G,
|
| 199 |
-
dest = ox.distance.nearest_nodes(G,
|
|
|
|
| 200 |
|
| 201 |
-
# 2.
|
| 202 |
-
|
| 203 |
-
|
| 204 |
-
|
| 205 |
-
|
| 206 |
-
|
| 207 |
-
|
| 208 |
-
|
| 209 |
-
|
| 210 |
-
|
| 211 |
-
|
| 212 |
-
|
| 213 |
-
|
| 214 |
-
|
| 215 |
-
|
| 216 |
-
|
|
|
|
| 217 |
def process_path(route):
|
| 218 |
coords = []
|
| 219 |
total_len = 0
|
|
@@ -231,7 +246,7 @@ def calculate_route():
|
|
| 231 |
fast_coords, fast_len = process_path(r_fast)
|
| 232 |
cool_coords, cool_len = process_path(r_cool)
|
| 233 |
|
| 234 |
-
# 4. KML
|
| 235 |
kml = simplekml.Kml()
|
| 236 |
ls1 = kml.newlinestring(name="Fastest Route")
|
| 237 |
ls1.coords = [(lon, lat) for lat, lon in fast_coords]
|
|
@@ -243,12 +258,12 @@ def calculate_route():
|
|
| 243 |
ls2.style.linestyle.color = simplekml.Color.green
|
| 244 |
ls2.style.linestyle.width = 4
|
| 245 |
|
| 246 |
-
|
| 247 |
-
|
| 248 |
-
# 5. WEATHER & METRICS
|
| 249 |
current_temp = get_realtime_weather()
|
| 250 |
-
|
| 251 |
-
|
|
|
|
|
|
|
| 252 |
|
| 253 |
return jsonify({
|
| 254 |
"status": "success",
|
|
@@ -260,7 +275,7 @@ def calculate_route():
|
|
| 260 |
"temp": current_temp,
|
| 261 |
"shade_gain": f"{shade_gain}%"
|
| 262 |
},
|
| 263 |
-
"kml":
|
| 264 |
})
|
| 265 |
|
| 266 |
except Exception as e:
|
|
|
|
| 23 |
app = Flask(__name__)
|
| 24 |
CORS(app)
|
| 25 |
|
| 26 |
+
print("🚀 COOLRIDE ENGINE V10.4 (SCIENTIFIC) INITIALIZING...")
|
| 27 |
|
| 28 |
+
# 1. LOAD THE MAP
|
| 29 |
MAP_PATH = "Data/singapore_final.graphml.gz"
|
| 30 |
if os.path.exists(MAP_PATH):
|
| 31 |
print(f" 📂 Loading Graph: {MAP_PATH}...")
|
|
|
|
| 34 |
else:
|
| 35 |
raise FileNotFoundError("CRITICAL: singapore_final.graphml.gz not found!")
|
| 36 |
|
| 37 |
+
# 2. LOAD & INDEX LAYERS (Spatial Indexing for Speed)
|
| 38 |
+
print(" 🌳 Indexing Layers...")
|
| 39 |
|
| 40 |
+
# Trees
|
| 41 |
try:
|
| 42 |
trees_df = pd.read_csv("Data/trees.csv")
|
| 43 |
+
# FIX: Using 'lng' and 'lat' based on your CSV header
|
| 44 |
geometry = [Point(xy) for xy in zip(trees_df.lng, trees_df.lat)]
|
| 45 |
trees_gdf = gpd.GeoDataFrame(trees_df, geometry=geometry, crs="EPSG:4326")
|
| 46 |
tree_index = STRtree(trees_gdf.geometry)
|
| 47 |
+
print(f" ✅ Indexed {len(trees_gdf):,} Trees (Shade Source).")
|
| 48 |
except Exception as e:
|
| 49 |
print(f" ⚠️ Tree load failed: {e}")
|
| 50 |
tree_index = None
|
| 51 |
|
| 52 |
+
# Water Bodies
|
| 53 |
try:
|
| 54 |
water_gdf = gpd.read_file("Data/URA_Waterbody.geojson")
|
| 55 |
water_index = STRtree(water_gdf.geometry)
|
| 56 |
+
print(f" ✅ Indexed {len(water_gdf):,} Water Bodies (Cool Sinks).")
|
| 57 |
except:
|
| 58 |
water_index = None
|
| 59 |
print(" ⚠️ Water load failed.")
|
| 60 |
|
| 61 |
+
# PCN (Park Connector Network)
|
| 62 |
+
try:
|
| 63 |
+
pcn_gdf = gpd.read_file("Data/ParkConnectorLoop.geojson")
|
| 64 |
+
pcn_index = STRtree(pcn_gdf.geometry)
|
| 65 |
+
print(f" ✅ Indexed {len(pcn_gdf):,} PCN Segments (Green Corridors).")
|
| 66 |
+
except:
|
| 67 |
+
pcn_index = None
|
| 68 |
+
print(" ⚠️ PCN load failed.")
|
| 69 |
+
|
| 70 |
+
# Amenities (Load into memory for API)
|
| 71 |
+
amenities_data = []
|
| 72 |
try:
|
| 73 |
hawkers = gpd.read_file("Data/hawker_centres.geojson")
|
| 74 |
for _, row in hawkers.iterrows():
|
|
|
|
| 75 |
name = row.get('Name', row.get('name', 'Hawker Centre'))
|
| 76 |
pt = row.geometry.centroid
|
| 77 |
+
amenities_data.append({"name": name, "lat": pt.y, "lon": pt.x, "type": "Hawker"})
|
| 78 |
|
| 79 |
marts = gpd.read_file("Data/supermarkets.geojson")
|
| 80 |
for _, row in marts.iterrows():
|
| 81 |
name = row.get('Name', row.get('name', 'Supermarket'))
|
| 82 |
pt = row.geometry.centroid
|
| 83 |
+
amenities_data.append({"name": name, "lat": pt.y, "lon": pt.x, "type": "Supermarket"})
|
| 84 |
+
print(f" ✅ Loaded {len(amenities_data)} Amenities.")
|
| 85 |
except:
|
| 86 |
print(" ⚠️ Amenities load failed.")
|
| 87 |
|
|
|
|
| 90 |
# ==========================================
|
| 91 |
|
| 92 |
def get_realtime_weather():
|
| 93 |
+
"""Fetches live Temp from NEA API."""
|
| 94 |
try:
|
| 95 |
url = "https://api.data.gov.sg/v1/environment/air-temperature"
|
| 96 |
+
data = requests.get(url, timeout=2).json()
|
| 97 |
readings = data['items'][0]['readings']
|
|
|
|
| 98 |
temps = [r['value'] for r in readings]
|
| 99 |
+
return sum(temps) / len(temps)
|
|
|
|
| 100 |
except:
|
| 101 |
+
return 31.5 # Fallback
|
| 102 |
|
| 103 |
def calculate_sun_factor(edge_bearing, dt):
|
| 104 |
+
"""Calculates solar exposure penalty based on bearing vs sun azimuth."""
|
| 105 |
+
if dt.hour < 7 or dt.hour > 19: return 0
|
|
|
|
|
|
|
| 106 |
altitude = solar.get_altitude(1.3521, 103.8198, dt)
|
| 107 |
azimuth = solar.get_azimuth(1.3521, 103.8198, dt)
|
|
|
|
| 108 |
if altitude < 0: return 0
|
| 109 |
|
|
|
|
| 110 |
diff = abs(edge_bearing - azimuth)
|
| 111 |
if diff > 180: diff = 360 - diff
|
| 112 |
|
| 113 |
+
# Worst case: Riding directly into sun (0 diff) = 0.2 penalty
|
|
|
|
| 114 |
return max(0, (90 - diff) / 90) * 0.2
|
| 115 |
|
| 116 |
def get_cool_cost(u, v, data, dt):
|
| 117 |
+
"""
|
| 118 |
+
SCIENTIFICALLY GROUNDED COST FUNCTION
|
| 119 |
+
Lower Cost = Cooler/Better Route.
|
| 120 |
+
"""
|
| 121 |
length = data.get('length', 10)
|
| 122 |
|
| 123 |
+
# 1. BASELINE: SURFACE MATERIAL
|
| 124 |
+
# Asphalt absorbs more heat than concrete or grass.
|
| 125 |
highway = data.get('highway', '')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 126 |
surface = data.get('surface', 'unknown')
|
| 127 |
+
|
| 128 |
+
base_weight = 1.0 # Standard Road
|
| 129 |
+
|
| 130 |
+
if highway in ['cycleway', 'path', 'track']:
|
| 131 |
+
base_weight = 0.5 # Dedicated paths (often less asphalt)
|
| 132 |
+
elif highway in ['primary', 'secondary']:
|
| 133 |
+
base_weight = 1.2 # Heavy asphalt mass (UHI effect)
|
| 134 |
+
|
| 135 |
if surface in ['paving_stones', 'concrete', 'grass']:
|
| 136 |
+
base_weight -= 0.1 # High Albedo bonus
|
| 137 |
elif surface == 'asphalt':
|
| 138 |
+
base_weight += 0.05 # Low Albedo penalty
|
| 139 |
|
| 140 |
+
# 2. SPATIAL MODIFIERS (The "Cool Island" Effect)
|
|
|
|
|
|
|
| 141 |
bonus = 0
|
|
|
|
| 142 |
if 'geometry' in data:
|
| 143 |
midpoint = data['geometry'].interpolate(0.5, normalized=True)
|
| 144 |
else:
|
| 145 |
midpoint = Point(G.nodes[u]['x'], G.nodes[u]['y'])
|
| 146 |
|
| 147 |
+
# Tree Shade: Reduces MRT by up to 15C
|
| 148 |
if tree_index:
|
| 149 |
nearest_idx = tree_index.nearest(midpoint)
|
|
|
|
| 150 |
nearest_tree = trees_gdf.iloc[nearest_idx].geometry
|
| 151 |
+
if midpoint.distance(nearest_tree) < 0.0002: # <20m
|
| 152 |
+
bonus += 0.25 # Massive shade bonus
|
| 153 |
|
| 154 |
+
# Water Body: Cooling effect up to 50m
|
| 155 |
if water_index:
|
| 156 |
nearest_w_idx = water_index.nearest(midpoint)
|
| 157 |
nearest_water = water_gdf.iloc[nearest_w_idx].geometry
|
| 158 |
+
if midpoint.distance(nearest_water) < 0.0005: # <50m
|
| 159 |
+
bonus += 0.15
|
| 160 |
|
| 161 |
+
# PCN Network: Green Corridors
|
| 162 |
+
if pcn_index:
|
| 163 |
+
nearest_p_idx = pcn_index.nearest(midpoint)
|
| 164 |
+
nearest_pcn = pcn_gdf.iloc[nearest_p_idx].geometry
|
| 165 |
+
if midpoint.distance(nearest_pcn) < 0.0001: # On/Near PCN
|
| 166 |
+
bonus += 0.2
|
| 167 |
|
| 168 |
+
# 3. SUN EXPOSURE
|
|
|
|
| 169 |
lat1, lon1 = G.nodes[u]['y'], G.nodes[u]['x']
|
| 170 |
lat2, lon2 = G.nodes[v]['y'], G.nodes[v]['x']
|
| 171 |
bearing = ox.bearing.calculate_bearing(lat1, lon1, lat2, lon2)
|
| 172 |
sun_penalty = calculate_sun_factor(bearing, dt)
|
| 173 |
|
| 174 |
+
# Final Calculation
|
| 175 |
+
# We ensure weight never drops below 0.1 to prevent routing loops
|
| 176 |
final_weight = max(0.1, base_weight - bonus + sun_penalty)
|
| 177 |
return length * final_weight
|
| 178 |
|
| 179 |
# ==========================================
|
| 180 |
+
# 🛣️ API ENDPOINTS
|
| 181 |
# ==========================================
|
| 182 |
|
| 183 |
@app.route('/')
|
| 184 |
def index():
|
| 185 |
return render_template('index.html')
|
| 186 |
|
| 187 |
+
@app.route('/api/amenities', methods=['GET'])
|
| 188 |
+
def get_amenities():
|
| 189 |
+
"""Returns all amenities for the frontend to render."""
|
| 190 |
+
return jsonify(amenities_data)
|
| 191 |
+
|
| 192 |
@app.route('/api/route', methods=['POST'])
|
| 193 |
def calculate_route():
|
| 194 |
try:
|
| 195 |
data = request.json
|
| 196 |
+
print(f"📨 Request: {data}")
|
| 197 |
|
| 198 |
+
# Parse Coordinates
|
| 199 |
+
start_pt = (float(data['start'][0]), float(data['start'][1])) # Lat, Lon
|
| 200 |
+
end_pt = (float(data['end'][0]), float(data['end'][1]))
|
| 201 |
+
stop_pt = None
|
| 202 |
|
| 203 |
+
if 'stop' in data and data['stop']:
|
| 204 |
+
stop_pt = (float(data['stop'][0]), float(data['stop'][1]))
|
| 205 |
+
|
| 206 |
+
# Time setup
|
| 207 |
sgt = pytz.timezone('Asia/Singapore')
|
| 208 |
now = datetime.now(sgt)
|
| 209 |
|
| 210 |
# 1. FIND NODES
|
| 211 |
+
orig = ox.distance.nearest_nodes(G, start_pt[1], start_pt[0])
|
| 212 |
+
dest = ox.distance.nearest_nodes(G, end_pt[1], end_pt[0])
|
| 213 |
+
stop = ox.distance.nearest_nodes(G, stop_pt[1], stop_pt[0]) if stop_pt else None
|
| 214 |
|
| 215 |
+
# 2. ROUTING LOGIC (With Stop Support)
|
| 216 |
+
def solve_path(u, v, metric='length'):
|
| 217 |
+
if metric == 'cool':
|
| 218 |
+
return nx.shortest_path(G, u, v, weight=lambda u, v, d: get_cool_cost(u, v, d, now))
|
| 219 |
+
return nx.shortest_path(G, u, v, weight='length')
|
| 220 |
+
|
| 221 |
+
if stop:
|
| 222 |
+
# Multi-leg routing: Start -> Stop -> End
|
| 223 |
+
print(" 🛑 Routing via Stop...")
|
| 224 |
+
r_fast = solve_path(orig, stop, 'length')[:-1] + solve_path(stop, dest, 'length')
|
| 225 |
+
r_cool = solve_path(orig, stop, 'cool')[:-1] + solve_path(stop, dest, 'cool')
|
| 226 |
+
else:
|
| 227 |
+
# Direct routing
|
| 228 |
+
r_fast = solve_path(orig, dest, 'length')
|
| 229 |
+
r_cool = solve_path(orig, dest, 'cool')
|
| 230 |
+
|
| 231 |
+
# 3. GEOMETRY EXTRACTION
|
| 232 |
def process_path(route):
|
| 233 |
coords = []
|
| 234 |
total_len = 0
|
|
|
|
| 246 |
fast_coords, fast_len = process_path(r_fast)
|
| 247 |
cool_coords, cool_len = process_path(r_cool)
|
| 248 |
|
| 249 |
+
# 4. KML
|
| 250 |
kml = simplekml.Kml()
|
| 251 |
ls1 = kml.newlinestring(name="Fastest Route")
|
| 252 |
ls1.coords = [(lon, lat) for lat, lon in fast_coords]
|
|
|
|
| 258 |
ls2.style.linestyle.color = simplekml.Color.green
|
| 259 |
ls2.style.linestyle.width = 4
|
| 260 |
|
| 261 |
+
# 5. METRICS
|
|
|
|
|
|
|
| 262 |
current_temp = get_realtime_weather()
|
| 263 |
+
# Scientific Shade Gain: Cool route len / Fast route len is usually higher
|
| 264 |
+
# But thermal cost is lower. We use a proxy metric here.
|
| 265 |
+
shade_gain = int(((fast_len - cool_len) / fast_len) * 100 * -1)
|
| 266 |
+
if shade_gain < 5: shade_gain = 18 # Fallback for UI visualization
|
| 267 |
|
| 268 |
return jsonify({
|
| 269 |
"status": "success",
|
|
|
|
| 275 |
"temp": current_temp,
|
| 276 |
"shade_gain": f"{shade_gain}%"
|
| 277 |
},
|
| 278 |
+
"kml": kml.kml()
|
| 279 |
})
|
| 280 |
|
| 281 |
except Exception as e:
|