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 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