405 lines
15 KiB
Python
Executable file
405 lines
15 KiB
Python
Executable file
import json
|
|
import logging
|
|
import os
|
|
from collections import defaultdict
|
|
|
|
from subway_structure import (
|
|
DISPLACEMENT_TOLERANCE,
|
|
distance,
|
|
el_center,
|
|
Station,
|
|
)
|
|
from ._common import (
|
|
DEFAULT_INTERVAL,
|
|
format_colour,
|
|
KMPH_TO_MPS,
|
|
SPEED_ON_TRANSFER,
|
|
TRANSFER_PENALTY,
|
|
)
|
|
|
|
|
|
OSM_TYPES = {"n": (0, "node"), "w": (2, "way"), "r": (3, "relation")}
|
|
ENTRANCE_PENALTY = 60 # seconds
|
|
SPEED_TO_ENTRANCE = 5 * KMPH_TO_MPS # m/s
|
|
SPEED_ON_LINE = 40 * KMPH_TO_MPS # m/s
|
|
|
|
|
|
def uid(elid, typ=None):
|
|
t = elid[0]
|
|
osm_id = int(elid[1:])
|
|
if not typ:
|
|
osm_id = (osm_id << 2) + OSM_TYPES[t][0]
|
|
elif typ != t:
|
|
raise Exception("Got {}, expected {}".format(elid, typ))
|
|
return osm_id << 1
|
|
|
|
|
|
class DummyCache:
|
|
"""This class may be used when you need to omit all cache processing"""
|
|
|
|
def __init__(self, cache_path, cities):
|
|
pass
|
|
|
|
def __getattr__(self, name):
|
|
"""This results in that a call to any method effectively does nothing
|
|
and does not generate exceptions."""
|
|
|
|
def method(*args, **kwargs):
|
|
return None
|
|
|
|
return method
|
|
|
|
|
|
def if_object_is_used(method):
|
|
"""Decorator to skip method execution under certain condition.
|
|
Relies on "is_used" object property."""
|
|
|
|
def inner(self, *args, **kwargs):
|
|
if not self.is_used:
|
|
return
|
|
return method(self, *args, **kwargs)
|
|
|
|
return inner
|
|
|
|
|
|
class MapsmeCache:
|
|
def __init__(self, cache_path, cities):
|
|
if not cache_path:
|
|
# Cache is not used,
|
|
# all actions with cache must be silently skipped
|
|
self.is_used = False
|
|
return
|
|
self.cache_path = cache_path
|
|
self.is_used = True
|
|
self.cache = {}
|
|
if os.path.exists(cache_path):
|
|
try:
|
|
with open(cache_path, "r", encoding="utf-8") as f:
|
|
self.cache = json.load(f)
|
|
except json.decoder.JSONDecodeError:
|
|
logging.warning(
|
|
"City cache '%s' is not a valid json file. "
|
|
"Building cache from scratch.",
|
|
cache_path,
|
|
)
|
|
self.recovered_city_names = set()
|
|
# One stoparea may participate in routes of different cities
|
|
self.stop_cities = defaultdict(set) # stoparea id -> city names
|
|
self.city_dict = {c.name: c for c in cities}
|
|
self.good_city_names = {c.name for c in cities if c.is_good}
|
|
|
|
def _is_cached_city_usable(self, city):
|
|
"""Check if cached stations still exist in osm data and
|
|
not moved far away.
|
|
"""
|
|
city_cache_data = self.cache[city.name]
|
|
for stoparea_id, cached_stoparea in city_cache_data["stops"].items():
|
|
station_id = cached_stoparea["osm_type"][0] + str(
|
|
cached_stoparea["osm_id"]
|
|
)
|
|
city_station = city.elements.get(station_id)
|
|
if not city_station or not Station.is_station(
|
|
city_station, city.modes
|
|
):
|
|
return False
|
|
station_coords = el_center(city_station)
|
|
cached_station_coords = tuple(
|
|
cached_stoparea[coord] for coord in ("lon", "lat")
|
|
)
|
|
displacement = distance(station_coords, cached_station_coords)
|
|
if displacement > DISPLACEMENT_TOLERANCE:
|
|
return False
|
|
|
|
return True
|
|
|
|
@if_object_is_used
|
|
def provide_stops_and_networks(self, stops, networks):
|
|
"""Put stops and networks for bad cities into containers
|
|
passed as arguments."""
|
|
for city in self.city_dict.values():
|
|
if not city.is_good and city.name in self.cache:
|
|
city_cached_data = self.cache[city.name]
|
|
if self._is_cached_city_usable(city):
|
|
stops.update(city_cached_data["stops"])
|
|
networks.append(city_cached_data["network"])
|
|
logging.info("Taking %s from cache", city.name)
|
|
self.recovered_city_names.add(city.name)
|
|
|
|
@if_object_is_used
|
|
def provide_transfers(self, transfers):
|
|
"""Add transfers from usable cached cities to 'transfers' dict
|
|
passed as argument."""
|
|
for city_name in self.recovered_city_names:
|
|
city_cached_transfers = self.cache[city_name]["transfers"]
|
|
for stop1_uid, stop2_uid, transfer_time in city_cached_transfers:
|
|
if (stop1_uid, stop2_uid) not in transfers:
|
|
transfers[(stop1_uid, stop2_uid)] = transfer_time
|
|
|
|
@if_object_is_used
|
|
def initialize_good_city(self, city_name, network):
|
|
"""Create/replace one cache element with new data container.
|
|
This should be done for each good city."""
|
|
self.cache[city_name] = {
|
|
"network": network,
|
|
"stops": {}, # stoparea el_id -> jsonified stop data
|
|
"transfers": [], # list of tuples
|
|
# (stoparea1_uid, stoparea2_uid, time); uid1 < uid2
|
|
}
|
|
|
|
@if_object_is_used
|
|
def link_stop_with_city(self, stoparea_id, city_name):
|
|
"""Remember that some stop_area is used in a city."""
|
|
stoparea_uid = uid(stoparea_id)
|
|
self.stop_cities[stoparea_uid].add(city_name)
|
|
|
|
@if_object_is_used
|
|
def add_stop(self, stoparea_id, st):
|
|
"""Add stoparea to the cache of each city the stoparea is in."""
|
|
stoparea_uid = uid(stoparea_id)
|
|
for city_name in self.stop_cities[stoparea_uid]:
|
|
self.cache[city_name]["stops"][stoparea_id] = st
|
|
|
|
@if_object_is_used
|
|
def add_transfer(self, stoparea1_uid, stoparea2_uid, transfer_time):
|
|
"""If a transfer is inside a good city, add it to the city's cache."""
|
|
for city_name in (
|
|
self.good_city_names
|
|
& self.stop_cities[stoparea1_uid]
|
|
& self.stop_cities[stoparea2_uid]
|
|
):
|
|
self.cache[city_name]["transfers"].append(
|
|
(stoparea1_uid, stoparea2_uid, transfer_time)
|
|
)
|
|
|
|
@if_object_is_used
|
|
def save(self):
|
|
try:
|
|
with open(self.cache_path, "w", encoding="utf-8") as f:
|
|
json.dump(self.cache, f, ensure_ascii=False)
|
|
except Exception as e:
|
|
logging.warning("Failed to save cache: %s", str(e))
|
|
|
|
|
|
def process(cities, transfers, filename, cache_path):
|
|
"""Generate all output and save to file.
|
|
:param cities: List of City instances
|
|
:param transfers: List of sets of StopArea.id
|
|
:param filename: Path to file to save the result
|
|
:param cache_path: Path to json-file with good cities cache or None.
|
|
"""
|
|
|
|
def find_exits_for_platform(center, nodes):
|
|
exits = []
|
|
min_distance = None
|
|
for n in nodes:
|
|
d = distance(center, (n["lon"], n["lat"]))
|
|
if not min_distance:
|
|
min_distance = d * 2 / 3
|
|
elif d < min_distance:
|
|
continue
|
|
too_close = False
|
|
for e in exits:
|
|
d = distance((e["lon"], e["lat"]), (n["lon"], n["lat"]))
|
|
if d < min_distance:
|
|
too_close = True
|
|
break
|
|
if not too_close:
|
|
exits.append(n)
|
|
return exits
|
|
|
|
cache = MapsmeCache(cache_path, cities)
|
|
|
|
stop_areas = {} # stoparea el_id -> StopArea instance
|
|
stops = {} # stoparea el_id -> stop jsonified data
|
|
networks = []
|
|
good_cities = [c for c in cities if c.is_good]
|
|
platform_nodes = {}
|
|
cache.provide_stops_and_networks(stops, networks)
|
|
|
|
for city in good_cities:
|
|
network = {"network": city.name, "routes": [], "agency_id": city.id}
|
|
cache.initialize_good_city(city.name, network)
|
|
for route in city:
|
|
routes = {
|
|
"type": route.mode,
|
|
"ref": route.ref,
|
|
"name": route.name,
|
|
"colour": format_colour(route.colour),
|
|
"route_id": uid(route.id, "r"),
|
|
"itineraries": [],
|
|
}
|
|
if route.infill:
|
|
routes["casing"] = routes["colour"]
|
|
routes["colour"] = format_colour(route.infill)
|
|
for i, variant in enumerate(route):
|
|
itin = []
|
|
for stop in variant:
|
|
stop_areas[stop.stoparea.id] = stop.stoparea
|
|
cache.link_stop_with_city(stop.stoparea.id, city.name)
|
|
itin.append(
|
|
[
|
|
uid(stop.stoparea.id),
|
|
round(stop.distance / SPEED_ON_LINE),
|
|
]
|
|
)
|
|
# Make exits from platform nodes,
|
|
# if we don't have proper exits
|
|
if (
|
|
len(stop.stoparea.entrances) + len(stop.stoparea.exits)
|
|
== 0
|
|
):
|
|
for pl in stop.stoparea.platforms:
|
|
pl_el = city.elements[pl]
|
|
if pl_el["type"] == "node":
|
|
pl_nodes = [pl_el]
|
|
elif pl_el["type"] == "way":
|
|
pl_nodes = [
|
|
city.elements.get("n{}".format(n))
|
|
for n in pl_el["nodes"]
|
|
]
|
|
else:
|
|
pl_nodes = []
|
|
for m in pl_el["members"]:
|
|
if m["type"] == "way":
|
|
if (
|
|
"{}{}".format(
|
|
m["type"][0], m["ref"]
|
|
)
|
|
in city.elements
|
|
):
|
|
pl_nodes.extend(
|
|
[
|
|
city.elements.get(
|
|
"n{}".format(n)
|
|
)
|
|
for n in city.elements[
|
|
"{}{}".format(
|
|
m["type"][0],
|
|
m["ref"],
|
|
)
|
|
]["nodes"]
|
|
]
|
|
)
|
|
pl_nodes = [n for n in pl_nodes if n]
|
|
platform_nodes[pl] = find_exits_for_platform(
|
|
stop.stoparea.centers[pl], pl_nodes
|
|
)
|
|
|
|
routes["itineraries"].append(
|
|
{
|
|
"stops": itin,
|
|
"interval": round(
|
|
variant.interval or DEFAULT_INTERVAL
|
|
),
|
|
}
|
|
)
|
|
network["routes"].append(routes)
|
|
networks.append(network)
|
|
|
|
for stop_id, stop in stop_areas.items():
|
|
st = {
|
|
"name": stop.name,
|
|
"int_name": stop.int_name,
|
|
"lat": stop.center[1],
|
|
"lon": stop.center[0],
|
|
"osm_type": OSM_TYPES[stop.station.id[0]][1],
|
|
"osm_id": int(stop.station.id[1:]),
|
|
"id": uid(stop.id),
|
|
"entrances": [],
|
|
"exits": [],
|
|
}
|
|
for e_l, k in ((stop.entrances, "entrances"), (stop.exits, "exits")):
|
|
for e in e_l:
|
|
if e[0] == "n":
|
|
st[k].append(
|
|
{
|
|
"osm_type": "node",
|
|
"osm_id": int(e[1:]),
|
|
"lon": stop.centers[e][0],
|
|
"lat": stop.centers[e][1],
|
|
"distance": ENTRANCE_PENALTY
|
|
+ round(
|
|
distance(stop.centers[e], stop.center)
|
|
/ SPEED_TO_ENTRANCE
|
|
),
|
|
}
|
|
)
|
|
if len(stop.entrances) + len(stop.exits) == 0:
|
|
if stop.platforms:
|
|
for pl in stop.platforms:
|
|
for n in platform_nodes[pl]:
|
|
for k in ("entrances", "exits"):
|
|
st[k].append(
|
|
{
|
|
"osm_type": n["type"],
|
|
"osm_id": n["id"],
|
|
"lon": n["lon"],
|
|
"lat": n["lat"],
|
|
"distance": ENTRANCE_PENALTY
|
|
+ round(
|
|
distance(
|
|
(n["lon"], n["lat"]), stop.center
|
|
)
|
|
/ SPEED_TO_ENTRANCE
|
|
),
|
|
}
|
|
)
|
|
else:
|
|
for k in ("entrances", "exits"):
|
|
st[k].append(
|
|
{
|
|
"osm_type": OSM_TYPES[stop.station.id[0]][1],
|
|
"osm_id": int(stop.station.id[1:]),
|
|
"lon": stop.centers[stop.id][0],
|
|
"lat": stop.centers[stop.id][1],
|
|
"distance": 60,
|
|
}
|
|
)
|
|
|
|
stops[stop_id] = st
|
|
cache.add_stop(stop_id, st)
|
|
|
|
pairwise_transfers = (
|
|
{}
|
|
) # (stoparea1_uid, stoparea2_uid) -> time; uid1 < uid2
|
|
for t_set in transfers:
|
|
t = list(t_set)
|
|
for t_first in range(len(t) - 1):
|
|
for t_second in range(t_first + 1, len(t)):
|
|
stoparea1 = t[t_first]
|
|
stoparea2 = t[t_second]
|
|
if stoparea1.id in stops and stoparea2.id in stops:
|
|
uid1 = uid(stoparea1.id)
|
|
uid2 = uid(stoparea2.id)
|
|
uid1, uid2 = sorted([uid1, uid2])
|
|
transfer_time = TRANSFER_PENALTY + round(
|
|
distance(stoparea1.center, stoparea2.center)
|
|
/ SPEED_ON_TRANSFER
|
|
)
|
|
pairwise_transfers[(uid1, uid2)] = transfer_time
|
|
cache.add_transfer(uid1, uid2, transfer_time)
|
|
|
|
cache.provide_transfers(pairwise_transfers)
|
|
cache.save()
|
|
|
|
pairwise_transfers = [
|
|
(stop1_uid, stop2_uid, transfer_time)
|
|
for (stop1_uid, stop2_uid), transfer_time in pairwise_transfers.items()
|
|
]
|
|
|
|
result = {
|
|
"stops": list(stops.values()),
|
|
"transfers": pairwise_transfers,
|
|
"networks": networks,
|
|
}
|
|
|
|
if not filename.lower().endswith("json"):
|
|
filename = f"{filename}.json"
|
|
|
|
with open(filename, "w", encoding="utf-8") as f:
|
|
json.dump(
|
|
result,
|
|
f,
|
|
indent=1,
|
|
ensure_ascii=False,
|
|
)
|