ULP-ActivitySupport – commitdiff
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 49bcdb4)
raw | patch | inline | side by side (parent: 49bcdb4)
| author | Julian Fietkau <git@fietkau.software> | |
| Fri, 6 Jan 2023 18:22:55 +0000 (19:22 +0100) | ||
| committer | Julian Fietkau <git@fietkau.software> | |
| Fri, 6 Jan 2023 18:22:55 +0000 (19:22 +0100) |
| batch-simulation/README.md | [new file with mode: 0644] | patch | blob |
| batch-simulation/analysis.py | [new file with mode: 0755] | patch | blob |
| batch-simulation/data.py | [new file with mode: 0755] | patch | blob |
| batch-simulation/osm_pbf_import.py | [new file with mode: 0755] | patch | blob |
| batch-simulation/routing.py | [new file with mode: 0755] | patch | blob |
| batch-simulation/run.py | [new file with mode: 0755] | patch | blob |
| batch-simulation/scooter-park.json | [new file with mode: 0644] | patch | blob |
| batch-simulation/simulator.py | [new file with mode: 0755] | patch | blob |
| batch-simulation/visualizer.py | [new file with mode: 0755] | patch | blob |
diff --git a/batch-simulation/README.md b/batch-simulation/README.md
--- /dev/null
@@ -0,0 +1,59 @@
+# UrbanLife+ Activity Support: Batch Simulation
+
+This collection of scripts performs a batch simulation of pedestrians finding
+their goals in a street network. You can export a network from an OpenStreetMap
+PBF file and then run simulations in them.
+
+To reproduce the simulations from my doctoral thesis, start with a copy of
+Geofabrik's OSM PBF download for the area of Düsseldorf:
+
+<https://download.geofabrik.de/europe/germany/nordrhein-westfalen/duesseldorf-regbez.html>
+
+You'd need to acquire the timestamped data I pulled on February 2nd, 2021, to get an
+exact match for the street networks, but more recent copies should work too and would
+be expected to produce similar results.
+
+ duesseldorf-regbez-2021-02-02.osm.pbf
+ SHA-1: 24bfcad2b8a9ce343f37566c121e3c22b0f500e8
+
+Create the street network files centered around the Altenheim Hardterbroich like this:
+
+ osm_pbf_import.py duesseldorf.osm.pbf 51.1851 6.4532 100 gladbach-01km.json
+ osm_pbf_import.py duesseldorf.osm.pbf 51.1851 6.4532 250 gladbach-025km.json
+ osm_pbf_import.py duesseldorf.osm.pbf 51.1851 6.4532 500 gladbach-05km.json
+ osm_pbf_import.py duesseldorf.osm.pbf 51.1851 6.4532 1000 gladbach-1km.json
+ osm_pbf_import.py duesseldorf.osm.pbf 51.1851 6.4532 2000 gladbach-2km.json
+
+The Scooter-Park network used in the thesis simulations is included with the software.
+
+You can optionally generate the network visualizations like this to check for plausibility:
+
+ visualizer.py gladbach-01km.json gladbach-01km.png gladbach-01km.svg
+ visualizer.py gladbach-025km.json gladbach-025km.png gladbach-025km.svg
+ visualizer.py gladbach-05km.json gladbach-05km.png gladbach-05km.svg
+ visualizer.py gladbach-1km.json gladbach-1km.png gladbach-1km.svg
+ visualizer.py gladbach-2km.json gladbach-2km.png gladbach-2km.svg
+ visualizer.py scooter-park.json scooter-park.png scooter-park.svg
+
+The simulations corresponding to the results tables from my thesis can be run as follows:
+
+ run.py gladbach-01km.json 100000 1 gladbach-01km.csv gladbach-01km.dat
+ run.py gladbach-025km.json 100000 1 gladbach-025km.csv gladbach-025km.dat
+ run.py gladbach-05km.json 1000 1 gladbach-05km.csv gladbach-05km.dat
+ run.py gladbach-1km.json 1000 1 gladbach-1km.csv gladbach-1km.dat
+ run.py gladbach-2km.json 50 1 gladbach-2km.csv gladbach-2km.dat
+ run.py scooter-park.json 100000 1 scooter-park.csv scooter-park.dat
+
+Do keep in mind that the number of iterations given above is per density, so the total
+number of runs is that multiplied by 11.
+
+For your convenience, a script is included that generates a results table of discrete
+diversion factor categories that can be used like this:
+
+ analysis.py gladbach-01km.csv
+ analysis.py gladbach-025km.csv
+ analysis.py gladbach-05km.csv
+ analysis.py gladbach-1km.csv
+ analysis.py gladbach-2km.csv
+ analysis.py scooter-park.csv
+
diff --git a/batch-simulation/analysis.py b/batch-simulation/analysis.py
--- /dev/null
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+
+import copy
+import csv
+import json
+import math
+import os
+import random
+import sys
+
+
+def analyze_network(network):
+ print('Knoten:', len(network['nodes']))
+ kreuzungen = 0
+ for n in network['nodes']:
+ nachbarn = 0
+ for e in network['edges']:
+ if n in network['edges'][e]['nodes']:
+ nachbarn += 1
+ if nachbarn > 2:
+ break
+ if nachbarn > 2:
+ kreuzungen += 1
+ print('davon Kreuzungen:', kreuzungen)
+ print('Kanten:', len(network['edges']))
+
+def print_tabbed(*args):
+ print('\t'.join([str(v) for v in args]))
+
+def analyze_simulation(reader):
+ num = 0
+ results = {}
+ for density in [str(i/10) for i in range(0, 11)]:
+ results[density] = {}
+ for factor in [str(i) for i in range(1, 11)]:
+ results[density][factor] = 0
+ results[density]['>10'] = 0
+ for row in reader:
+ factor = math.ceil(float(row[5]))
+ if factor > 10:
+ factor = '>10'
+ else:
+ factor = str(factor)
+ results[row[0]][factor] += 1
+ factors = [str(i) for i in range(1, 11)] + ['>10']
+ if '--latex' in sys.argv:
+ for density in sorted(results.keys()):
+ line = ' & \\textbf{' + str(density) + '}'
+ for factor in factors:
+ line += ' & ' + str(results[density][factor])
+ line += ' \\\\'
+ print(line)
+ print(' \cline{2-13}')
+ else:
+ print_tabbed('', *factors)
+ for density in sorted(results.keys()):
+ print_tabbed(density, *[results[density][k] for k in factors])
+
+if __name__ == '__main__':
+ if len(sys.argv) < 2:
+ print('Usage: analysis.py $input_file')
+ sys.exit(1)
+ if sys.argv[1].endswith('.json'):
+ with open(sys.argv[1], 'r') as fp:
+ network = json.load(fp)
+ analyze_network(network)
+ elif sys.argv[1].endswith('.csv'):
+ with open(sys.argv[1], 'r') as fp:
+ reader = csv.reader(fp)
+ analyze_simulation(reader)
+
diff --git a/batch-simulation/data.py b/batch-simulation/data.py
--- /dev/null
+++ b/batch-simulation/data.py
@@ -0,0 +1,241 @@
+#!/usr/bin/env python3\r
+\r
+import json\r
+import math\r
+\r
+\r
+class Position:\r
+ def __init__(self, *, lat=None, lon=None, x=None, y=None):\r
+ if lat is not None and lon is not None:\r
+ self.lat = lat\r
+ self.lon = lon\r
+ if x is not None and y is not None:\r
+ self.x = x\r
+ self.y = y\r
+\r
+ def __str__(self):\r
+ if hasattr(self, 'lat'):\r
+ return "(%f, %f)" % (self.lat, self.lon)\r
+ if hasattr(self, 'x'):\r
+ return "(%f, %f)" % (self.x, self.y)\r
+ return "(None)"\r
+\r
+ def difference_to(self, goal):\r
+ if hasattr(self, 'lat'):\r
+ return (goal.lat - self.lat, goal.lon - self.lon)\r
+ if hasattr(self, 'x'):\r
+ return (goal.x - self.x, goal.y - self.y)\r
+ return None\r
+\r
+ def distance(self, goal):\r
+ rel = self.difference_to(goal)\r
+ return math.sqrt(rel[0] ** 2 + rel[1] ** 2)\r
+\r
+ def move_by(self, vector):\r
+ if hasattr(self, 'lat'):\r
+ self.lat += vector[0]\r
+ self.lon += vector[1]\r
+ if hasattr(self, 'x'):\r
+ self.x += vector[0]\r
+ self.y += vector[1]\r
+\r
+ def toJSON(self):\r
+ if hasattr(self, 'lat'):\r
+ return {\r
+ 'lat': self.lat,\r
+ 'lon': self.lon,\r
+ }\r
+ if hasattr(self, 'x'):\r
+ return {\r
+ 'x': self.x,\r
+ 'y': self.y,\r
+ }\r
+ return {}\r
+\r
+\r
+class QuestRequirement:\r
+ def __init__(self, req_type):\r
+ self.type = req_type\r
+ if self.type == 'set' or self.type == 'list':\r
+ self.parts = []\r
+ self.minimum = None\r
+ self.ordered = self.type == 'list'\r
+ if self.type == 'position':\r
+ self.position = None\r
+ if self.type == 'suo_proximity':\r
+ self.suo = None\r
+ self.fulfilled = False\r
+\r
+ def get_active_requirements(self):\r
+ if self.fulfilled:\r
+ return None\r
+ active_requirements = []\r
+ if self.type not in ['set', 'list']:\r
+ active_requirements.append(self)\r
+ else:\r
+ for part in self.parts:\r
+ if part.is_fulfilled():\r
+ continue\r
+ else:\r
+ active_requirements.extend(part.get_active_requirements())\r
+ if self.ordered:\r
+ break\r
+ return active_requirements\r
+\r
+ def is_fulfilled(self):\r
+ if self.fulfilled:\r
+ return True\r
+ if self.type in ['set', 'list']:\r
+ fulfilled_parts = 0\r
+ for part in self.parts:\r
+ if part.is_fulfilled():\r
+ fulfilled_parts += 1\r
+ minimum = self.minimum\r
+ if minimum is None:\r
+ minimum = len(self.parts)\r
+ if fulfilled_parts >= minimum:\r
+ self.fulfilled = True\r
+ return True\r
+ return False\r
+\r
+ def from_json(self, req_json):\r
+ data = json.loads(req_json)\r
+ for key in data:\r
+ if key == 'parts':\r
+ self.parts = []\r
+ for part in data['parts']:\r
+ part_json = json.dumps(part)\r
+ new_req = QuestRequirement(part['type'])\r
+ new_req.from_json(part_json)\r
+ self.parts.append(new_req)\r
+ else:\r
+ setattr(self, key, data[key])\r
+\r
+\r
+class Quest:\r
+ def __init__(self, qid = None):\r
+ self.qid = qid\r
+ self.title = None\r
+ self.requirement = None\r
+ self.rewards = None\r
+ self.user = None\r
+\r
+\r
+class Intent:\r
+ def __init__(self, intent_id, position):\r
+ self.id = intent_id\r
+ self.position = position\r
+\r
+ def toJSON(self):\r
+ return {\r
+ 'id': self.id,\r
+ 'position': self.position,\r
+ }\r
+\r
+\r
+class User:\r
+ def __init__(self, user_id, name):\r
+ self.id = user_id\r
+ self.name = name\r
+ self.position = None\r
+ self.rotation = 0\r
+ self.color_preference = None\r
+ self.is_virtual = False\r
+ self.intent = {}\r
+ self.mobility = None\r
+\r
+ def __str__(self):\r
+ return str(self.name) + ": " + str(self.position)\r
+\r
+ def __repr__(self):\r
+ return "<" + self.__str__() + ">"\r
+\r
+ def toJSON(self):\r
+ return {\r
+ 'id': self.id,\r
+ 'name': self.name,\r
+ 'position': self.position,\r
+ 'rotation': self.rotation,\r
+ 'intent': self.intent,\r
+ 'color_preference': self.color_preference,\r
+ 'mobility': self.mobility,\r
+ 'is_virtual': self.is_virtual,\r
+ }\r
+\r
+ def set_position(self, position):\r
+ self.position = position\r
+\r
+ def set_rotation(self, rotation):\r
+ self.rotation = rotation\r
+\r
+ def add_intent(self, intent):\r
+ self.intent[intent.id] = intent\r
+\r
+\r
+class SmartUrbanObject:\r
+ def __init__(self, suo_id, suo_type = None):\r
+ self.id = suo_id\r
+ self.suo_type = suo_type\r
+ self.position = None\r
+ self.rotation = 0\r
+ self.is_virtual = False\r
+ self.proximity_users = []\r
+\r
+ def __str__(self):\r
+ return str(self.id) + ": " + str(self.suo_type) + ", " + str(self.position)\r
+\r
+ def __repr__(self):\r
+ return "<" + self.__str__() + ">"\r
+\r
+ def toJSON(self):\r
+ return {\r
+ 'id': self.id,\r
+ 'position': self.position,\r
+ 'rotation': self.rotation,\r
+ 'suo_type': self.suo_type,\r
+ 'range': self.get_range(),\r
+ 'is_virtual': self.is_virtual,\r
+ }\r
+\r
+ def set_position(self, position):\r
+ self.position = position\r
+\r
+ def set_rotation(self, rotation):\r
+ self.rotation = rotation\r
+\r
+ def get_range(self):\r
+ return 4\r
+\r
+ def is_user_in_range(self, user):\r
+ return user.position.distance(self.position) <= self.get_range()\r
+\r
+\r
+class Context:\r
+ def __init__(self, context_id, name = None):\r
+ self.id = context_id\r
+ self.name = name\r
+ self.user = {}\r
+ self.suo = {}\r
+ self.boundaries = {}\r
+\r
+ def toJSON(self):\r
+ result = {\r
+ 'id': self.id,\r
+ 'name': self.name,\r
+ 'user': self.user,\r
+ 'suo': self.suo,\r
+ }\r
+ if 'width' in self.boundaries and 'height' in self.boundaries:\r
+ result['boundaries'] = self.boundaries\r
+ return result;\r
+\r
+ def add_user(self, user):\r
+ self.user[user.id] = user\r
+\r
+ def add_suo(self, suo):\r
+ self.suo[suo.id] = suo\r
+\r
+ def set_boundaries(self, width, height):\r
+ self.boundaries['width'] = width\r
+ self.boundaries['height'] = height\r
+\r
diff --git a/batch-simulation/osm_pbf_import.py b/batch-simulation/osm_pbf_import.py
--- /dev/null
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+
+import esy.osm.pbf
+import json
+import math
+import os
+import sys
+
+
+def transpose_diagonally(coords, distance):
+ delta_lat = 1
+ dist = 0
+ while abs(distance - dist) > 1:
+ iter_coords = (coords[0] + delta_lat, coords[1])
+ dist = get_distance(coords, iter_coords)
+ delta_lat = delta_lat * distance / dist
+ delta_lon = 1
+ dist = 0
+ while abs(distance - dist) > 1:
+ iter_coords = (coords[0], coords[1] + delta_lon)
+ dist = get_distance(coords, iter_coords)
+ delta_lon = delta_lon * distance / dist
+ return ((coords[0] - delta_lat, coords[1] - delta_lon), (coords[0] + delta_lat, coords[1] + delta_lon))
+
+def get_distance(coords1, coords2):
+ lon1 = math.radians(coords1[1])
+ lon2 = math.radians(coords2[1])
+ lat1 = math.radians(coords1[0])
+ lat2 = math.radians(coords2[0])
+
+ # Haversine formula
+ dlon = lon2 - lon1
+ dlat = lat2 - lat1
+ a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+ c = 2 * math.asin(math.sqrt(a))
+ r = 6371.01
+ return c * r * 1000
+
+def is_in_radius(node, point, radius):
+ return get_distance((node.lonlat[1], node.lonlat[0]), point) <= radius
+
+
+if __name__ == '__main__':
+ if len(sys.argv) < 6:
+ print('Usage: osm_pbf_import.py $input_osm_pbf $center_lat $center_lon $radius $output_json')
+ sys.exit(1)
+
+ osm_file = sys.argv[1]
+ if not os.path.isfile(osm_file):
+ print('OSM file not found.')
+ sys.exit(1)
+
+ osm = esy.osm.pbf.File(osm_file)
+
+ origin_lat = float(sys.argv[2])
+ origin_lon = float(sys.argv[3])
+ radius = int(sys.argv[4])
+ output_path = sys.argv[5]
+
+ boundaries = transpose_diagonally((origin_lat, origin_lon), radius)
+ print(boundaries)
+
+ nodes = {}
+ ways = {}
+
+ print('Filtering nodes...')
+ num_nodes = 0
+ for entry in osm:
+ if hasattr(entry, 'lonlat') and is_in_radius(entry, (origin_lat, origin_lon), radius):
+ nodes[str(entry.id)] = entry
+ num_nodes += 1
+ if num_nodes % 100000 == 0:
+ print(' ' + str(num_nodes) + ' ...')
+ print('Filtered', len(nodes), 'nodes.')
+
+ print('Filtering ways...')
+ edges = []
+ for entry in osm:
+ if hasattr(entry, 'refs'):
+ if 'highway' not in entry.tags:
+ continue
+ for i in range(len(entry.refs) - 1):
+ if str(entry.refs[i]) in nodes and str(entry.refs[i+1]) in nodes:
+ edges.append({ 'nodes': [str(entry.refs[i]), str(entry.refs[i+1])] })
+ print('Found', len(edges), 'edges.')
+
+ print('Calculating neighbors...')
+ neighbors = {}
+ for edge in edges:
+ for index in range(2):
+ one_node = edge['nodes'][index]
+ other_node = edge['nodes'][1-index]
+ if one_node not in neighbors:
+ neighbors[one_node] = []
+ neighbors[one_node].append(other_node)
+
+ print('Finding graph components...')
+ components = []
+ unchecked_nodes = list(nodes.keys())
+ while len(unchecked_nodes) > 0:
+ component = []
+ surface = [unchecked_nodes[0]]
+ del unchecked_nodes[0]
+ while len(surface) > 0:
+ current_node = surface[0]
+ del surface[0]
+ if current_node in neighbors:
+ for neighbor in neighbors[current_node]:
+ if neighbor in unchecked_nodes:
+ surface.append(neighbor)
+ unchecked_nodes.remove(neighbor)
+ component.append(current_node)
+ components.append(component)
+ print('Found', len(components), 'components')
+
+ print('Reducing components...')
+ main_component = max(components, key=len)
+ for node_id in list(nodes.keys()):
+ if node_id not in main_component:
+ del nodes[node_id]
+ for edge in list(edges):
+ if edge['nodes'][0] not in nodes or edge['nodes'][1] not in nodes:
+ edges.remove(edge)
+ print('Down to', len(nodes), 'nodes and', len(edges), 'edges.')
+
+ print('Saving result...')
+ result = {
+ 'boundaries': {
+ 'width': 2*radius,
+ 'height': 2*radius
+ },
+ 'edges': { str(i) : edges[i] for i in range(0, len(edges)) },
+ 'nodes': {}
+ }
+
+ for node_id in nodes:
+ node = nodes[node_id]
+ result['nodes'][str(node.id)] = {
+ 'x': '{:.2f}'.format((node.lonlat[1] - boundaries[0][0]) / (boundaries[1][0] - boundaries[0][0]) * result['boundaries']['width']),
+ 'y': '{:.2f}'.format((node.lonlat[0] - boundaries[0][1]) / (boundaries[1][1] - boundaries[0][1]) * result['boundaries']['height'])
+ }
+
+ with open(output_path, 'w') as fp:
+ json.dump(result, fp)
+
diff --git a/batch-simulation/routing.py b/batch-simulation/routing.py
--- /dev/null
@@ -0,0 +1,120 @@
+#!/usr/bin/env python3\r
+\r
+import copy\r
+import json\r
+import math\r
+import random\r
+\r
+from data import Position\r
+\r
+\r
+class RoutingEngine:\r
+ def __init__(self, context, network):\r
+ self.context = context\r
+ self.network = network\r
+ for edge_id in self.network['edges']:\r
+ nodeA = self.network['edges'][edge_id]['nodes'][0]\r
+ nodeB = self.network['edges'][edge_id]['nodes'][1]\r
+ distance = self.get_node_distance(nodeA, nodeB)\r
+ self.network['edges'][edge_id]['length'] = distance\r
+ self.hops = self.calculate_hops(self.network)\r
+\r
+ def calculate_hops(self, network):\r
+ result = {}\r
+ for source_node in network['nodes']:\r
+ result[source_node] = {}\r
+ for edge_id in network['edges']:\r
+ edge = network['edges'][edge_id]\r
+ target_node = None\r
+ if edge['nodes'][0] == source_node:\r
+ target_node = edge['nodes'][1]\r
+ if edge['nodes'][1] == source_node:\r
+ target_node = edge['nodes'][0]\r
+ if target_node is not None:\r
+ result[source_node][target_node] = edge['length']\r
+ if len(result[source_node].keys()) > 2:\r
+ self.network['nodes'][source_node]['is_crossroad'] = True\r
+ else:\r
+ self.network['nodes'][source_node]['is_crossroad'] = False\r
+ return result\r
+\r
+ def shuffle_mirs(self, density):\r
+ crossing_nodes = [node for node in self.network['nodes'] if self.network['nodes'][node]['is_crossroad']]\r
+ targets = random.sample(crossing_nodes, round(density * len(crossing_nodes)))\r
+ for node in self.network['nodes']:\r
+ self.network['nodes'][node]['has_mir'] = node in targets\r
+\r
+ def is_confusing(self, node):\r
+ return self.network['nodes'][node]['is_crossroad'] and not self.network['nodes'][node]['has_mir']\r
+\r
+ def get_network(self):\r
+ return self.network\r
+\r
+ def get_connected_nodes(self, node):\r
+ return list(self.hops[node].keys())\r
+\r
+ def get_node_distance(self, nodeA, nodeB):\r
+ coordsA = self.network['nodes'][nodeA]\r
+ coordsB = self.network['nodes'][nodeB]\r
+ return math.sqrt((float(coordsB['x']) - float(coordsA['x'])) ** 2 + (float(coordsB['y']) - float(coordsA['y'])) ** 2)\r
+\r
+ def get_route_distance(self, nodeA, nodeB):\r
+ route = self.route_between_nodes(nodeA, nodeB)\r
+ distance = 0\r
+ while len(route) >= 2:\r
+ distance += self.get_node_distance(route[0], route[1])\r
+ del route[0]\r
+ return distance\r
+\r
+ def get_angle(self, x1, y1, x2, y2):\r
+ dotProduct = x1 * x2 + y1 * y2\r
+ lengthProduct = math.sqrt(x1 * x1 + y1 * y1) * math.sqrt(x2 * x2 + y2 * y2)\r
+ cos = dotProduct / lengthProduct\r
+ return math.acos(cos)\r
+\r
+ def get_next_straight_node(self, previous, current, candidates):\r
+ coordsPrev = self.network['nodes'][previous]\r
+ coordsCur = self.network['nodes'][current]\r
+ direction = [float(coordsCur['x']) - float(coordsPrev['x']), float(coordsCur['y']) - float(coordsPrev['y'])]\r
+ chosen = None\r
+ bestAngle = None\r
+ for candidate in candidates:\r
+ coordsCand = self.network['nodes'][candidate]\r
+ candDir = [float(coordsCand['x']) - float(coordsCur['x']), float(coordsCand['y']) - float(coordsCur['y'])]\r
+ angle = self.get_angle(candDir[0], candDir[1], direction[0], direction[1])\r
+ if bestAngle is None or angle < bestAngle:\r
+ chosen = candidate\r
+ bestAngle = angle\r
+ return chosen\r
+\r
+ def route_between_nodes(self, nodeA, nodeB):\r
+ unvisited = {node: float('inf') for node in self.hops}\r
+ visited = {}\r
+ previous = {}\r
+ current = nodeA\r
+ currentDistance = 0\r
+ unvisited[current] = currentDistance\r
+\r
+ while True:\r
+ for neighbour, distance in self.hops[current].items():\r
+ if neighbour not in unvisited:\r
+ continue\r
+ newDistance = currentDistance + distance\r
+ if unvisited[neighbour] is None or unvisited[neighbour] > newDistance:\r
+ unvisited[neighbour] = newDistance\r
+ previous[neighbour] = current\r
+ visited[current] = currentDistance\r
+ del unvisited[current]\r
+ if current == nodeB or not unvisited:\r
+ break\r
+ candidates = [node for node in unvisited.items() if node[1]]\r
+ current, currentDistance = sorted(candidates, key = lambda x: x[1])[0]\r
+\r
+ result = []\r
+ node = nodeB\r
+ while node != nodeA:\r
+ result.insert(0, node)\r
+ node = previous[node]\r
+ result.insert(0, node)\r
+ return result\r
+\r
diff --git a/batch-simulation/run.py b/batch-simulation/run.py
--- /dev/null
+++ b/batch-simulation/run.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+import copy
+import json
+import os
+import pickle
+import random
+import requests
+import sys
+
+from data import Position, Intent, SmartUrbanObject, Context
+from routing import RoutingEngine
+from simulator import ContextSimulator
+
+
+data = {
+ 'context': {},
+ 'routing': {}
+}
+
+def setup_world(network):
+ world = Context('demo', 'Scooter-Park')
+ world.set_boundaries(network['boundaries']['width'], network['boundaries']['height'])
+ routing_engine = RoutingEngine(world, network)
+ data['context']['demo'] = world
+ data['routing']['demo'] = routing_engine
+
+
+
+if __name__ == '__main__':
+ if len(sys.argv) < 6:
+ print('Usage: run.py $input_json $num_users $num_repetitions $output_csv $output_dat')
+ sys.exit(1)
+ with open(sys.argv[1], 'r') as fp:
+ network = json.load(fp)
+ setup_world(network)
+ simulator = ContextSimulator(data['context']['demo'], data['routing']['demo'], sys.argv[4])
+ repetitions = int(sys.argv[2])
+ num_users = int(sys.argv[3])
+ result = simulator.run(repetitions, num_users)
+ with open(sys.argv[5], 'wb') as fp:
+ pickle.dump({ 'simulation': result, 'network': data['routing']['demo'].get_network() }, fp)
+
diff --git a/batch-simulation/scooter-park.json b/batch-simulation/scooter-park.json
--- /dev/null
@@ -0,0 +1 @@
+{"boundaries": {"height": 54.135, "width": 54.135, "pre-rotated": true}, "edges": {"0": {"nodes": ["1", "0"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "1": {"nodes": ["0", "44"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "2": {"nodes": ["44", "43"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "3": {"nodes": ["43", "42"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "4": {"nodes": ["42", "41"], "passable": ["foot", "walker"]}, "6": {"nodes": ["41", "40"], "passable": ["foot", "walker"]}, "8": {"nodes": ["40", "39"], "passable": ["foot", "walker"]}, "9": {"nodes": ["39", "38"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "11": {"nodes": ["38", "37"], "passable": ["foot"]}, "12": {"nodes": ["37", "36"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "13": {"nodes": ["36", "33"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "14": {"nodes": ["37", "33"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "15": {"nodes": ["33", "32"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "16": {"nodes": ["32", "31"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "17": {"nodes": ["31", "30"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "18": {"nodes": ["30", "29"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "19": {"nodes": ["29", "28"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "20": {"nodes": ["28", "14"], "passable": ["foot", "walker"]}, "21": {"nodes": ["14", "13"], "passable": ["foot", "walker"]}, "22": {"nodes": ["13", "12"], "passable": ["foot", "walker"]}, "23": {"nodes": ["12", "11"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "24": {"nodes": ["11", "10"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "25": {"nodes": ["10", "9"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "26": {"nodes": ["9", "9"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "28": {"nodes": ["9", "7"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "30": {"nodes": ["7", "6"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "31": {"nodes": ["6", "8"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "32": {"nodes": ["8", "4"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "33": {"nodes": ["5", "8"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "34": {"nodes": ["5", "4"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "35": {"nodes": ["4", "3"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "36": {"nodes": ["3", "2"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "37": {"nodes": ["2", "1"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "38": {"nodes": ["45", "42"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "39": {"nodes": ["45", "46"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "40": {"nodes": ["5", "46"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "41": {"nodes": ["46", "48"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "42": {"nodes": ["48", "49"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "43": {"nodes": ["49", "50"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "44": {"nodes": ["50", "47"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "45": {"nodes": ["47", "45"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "46": {"nodes": ["50", "17"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "47": {"nodes": ["17", "18"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "48": {"nodes": ["17", "45"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "49": {"nodes": ["45", "50"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "50": {"nodes": ["47", "48"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "51": {"nodes": ["45", "48"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "52": {"nodes": ["46", "47"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "53": {"nodes": ["49", "16"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "54": {"nodes": ["16", "17"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "55": {"nodes": ["17", "47"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "56": {"nodes": ["17", "49"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "57": {"nodes": ["50", "16"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "58": {"nodes": ["16", "15"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "59": {"nodes": ["15", "12"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "60": {"nodes": ["28", "27"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "61": {"nodes": ["27", "26"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "62": {"nodes": ["26", "25"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "63": {"nodes": ["25", "24"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "64": {"nodes": ["24", "23"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "65": {"nodes": ["23", "17"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "66": {"nodes": ["23", "22"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "67": {"nodes": ["22", "21"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "68": {"nodes": ["21", "20"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "69": {"nodes": ["20", "19"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "70": {"nodes": ["19", "18"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "71": {"nodes": ["23", "35"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "72": {"nodes": ["35", "36"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "73": {"nodes": ["35", "34"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "74": {"nodes": ["34", "32"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "75": {"nodes": ["34", "33"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "76": {"nodes": ["36", "34"], "passable": ["foot", "walker", "wheelchair", "scooter"]}, "77": {"nodes": ["33", "35"], "passable": ["foot", "walker", "wheelchair", "scooter"]}}, "nodes": {"0": {"r": "0.65", "x": "12.59", "y": "11.11"}, "1": {"r": "0.62", "x": "22.57", "y": "11.17"}, "2": {"r": "0.67", "x": "26.55", "y": "11.57"}, "3": {"r": "0.75", "x": "28.21", "y": "13.83"}, "4": {"r": "0.75", "x": "28.72", "y": "17.49"}, "5": {"r": "0.68", "x": "27.52", "y": "18.69"}, "6": {"r": "0.75", "x": "36.18", "y": "18.52"}, "7": {"r": "0.72", "x": "36.30", "y": "11.17"}, "8": {"r": "0.65", "x": "30.43", "y": "18.69"}, "9": {"r": "0.58", "x": "41.31", "y": "11.11"}, "10": {"r": "0.77", "x": "44.73", "y": "16.64"}, "11": {"r": "0.58", "x": "42.51", "y": "22.22"}, "12": {"r": "0.79", "x": "41.09", "y": "25.21"}, "13": {"r": "0.43", "x": "41.26", "y": "27.58"}, "14": {"r": "0.34", "x": "39.55", "y": "32.48"}, "15": {"r": "0.79", "x": "35.10", "y": "25.21"}, "16": {"r": "0.72", "x": "25.07", "y": "25.21"}, "17": {"r": "0.82", "x": "18.80", "y": "25.21"}, "18": {"r": "0.58", "x": "17.55", "y": "25.10"}, "19": {"r": "0.66", "x": "14.70", "y": "27.24"}, "20": {"r": "0.75", "x": "13.73", "y": "29.75"}, "21": {"r": "0.67", "x": "14.87", "y": "32.71"}, "22": {"r": "0.72", "x": "17.49", "y": "33.79"}, "23": {"r": "0.79", "x": "18.80", "y": "33.85"}, "24": {"r": "0.76", "x": "20.17", "y": "33.91"}, "25": {"r": "0.61", "x": "26.95", "y": "33.73"}, "26": {"r": "0.65", "x": "29.52", "y": "33.79"}, "27": {"r": "0.69", "x": "36.41", "y": "33.68"}, "28": {"r": "0.75", "x": "38.12", "y": "34.08"}, "29": {"r": "0.79", "x": "37.15", "y": "36.64"}, "30": {"r": "0.90", "x": "34.08", "y": "44.50"}, "31": {"r": "0.60", "x": "32.88", "y": "44.16"}, "32": {"r": "0.69", "x": "25.19", "y": "41.20"}, "33": {"r": "0.79", "x": "20.12", "y": "41.03"}, "34": {"r": "0.69", "x": "20.06", "y": "38.64"}, "35": {"r": "0.72", "x": "18.80", "y": "38.01"}, "36": {"r": "0.86", "x": "18.75", "y": "40.97"}, "37": {"r": "0.75", "x": "17.49", "y": "41.20"}, "38": {"r": "0.68", "x": "15.27", "y": "41.37"}, "39": {"r": "0.82", "x": "7.522", "y": "41.14"}, "40": {"r": "0.31", "x": "5.470", "y": "39.66"}, "41": {"r": "0.31", "x": "5.527", "y": "20.23"}, "42": {"r": "0.79", "x": "6.325", "y": "18.69"}, "43": {"r": "0.72", "x": "6.325", "y": "14.53"}, "44": {"r": "0.75", "x": "8.263", "y": "11.80"}, "45": {"r": "0.75", "x": "18.86", "y": "18.75"}, "46": {"r": "0.79", "x": "25.13", "y": "18.63"}, "47": {"r": "0.72", "x": "21.08", "y": "20.91"}, "48": {"r": "0.65", "x": "24.10", "y": "20.97"}, "49": {"r": "0.58", "x": "23.93", "y": "24.22"}, "50": {"r": "0.55", "x": "20.97", "y": "24.22"}}}
diff --git a/batch-simulation/simulator.py b/batch-simulation/simulator.py
--- /dev/null
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3\r
+\r
+import datetime\r
+import math\r
+import os\r
+import random\r
+import threading\r
+import time\r
+\r
+from data import Position, Intent, User, SmartUrbanObject, Context\r
+\r
+\r
+class ContextSimulator:\r
+ def __init__(self, context, routing_engine, csv_path):\r
+ self.follow_previous_direction_for_distance = 3\r
+ self.context = context\r
+ self.routing_engine = routing_engine\r
+ self.csv_path = csv_path\r
+ self.last_print = datetime.datetime.utcnow()\r
+\r
+ def run(self, repetitions, num_users):\r
+ self.csv_out = open(self.csv_path, 'w')\r
+ result = {}\r
+ for d in range(11):\r
+ density = d / 10\r
+ print('Running for density:', density)\r
+ result[density] = self.run_for_density(density, repetitions, num_users)\r
+ self.csv_out.close()\r
+ return result\r
+\r
+ def run_for_density(self, mir_density, repetitions, num_users):\r
+ result = []\r
+ last_count = 0\r
+ for r in range(repetitions):\r
+ self.routing_engine.shuffle_mirs(mir_density)\r
+ rep_result = []\r
+ for u in range(num_users):\r
+ rep_result.append(self.calc_navigation())\r
+ out1 = str(round(rep_result[-1][0], 2))\r
+ out2 = str(round(rep_result[-1][1], 2))\r
+ out3 = str(round(rep_result[-1][1] / rep_result[-1][0], 2))\r
+ print(str(mir_density) + ',' + str(r+1) + ',' + str(u+1) + ',' + out1 + ',' + out2 + ',' + out3, file=self.csv_out)\r
+ since_last_print = datetime.datetime.utcnow() - self.last_print\r
+ if since_last_print > datetime.timedelta(seconds=10):\r
+ new_count = r * num_users + u + 1\r
+ time_per_user = since_last_print / (new_count - last_count)\r
+ print(f'Calculated {new_count}/{repetitions*num_users} for density {mir_density} (tpu: ' + '{0:.3g}'.format(time_per_user.total_seconds()) + ')')\r
+ self.last_print = datetime.datetime.utcnow()\r
+ last_count = new_count\r
+ result.append(rep_result)\r
+ return result\r
+\r
+ def calc_navigation(self):\r
+ nodes = self.routing_engine.get_network()['nodes']\r
+ self.current_node = random.choice(list(nodes.keys()))\r
+ self.goal = self.current_node\r
+ while self.goal == self.current_node:\r
+ self.goal = random.choice(list(nodes.keys()))\r
+ self.current_distance = 0\r
+ self.nodes_since_last_support = 0\r
+ self.previous_node = None\r
+ self.shortest_distance = self.routing_engine.get_route_distance(self.current_node, self.goal)\r
+ path = [self.current_node]\r
+ while self.current_node != self.goal and self.current_distance < 10*self.shortest_distance:\r
+ self.step()\r
+ path.append(self.current_node)\r
+ diversion_factor = self.current_distance / self.shortest_distance\r
+ return [self.shortest_distance, self.current_distance, path]\r
+\r
+ def step(self):\r
+ route = self.routing_engine.route_between_nodes(self.current_node, self.goal)\r
+ candidates = self.routing_engine.get_connected_nodes(self.current_node)\r
+ if len(candidates) >= 2 and self.previous_node in candidates:\r
+ candidates.remove(self.previous_node)\r
+ if len(candidates) == 1:\r
+ target = candidates[0]\r
+ elif self.routing_engine.is_confusing(self.current_node):\r
+ candidates = self.routing_engine.get_connected_nodes(self.current_node)\r
+ if len(candidates) >= 2 and self.previous_node in candidates:\r
+ candidates.remove(self.previous_node)\r
+ if len(candidates) >= 2:\r
+ self.nodes_since_last_support += 1\r
+ if self.nodes_since_last_support < self.follow_previous_direction_for_distance and self.previous_node is not None:\r
+ target = self.routing_engine.get_next_straight_node(self.previous_node, self.current_node, candidates) \r
+ else:\r
+ target = random.choice(candidates)\r
+ else:\r
+ target = route[1]\r
+ self.nodes_since_last_support = 0\r
+ self.current_distance += self.routing_engine.get_node_distance(self.current_node, target)\r
+ self.previous_node = self.current_node\r
+ self.current_node = target\r
+\r
diff --git a/batch-simulation/visualizer.py b/batch-simulation/visualizer.py
--- /dev/null
@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+
+import collections
+import copy
+import datetime
+import json
+import math
+import os
+import pickle
+import random
+import sys
+import time
+
+from PIL import Image, ImageDraw, ImageFont
+
+from data import Position, Intent, User, SmartUrbanObject, Context
+
+
+class Visualizer:
+ def __init__(self, context, simulation, network, step_length):
+ self.context = context
+ self.network = network
+ self.simulation = simulation
+ self.step_length = step_length
+ self.fail_factor = None
+ self.font = ImageFont.truetype("arial.ttf", 15)
+ self.bg = None
+ self.rotate = True
+
+ def get_image_coords(self, coords):
+ if self.rotate:
+ return (round(float(coords['y']) / self.boundaries[0] * 1000), 1000-round(float(coords['x']) / self.boundaries[1] * 1000))
+ else:
+ return (round(float(coords['x']) / self.boundaries[0] * 1000), round(float(coords['y']) / self.boundaries[1] * 1000))
+
+ def render_bg(self):
+ self.bg = Image.new('RGB', (1000, 1000))
+ network = self.network
+ draw = ImageDraw.Draw(self.bg)
+ for edge_id in network['edges']:
+ edge = network['edges'][edge_id]
+ nodeA = network['nodes'][edge['nodes'][0]]
+ nodeB = network['nodes'][edge['nodes'][1]]
+ draw.line((self.get_image_coords(nodeA), self.get_image_coords(nodeB)), fill=(0, 255, 255), width=3)
+ for node_id in network['nodes']:
+ node = network['nodes'][node_id]
+ x, y = self.get_image_coords(node)
+ if 'is_crossroad' in node and node['is_crossroad']:
+ r = 6
+ color = (0, 255, 255)
+ if node['has_mir']:
+ color = (255, 255, 0)
+ draw.ellipse((x-r, y-r, x+r, y+r), fill=color)
+ #if node_id == '1':
+ # draw.text((x-20, y-20), 'Start', fill=(255, 255, 255), font=self.font)
+ #elif node_id == '30':
+ # draw.text((x-20, y+10), 'Goal', fill=(255, 255, 255), font=self.font)
+ del draw
+
+ def render_bg_svg(self):
+ network = self.network
+ result = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+ xmlns="http://www.w3.org/2000/svg"
+ width="1000"
+ height="1000"
+ viewBox="0 0 1000 1000"
+ version="1.1">
+ <g
+ stroke-width="4"
+ stroke="#000"
+ stroke-linecap="round">
+"""
+ for edge_id in network['edges']:
+ edge = network['edges'][edge_id]
+ nodeA = network['nodes'][edge['nodes'][0]]
+ nodeB = network['nodes'][edge['nodes'][1]]
+ coordsA = self.get_image_coords(nodeA)
+ coordsB = self.get_image_coords(nodeB)
+ result += f'<line x1="{coordsA[0]}" x2="{coordsB[0]}" y1="{coordsA[1]}" y2="{coordsB[1]}" />'
+ result += '</g></svg>'
+ return result
+
+ def render_frame(self, density, repetition, frame_number):
+ if self.bg is None:
+ self.render_bg()
+ frame = self.bg.copy()
+ draw = ImageDraw.Draw(frame)
+ finished_and_failed = dict(self.finished_users)
+ finished_and_failed.update(self.failed_users)
+ for user_id in finished_and_failed:
+ user = self.finished_users[user_id] if user_id in self.finished_users else self.failed_users[user_id]
+ x, y = self.get_image_coords(user['pos'])
+ r = 10
+ detour_factor = user['distance'] / user['shortest']
+ hue = max(0, 128 - 128 * max(detour_factor / 3, 1))
+ user_color = 'hsl(' + str(hue) + ',60%,25%)'
+ draw.ellipse((x-r, y-r, x+r, y+r), fill=user_color, outline=(127, 127, 127))
+ for user_id in self.active_users:
+ user = self.active_users[user_id]
+ x, y = self.get_image_coords(user['pos'])
+ r = 10
+ detour_factor = user['distance'] / user['shortest']
+ hue = max(0, 128 - detour_factor * 128 / 3)
+ user_color = 'hsl(' + str(hue) + ',60%,50%)'
+ draw.ellipse((x-r, y-r, x+r, y+r), fill=user_color, outline=(255, 255, 255))
+ text = [
+ 'Active: ' + str(len(self.active_users.keys())),
+ 'Finished at goal: ' + str(len(self.finished_users.keys())),
+ 'Finished elsewhere: ' + str(len(self.failed_users.keys())),
+ ]
+ draw.text((50, 900), '\n'.join(text), fill=(255, 255, 255), font=self.font)
+ del draw
+ frame.save('frames/' + str(density).replace('.', '_') + '_' + str(repetition) + '_' + str(frame_number) + '.png')
+
+ def run(self):
+ network = self.network
+ for root, dirs, files in os.walk('frames'):
+ for file in files:
+ os.remove(os.path.join(root, file))
+ for density in self.simulation:
+ for r in range(len(self.simulation[density])):
+ repetition = self.simulation[density][r]
+ frame_number = 0
+ total_users = len(repetition)
+ self.active_users = {}
+ self.failed_users = {}
+ self.finished_users = {}
+ while len(self.finished_users.keys()) + len(self.failed_users.keys()) < total_users:
+ finished = []
+ failed = []
+ print(frame_number)
+ for user_id in self.active_users:
+ user = self.active_users[user_id]
+ self.walk_step(user)
+ if len(user['path']) == 0:
+ finished.append(user_id)
+ if self.fail_factor is not None and user['distance'] > self.fail_factor * user['shortest']:
+ failed.append(user_id)
+ for user_id in finished:
+ self.finished_users[user_id] = self.active_users[user_id]
+ del self.active_users[user_id]
+ for user_id in failed:
+ self.failed_users[user_id] = self.active_users[user_id]
+ del self.active_users[user_id]
+ self.render_frame(density, r, frame_number)
+ frame_number += 1
+ next_user = len(self.active_users.keys()) + len(self.finished_users.keys()) + len(self.failed_users.keys())
+ if next_user < total_users:
+ self.active_users[next_user] = {
+ 'path': repetition[next_user][2][1:],
+ 'pos': copy.deepcopy(network['nodes'][repetition[next_user][2][0]]),
+ 'distance': 0.0,
+ 'shortest': repetition[next_user][0]
+ }
+
+ def walk_step(self, user):
+ network = self.network
+ step_length = self.step_length
+ while step_length > 0.0 and len(user['path']) > 0:
+ next_goal = network['nodes'][user['path'][0]]
+ delta = {'x': float(next_goal['x']) - float(user['pos']['x']), 'y': float(next_goal['y']) - float(user['pos']['y'])}
+ distance_to_goal = math.sqrt(delta['x'] ** 2 + delta['y'] ** 2)
+ if step_length > distance_to_goal:
+ user['pos'] = copy.deepcopy(next_goal)
+ del user['path'][0]
+ step_length -= distance_to_goal
+ user['distance'] += distance_to_goal
+ else:
+ user['pos']['x'] = float(user['pos']['x']) + delta['x'] * step_length / distance_to_goal
+ user['pos']['y'] = float(user['pos']['y']) + delta['y'] * step_length / distance_to_goal
+ user['distance'] += step_length
+ step_length = 0.0
+
+
+data = {
+ 'context': {}
+}
+
+def setup_world(boundaries):
+ world = Context('demo', 'Scooter-Park')
+ world.set_boundaries(boundaries[0], boundaries[1])
+ data['context']['demo'] = world
+
+
+if __name__ == '__main__':
+ path = sys.argv[1]
+ if path.endswith('.dat'):
+ with open(path, 'rb') as fp:
+ sim_data = pickle.load(fp)
+ boundaries = (sim_data['network']['boundaries']['width'], sim_data['network']['boundaries']['height'])
+ setup_world(boundaries)
+ step_length = (sim_data['network']['boundaries']['width'] + sim_data['network']['boundaries']['height']) / 500
+ vis = Visualizer(data['context']['demo'], sim_data['simulation'], sim_data['network'], step_length)
+ vis.boundaries = boundaries
+ if 'pre-rotated' in sim_data['network']['boundaries'] and sim_data['network']['boundaries']['pre-rotated']:
+ vis.rotate = False
+ vis.run()
+ elif path.endswith('.json'):
+ if len(sys.argv) < 4:
+ print('Requires output file names (PNG and SVG).')
+ sys.exit(1)
+ with open(path, 'r') as fp:
+ network = json.load(fp)
+ vis = Visualizer(None, None, network, 0)
+ vis.boundaries = (network['boundaries']['width'], network['boundaries']['height'], None)
+ if 'pre-rotated' in network['boundaries'] and network['boundaries']['pre-rotated']:
+ vis.rotate = False
+ vis.render_bg()
+ vis.bg.save(sys.argv[2])
+ svg = vis.render_bg_svg()
+ with open(sys.argv[3], 'w') as fp:
+ fp.write(svg)
+