def setUp(self):
super(SimulationDataParserTest, self).setUp()
local_testdir = './teatdata'
self._testdata_dir = os.path.join(FLAGS.test_srcdir, local_testdir)
self._output_dir = tempfile.mkdtemp(
dir=absltest.get_default_test_tmpdir())
self._data_parser = parser.SimulationDataParser()
def _extract_detector_data(self):
"""Extracts detector data form xml files."""
data_parser = simulation_data_parser.SimulationDataParser()
visualizer = map_visualizer.MapVisualizer()
detector_folder = os.path.join(self._output_dir, 'detector/')
detector_trajectory_folder = os.path.join(detector_folder,
'detector_trajectory/')
if not file_util.exists(detector_trajectory_folder):
file_util.mkdir(detector_trajectory_folder)
detector_files = os.listdir(detector_folder)
for detector_file in detector_files:
if not detector_file.endswith('.xml'):
continue
# print('Extract file: ', detector_file)
output_file = os.path.splitext(detector_file)[0] + '.pkl'
output_file = os.path.join(detector_trajectory_folder, output_file)
detector_file = os.path.join(detector_folder, detector_file)
print('Save file: ', output_file)
data_parser.get_and_save_detector_data(detector_file, output_file)
# Creates figures for individual detector.
output_figure_folder = os.path.join(detector_folder, 'detector_fig/')
if not file_util.f_exists(output_figure_folder):
file_util.f_mkdir(output_figure_folder)
visualizer.plot_individual_detector(detector_trajectory_folder,
output_figure_folder)
def plot_traveling_time(self):
"""Plot tripinfo data."""
visualizer = map_visualizer.MapVisualizer()
data_parser = simulation_data_parser.SimulationDataParser()
tripinfo_file = 'output/tripinfo.xml'
# output_folder = 'output/'
# output_file = 'tripinfo.pkl'
tripinfo = data_parser.get_tripinfo_attribute_to_trips(tripinfo_file)
bins = np.linspace(0, 12, 49)
positions_on_edge = (np.array(tripinfo['depart']) -
np.array(tripinfo['departDelay'])) / 3600
values_on_edge = np.array(tripinfo['duration'])
print(len(values_on_edge), len(values_on_edge))
# print(positions_on_edge)
bin_mean, bin_boundary = visualizer._histogram_along_edge(
values_on_edge, positions_on_edge, bins=bins)
# print(bin_mean, bin_boundary)
fig = pylab.figure(figsize=(8, 6))
fig.add_subplot(111)
pylab.plt.plot(bin_boundary[:-1], bin_mean)
pylab.plt.xlabel('Time [h]')
pylab.plt.xlim(0, 10)
pylab.plt.ylim(0, 10000)
pylab.plt.ylabel('Average traveling time.')
pylab.savefig(os.path.join(self._output_dir,
'traveling_time_hist.pdf'))
def parse_fcd_results_multiple_files(self):
"""Extract the data then save to file."""
net = sumolib.net.readNet(self._sumo_net_file)
data_parser = simulation_data_parser.SimulationDataParser()
plot_edges = net.getEdges()
fcd_file_folder = 'output/fcd_segments/'
# fcd_file_list = os.listdir(fcd_file_folder)
fcd_file_list = ['traffic.segment_2.fcd.xml']
output_folder = os.path.join(self._output_dir, 'trajectory/')
for fcd_file in fcd_file_list:
print('Analyzing file: ', fcd_file)
# time_segment_length = 0.5 * 3600
time_segment_length = None
# time_range = [0, 3600*12]
time_range = None
data_parser.save_batch_edge_id_to_trajectory(
os.path.join(fcd_file_folder, fcd_file),
plot_edges,
time_range=time_range,
time_segment_length=time_segment_length,
parse_time_step=10,
output_folder=output_folder)
def setUp(self): super(MapVisualizerTests, self).setUp() self._output_dir = tempfile.mkdtemp(dir=absltest.get_default_test_tmpdir()) self._fcd_file = _load_file(_TESTDATA_DIR, _FCD_FILE_NAME) self._summary_file = _load_file(_TESTDATA_DIR, _SUMMARY_FILE_NAME) self._route_file = _load_file(_TESTDATA_DIR, _ROUTE_FILE_NAME) mtv_map_file = _load_file(_TESTDATA_DIR, _MTV_MAP_FILE_NAME) net = sumolib.net.readNet(mtv_map_file) self._map_visualier = map_visualizer.MapVisualizer(net) self._data_parser = simulation_data_parser.SimulationDataParser()
def scenarios_detector_comparison(output_dir):
"""Compare different scenarios."""
data_parser = simulation_data_parser.SimulationDataParser()
visualizer = map_visualizer.MapVisualizer()
fig = pylab.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
load_input = file_util.load_variable(
'Paradise_reverse_roads/demands/demands_taz_tuple.pkl')
load_input = sorted(load_input)
demand_time_line, _, demand_car_count = list(zip(*load_input))
cumulative_values = np.cumsum(demand_car_count)
pylab.plt.plot(np.array(demand_time_line) / 3600, cumulative_values)
# print(cumulative_values[-1])
# print(np.sum(demand_car_count))
# visualizer.add_pertentage_interception_lines(
# np.array(demand_time_line) / 3600, demand_car_count, [0.5, .9, .95])
detector_trajectory_folder = 'Paradise_reverse_roads/output/detector/detector_trajectory/'
(time_line,
arrival_car_count) = file_util.load_variable(detector_trajectory_folder +
'all_arrival_flow.pkl')
cumulative_values = np.cumsum(arrival_car_count)
print(cumulative_values[-1])
pylab.plt.plot(time_line, cumulative_values)
visualizer.add_pertentage_interception_lines(time_line, arrival_car_count,
[0.5, .9, .95])
detector_trajectory_folder = 'Paradise_auto_routing/output/detector/detector_trajectory/'
(time_line,
arrival_car_count) = file_util.load_variable(detector_trajectory_folder +
'all_arrival_flow.pkl')
cumulative_values = np.cumsum(arrival_car_count)
print(cumulative_values[-1])
pylab.plt.plot(time_line / 3600, cumulative_values)
# visualizer.add_pertentage_interception_lines(
# time_line, arrival_car_count, [0.5, .9, .95])
detector_trajectory_folder = 'Paradise_2s_baseline/output/detector/detector_trajectory/'
(time_line,
arrival_car_count) = file_util.load_variable(detector_trajectory_folder +
'all_arrival_flow.pkl')
cumulative_values = np.cumsum(arrival_car_count)
print(cumulative_values[-1])
pylab.plt.plot(time_line, cumulative_values)
pylab.plt.xlabel('Time [h]')
pylab.plt.ylabel('Cummulative vehicles')
ax.autoscale_view(True, True, True)
pylab.savefig(os.path.join(output_dir, 'scenarios_arrival_comparison.pdf'))
def _analyze_summary_demands_vs_evacuation(self,
demand_file,
summary_file,
output_dir=None):
"""Plot summary vs demands."""
data_parser = simulation_data_parser.SimulationDataParser()
visualizer = map_visualizer.MapVisualizer()
demands = file_util.load_variable(demand_file)
sorted_demands = sorted(demands, key=lambda x: x.time)
demand_time_line = [x.time for x in sorted_demands]
demand_time_line = np.array(demand_time_line) / 3600
demand_car_count = [x.num_cars for x in sorted_demands]
demand_cumulative_values = (np.cumsum(demand_car_count) /
sum(demand_car_count))
summary = data_parser.parse_summary_file(summary_file)
summary_time_line = np.array(summary['time']) / 3600
summary_cumulative_values = (np.array(summary['ended']) /
sum(demand_car_count))
# Calculate the gap between them.
gap_area = visualizer.calculate_gap_area_between_cummulative_curves(
demand_time_line, demand_cumulative_values, summary_time_line,
summary_cumulative_values)
if not output_dir:
return (demand_time_line, demand_cumulative_values,
summary_time_line, summary_cumulative_values, gap_area)
# Plot demands v.s. evacuation.
fig = pylab.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
pylab.plt.plot(demand_time_line,
demand_cumulative_values,
label='Demands')
pylab.plt.plot(summary_time_line,
summary_cumulative_values,
label='Evacuation')
visualizer.add_pertentage_interception_lines(
summary_time_line, summary_cumulative_values, [0.5, .9, .95])
pylab.plt.xlabel('Time [h]')
pylab.plt.ylabel('Cummulative percentage of total vehicles')
pylab.plt.legend()
ax.autoscale_view(True, True, True)
output_figure_path = os.path.join(output_dir, 'evacuation_curve.pdf')
pylab.savefig(output_figure_path)
return (demand_time_line, demand_cumulative_values, summary_time_line,
summary_cumulative_values, gap_area)
def scenarios_summary_comparison(output_dir):
"""Compare different scenarios."""
data_parser = simulation_data_parser.SimulationDataParser()
visualizer = map_visualizer.MapVisualizer()
fig = pylab.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
demands = file_util.load_variable(
'MillValley_template/demands/demands_taz_tuple_std_0.5_portion_1.pkl')
sorted_demands = sorted(demands, key=lambda x: x.time)
demand_time_line = [x.time for x in sorted_demands]
demand_car_count = [x.num_cars for x in sorted_demands]
cumulative_values = np.cumsum(demand_car_count) / sum(demand_car_count)
pylab.plt.plot(np.array(demand_time_line) / 3600,
cumulative_values,
label='Demands')
summary = data_parser.parse_summary_file(
'MillValley_RevRd_noTFL/output_std_0.5_portion_1/summary.xml')
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line, cumulative_values, label='New scenario')
summary = data_parser.parse_summary_file(
'MillValley_auto_routing_baseline/output_std_0.5_portion_1/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line, cumulative_values, label='Baseline auto-routing')
summary = data_parser.parse_summary_file(
'MillValley_shortest_path_baseline/output_std_0.5_portion_1/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line, cumulative_values, label='Baseline fixed path')
visualizer.add_pertentage_interception_lines(time_line, cumulative_values,
[0.5, .9, .95])
pylab.plt.xlabel('Time [h]')
pylab.plt.ylabel('Cummulative vehicles')
ax.autoscale_view(True, True, True)
# pylab.plt.xlim(0, 8)
pylab.plt.legend(loc='lower right')
pylab.savefig(
os.path.join(output_dir, 'MV_evacuation_curve_std_0.5_comparison.pdf'))
def parse_fcd_results_single_file(self, hours):
"""Extract the data then save to file."""
net = sumolib.net.readNet(self._sumo_net_file)
data_parser = simulation_data_parser.SimulationDataParser()
plot_edges = net.getEdges()
fcd_file = os.path.join(self._output_dir, 'traffic.fcd.xml')
output_folder = os.path.join(self._output_dir, 'trajectory/')
if not file_util.f_exists(output_folder):
file_util.f_mkdir(output_folder)
time_segment_length_seconds = hours * 3600
time_range_seconds = [0, 3600 * 12]
data_parser.save_batch_edge_id_to_trajectory(
fcd_file, plot_edges,
time_range=time_range_seconds,
time_segment_length=time_segment_length_seconds,
parse_time_step=10, output_folder=output_folder)
def scenarios_summary_comparison(output_dir):
"""Compare different scenarios."""
data_parser = simulation_data_parser.SimulationDataParser()
visualizer = map_visualizer.MapVisualizer()
fig = pylab.figure(figsize=(8, 6))
ax = fig.add_subplot(111)
demands = file_util.load_variable(
'Paradise_template/demands/demands_taz_tuple_std_0.7.pkl')
sorted_demands = sorted(demands, key=lambda x: x.time)
demand_time_line = [x.time for x in sorted_demands]
demand_car_count = [x.num_cars for x in sorted_demands]
cumulative_values = np.cumsum(demand_car_count) / sum(demand_car_count)
pylab.plt.plot(np.array(demand_time_line) / 3600,
cumulative_values,
':',
label='Demands',
color='black')
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL/output_std_0.7/summary.xml')
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line, cumulative_values, '--', label='No block')
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL_road_blocker/output_std_0.7_road_block_21600/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line,
cumulative_values,
label='t=5 h',
color=pylab.plt.cm.jet(1 / 6))
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL_road_blocker/output_std_0.7_road_block_18000/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line,
cumulative_values,
label='t=4 h',
color=pylab.plt.cm.jet(2 / 6))
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL_road_blocker/output_std_0.7_road_block_10800/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line,
cumulative_values,
label='t=3 h',
color=pylab.plt.cm.jet(3 / 6))
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL_road_blocker/output_std_0.7_road_block_7200/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line,
cumulative_values,
label='t=2 h',
color=pylab.plt.cm.jet(4 / 6))
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL_road_blocker/output_std_0.7_road_block_3600/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line,
cumulative_values,
label='t=1 h',
color=pylab.plt.cm.jet(5 / 6))
summary = data_parser.parse_summary_file(
'Paradise_RevRd_noTFL_road_blocker/output_std_0.7_road_block_0/summary.xml'
)
time_line = np.array(summary['time']) / 3600
cumulative_values = np.array(summary['ended']) / sum(demand_car_count)
pylab.plt.plot(time_line,
cumulative_values,
label='t=0 h',
color=pylab.plt.cm.jet(0.95))
# visualizer.add_pertentage_interception_lines(
# time_line, cumulative_values, [0.5, .9, .95])
pylab.plt.xlabel('Time [h]')
pylab.plt.ylabel('Cummulative vehicles')
ax.autoscale_view(True, True, True)
pylab.plt.xlim(1, 6)
pylab.plt.legend(loc='lower right')
pylab.savefig(
os.path.join(output_dir,
'evacuation_curve_std_0.7_road_block_comparison.pdf'))
