def write_matlab_results(self):
"""
Stores result in binary matlab file
:return: None
"""
ft.log("Started writing results to binary file")
filename = "%s/%s_%s" % (self.result_dir, 'results', self.id)
sio.savemat(
filename,
mdict={
"max_speed":
self.max_speed,
"time_spent":
self.time_spent,
"origins":
self.origins,
"avg_mean_speed":
self.avg_mean_speed,
# "paths_list": self.paths_list,
"mean_speed":
self.mean_speed,
"position_list":
self.position_list,
"finished":
self.finished,
"final_positions":
self.scene.position_array[self.scene.active_entries],
"exit_times":
self.exit_times[:self.number_of_peds_left, :],
"pressure_sum":
self.pressure_sum
})
ft.log("Finished writing results to binary file")
def finish(self):
"""
Finish the simulation and run all registered methods that should be called on finish.
:return: None
"""
functions.log("Finishing simulation. %d iterations of %.2f seconds" %
(self.scene.counter, self.scene.time))
[finish() for finish in self.finish_functions]
def _give_relative_position(self, event):
"""
Return the position of the click, reverted to the standard coordinate system (in first quadrant of unit square)
:param event: Mouse click or whatever
:return: Coordinates relative to scene.
"""
x, y = (event.x / self.size[0], 1 - event.y / self.size[1])
ft.log("Mouse location: (%.2f,%.2f)" % (x, y))
def start(self):
while not self.is_done:
try:
self.step_callback()
# ft.log("Iteration took %.4f seconds" % (time.time() - self.time))
# ft.log("Time step %d" % self.scene.counter)
self.time = time.time()
except KeyboardInterrupt:
ft.log("\nUser interrupted simulation")
self.scene.status = 'DONE'
def _provide_information(self, event):
"""
When assigned to a button by tkinter, prints a live summary of the present pedestrians to the screen.
:param event: Event instance passed by tkinter
:return: None
"""
x, y = (event.x / self.size[0], 1 - event.y / self.size[1])
scene_point = Point([x * self.scene.size[0], y * self.scene.size[1]])
ft.log("Mouse location: %s" % scene_point)
for pedestrian in self.scene.pedestrian_list:
print(pedestrian)
for obstacle in self.scene.obstacle_list:
print(obstacle)
def _provide_information(self, event):
"""
When assigned to a button by tkinter, prints a live summary of the present pedestrians to the screen.
:param event: Event instance passed by tkinter
:return: None
"""
x, y = (event.x / self.size[0], 1 - event.y / self.size[1])
scene_point = Point([x * self.scene.size[0], y * self.scene.size[1]])
ft.log("Mouse location: %s" % scene_point)
for pedestrian in self.scene.pedestrian_list:
print(pedestrian)
for obstacle in self.scene.obstacle_list:
print(obstacle)
def on_finish(self):
"""
All data that should be gathered on finishing the simulation:
:return: None
"""
ft.log("Starting post-processing results")
unfinished_counters = [self.scene.index_map[index].counter for index in
np.where(self.scene.active_entries)[0]]
for ped_index in unfinished_counters:
self.time_spent[ped_index] = self.scene.time
self.paths_list = np.array(self.paths_list)
self.position_list = np.array(self.position_list)
self.avg_mean_speed = np.mean(self.mean_speed)
self.write_matlab_results()
ft.log("Finished post-processing results")
def write_matlab_results(self):
"""
Stores result in binary matlab file
:return: None
"""
ft.log("Started writing results to binary file")
filename = self.result_dir + 'results' + self.scene.config['general']['number_of_pedestrians']
sio.savemat(filename, mdict={"max_speed": self.max_speed,
"time_spent": self.time_spent,
"origins": self.origins,
"avg_mean_speed": self.avg_mean_speed,
"paths_list": self.paths_list,
"mean_speed": self.mean_speed,
"position_list": self.position_list,
"finished": self.finished,
"final_positions": self.scene.position_array[self.scene.active_entries]})
ft.log("Finished writing results to binary file")
def on_finish(self):
"""
All data that should be gathered on finishing the simulation:
:return: None
"""
ft.log("Starting post-processing results")
unfinished_counters = [
self.scene.index_map[index].counter
for index in np.where(self.scene.active_entries)[0]
]
for ped_index in unfinished_counters:
self.time_spent[ped_index] = self.scene.time
# self.paths_list = np.array(self.paths_list)
self.position_list = np.array(self.position_list)
self.avg_mean_speed = np.mean(self.mean_speed)
self.write_matlab_results()
ft.log("Finished post-processing results")
def prepare(self, params):
"""
Called before the simulation starts. Fix all parameters and bootstrap functions.
:params: Parameter object
:return: None
"""
self.params = params
init_size = Size(
[self.params.screen_size_x, self.params.screen_size_y])
# Todo: Set initial visualisation dimensions as a function of scene size
self.autoloop = params.time_delay > 0
if not self.autoloop:
ft.log(
"Auto-updating of backend disabled. Press <Space> or click to advance simulation"
)
self.window = tkinter.Tk()
self.window.title("Mercurial: Hybrid simulation for dense crowds")
self.window.geometry("%dx%d" % (init_size[0], init_size[1]))
self.window.bind("<Button-3>", self.store_scene)
self.window.grid()
# Todo: Draw the fire
env_image = self.params.scene_file
self.original_env = Image.open(env_image)
self.env = ImageTk.PhotoImage(self.original_env)
self.canvas = tkinter.Canvas(self.window, bd=0, highlightthickness=0)
self.canvas.create_image(0,
0,
image=self.env,
anchor=tkinter.NW,
tags="IMG")
self.canvas.grid(row=0,
sticky=tkinter.W + tkinter.E + tkinter.N + tkinter.S)
self.canvas.pack(fill=tkinter.BOTH, expand=1)
# self.window.pack(fill=tkinter.BOTH,expand=1)
self.window.bind("<Configure>", self.resize)
def start(self):
while not self.scene.status == 'DONE':
try:
self.step_callback()
ft.log("Iteration took %.4f seconds" % (time.time() - self.time))
ft.log("Time step %d" % self.scene.counter)
self.time = time.time()
except KeyboardInterrupt:
ft.log("\nUser interrupted simulation")
self.scene.status = 'DONE'
def __init__(self, scene, planner, identifier):
"""
Results processed in this class:
- Path length (measuring the distance between all successive points pedestrians visit).
- Planned path length (measuring the sum of line segment lengths of the planned path).
- Time spent (number of time steps * dt pedestrians spend inside the scene).
- Density (total mass (=number of pedestrians) divided by the area of the scene (minus obstacles)).
- Origin (starting point of each pedestrian, to see the results as a relative factor).
- Path (as a sequence of followed points per pedestrian)
Derived results:
- Path length ratio: Path length over planned path length per pedestrian.
- Average path length ratio: Average of all path length ratio's.
- Mean speed: Path length over time spend in simulation.
:param scene: Scene object under evaluation.
:return: None
"""
self.result_dir = scene.config['general']['result_dir']
self.scene = scene
self.planner = planner
ft.log("Simulations results are processed and stored in folder '%s'" %
self.result_dir)
if not hasattr(scene.pedestrian_list[0], "line"):
self.no_paths = True
ft.log("Storing results for Dynamic planner")
else:
self.no_paths = False
ft.log("Storing results for Graph Planner")
self.position_list = []
# Microscopic measures
init_number = len(self.scene.pedestrian_list)
self.time_spent = np.zeros(init_number)
self.mean_speed = np.zeros(init_number)
self.max_speed = np.zeros(init_number)
self.finished = np.zeros(init_number, dtype=bool)
self.started = np.zeros(init_number, dtype=bool)
self.exit_times = np.zeros((init_number, 2))
self.avg_mean_speed = 0
self.density = init_number / (self.scene.size[0] * self.scene.size[1])
self.origins = np.zeros([init_number, 2])
# Macroscopic measures
self.shape = self.planner.macro.pressure_field.array.shape
self.pressure_sum = np.zeros(self.shape)
self.on_init()
self.id = identifier
self.number_of_peds_left = 0
def __init__(self, scene):
"""
Results processed in this class:
- Path length (measuring the distance between all successive points pedestrians visit).
- Planned path length (measuring the sum of line segment lengths of the planned path).
- Time spent (number of time steps * dt pedestrians spend inside the scene).
- Density (total mass (=number of pedestrians) divided by the area of the scene (minus obstacles)).
- Origin (starting point of each pedestrian, to see the results as a relative factor).
- Path (as a sequence of followed points per pedestrian)
Derived results:
- Path length ratio: Path length over planned path length per pedestrian.
- Average path length ratio: Average of all path length ratio's.
- Mean speed: Path length over time spend in simulation.
:param scene: Scene object under evaluation.
:return: None
"""
self.result_dir = scene.config['general']['result_dir']
self.scene = scene
ft.log("Simulations results are processed and stored in folder '%s'" % self.result_dir)
if not hasattr(scene.pedestrian_list[0], "line"):
self.no_paths = True
ft.log("Storing results for Dynamic planner")
else:
self.no_paths = False
ft.log("Storing results for Graph Planner")
self.position_list = []
self.time_spent = np.zeros(len(self.scene.pedestrian_list))
self.mean_speed = np.zeros(len(self.scene.pedestrian_list))
self.max_speed = np.zeros(len(self.scene.pedestrian_list))
self.finished = np.zeros(len(self.scene.pedestrian_list), dtype=bool)
self.started = np.zeros(len(self.scene.pedestrian_list), dtype=bool)
self.avg_mean_speed = 0
self.density = len(self.scene.pedestrian_list) / (self.scene.size[0] * self.scene.size[1])
self.origins = np.zeros([len(self.scene.pedestrian_list), 2])
self.on_init()
def finish(self):
functions.log("Finishing simulation")
[finish() for finish in self.finish_functions]
def __init__(self, args):
np.seterr(all='raise')
functions.VERBOSE = args.verbose
self.scene = None
self.step_functions = []
self.on_pedestrian_exit_functions = []
self.on_pedestrian_init_functions = []
self.finish_functions = []
config = configparser.ConfigParser()
has_config = config.read(args.config_file)
if not has_config:
raise FileNotFoundError("Configuration file %s not found" % args.config_file)
functions.EPS = config['general'].getfloat('epsilon')
self.config = config
if args.obstacle_file:
config['general']['obstacle_file'] = args.obstacle_file
# Initialization scene
if args.number >= 0:
config['general']['number_of_pedestrians'] = str(args.number)
if args.configuration == 'uniform':
self.scene = scene_module.Scene(config=config)
elif args.configuration == 'top':
self.scene = TopScene(barrier=0.8, config=config)
elif args.configuration == 'center':
self.scene = ImpulseScene(impulse_location=(0.5, 0.6), impulse_size=8, config=config)
elif args.configuration == 'bottom':
self.scene = TwoImpulseScene(impulse_locations=[(0.5, 0.4), (0.4, 0.2)], impulse_size=8, config=config)
if not self.scene:
raise ValueError("No scene has been initialized")
# Initialization planner
planner = Planner(self.scene)
self.step_functions.append(planner.step)
if args.store_positions:
# filename = input('Specify storage file\n')
import re
filename = re.search('/([^/]+)\.json', config['general']['obstacle_file']).group(1)
functions.log("Storing positions results in '%s%s'" % (config['general']['result_dir'], filename))
self.step_functions.append(lambda: self.store_positions_to_file(filename))
self.finish_functions.append(lambda: self.store_position_usage(filename))
self.finish_functions.append(self.store_exit_logs)
if args.results:
results = Result(self.scene)
self.step_functions.append(results.on_step)
self.on_pedestrian_exit_functions.append(results.on_pedestrian_exit)
self.on_pedestrian_init_functions.append(results.on_pedestrian_entrance)
self.finish_functions.append(results.on_finish)
if not args.kernel:
self.vis = VisualScene(self.scene)
if args.step:
self.vis.disable_loop()
else:
self.step_functions.append(self.vis.loop)
else:
if not (args.store_positions or args.results):
functions.warn("No results are logged. Ensure you want a headless simulation.")
self.vis = NoVisualScene(self.scene)
self.scene.on_pedestrian_exit_functions += self.on_pedestrian_exit_functions
self.scene.on_pedestrian_init_functions += self.on_pedestrian_init_functions
self.vis.step_callback = self.step
self.vis.finish_callback = self.finish
