6687

pending completion

Build # 6687

Build Type

Pull #985

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/flow-project/flow/commit/<a class=hub.com/flow-project/flow/commit/3fd9d938d11cc2bf8547daab03017b1cd615d6e8">3fd9d938d<a href="https://github.com/flow-project/flow/commit/3fd9d938d11cc2bf8547daab03017b1cd615d6e8">">Merge </a><a class="double-link" href="https://github.com/flow-project/flow/commit/<a class="double-link" href="https://github.com/flow-project/flow/commit/b725e0e43e6ad7bb15da7267b7f21e6b520b39b6">b725e0e43</a>">b725e0e43</a><a href="https://github.com/flow-project/flow/commit/3fd9d938d11cc2bf8547daab03017b1cd615d6e8"> into af0b4f68d">af0b4f68d</a>

Pull Request Pull Request #985: add 210 edgestarts for backwards compatibility

Run Details

11 of 11 new or added lines in 5 files covered. (100.0%)

9424 of 10621 relevant lines covered (88.73%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.27

/flow/visualize/time_space_diagram.py

"""Generate a time space diagram for some networks.

This method accepts as input a csv file containing the sumo-formatted emission
file, and then uses this data to generate a time-space diagram, with the x-axis
being the time (in seconds), the y-axis being the position of a vehicle, and
color representing the speed of te vehicles.

If the number of simulation steps is too dense, you can plot every nth step in
the plot by setting the input `--steps=n`.

Note: This script assumes that the provided network has only one lane on the
each edge, or one lane on the main highway in the case of MergeNetwork.

Usage
-----
::
    python time_space_diagram.py </path/to/emission>.csv </path/to/params>.json
"""
from flow.utils.rllib import get_flow_params
from flow.networks import RingNetwork, FigureEightNetwork, MergeNetwork, I210SubNetwork, HighwayNetwork

import argparse
from collections import defaultdict
try:
    from matplotlib import pyplot as plt
except ImportError:
    import matplotlib
    matplotlib.use('TkAgg')
    from matplotlib import pyplot as plt
from matplotlib.collections import LineCollection
import matplotlib.colors as colors
import numpy as np
import pandas as pd


# networks that can be plotted by this method
ACCEPTABLE_NETWORKS = [
    RingNetwork,
    FigureEightNetwork,
    MergeNetwork,
    I210SubNetwork,
    HighwayNetwork
]


def import_data_from_trajectory(fp, params=dict()):
    r"""Import and preprocess data from the Flow trajectory (.csv) file.

    Parameters
    ----------
    fp : str
        file path (for the .csv formatted file)
    params : dict
        flow-specific parameters, including:

        * "network" (str): name of the network that was used when generating
          the emission file. Must be one of the network names mentioned in
          ACCEPTABLE_NETWORKS,
        * "net_params" (flow.core.params.NetParams): network-specific
          parameters. This is used to collect the lengths of various network
          links.

    Returns
    -------
    pd.DataFrame
    """
    # Read trajectory csv into pandas dataframe
    df = pd.read_csv(fp)

    # Convert column names for backwards compatibility using emissions csv
    column_conversions = {
        'time': 'time_step',
        'lane_number': 'lane_id',
    }
    df = df.rename(columns=column_conversions)
    if 'distance' not in df.columns:
        df['distance'] = _get_abs_pos(df, params)

    # Compute line segment ends by shifting dataframe by 1 row
    df[['next_pos', 'next_time']] = df.groupby('id')[['distance', 'time_step']].shift(-1)

    # Remove nans from data
    df = df[df['next_time'].notna()]

    return df


def get_time_space_data(data, params):
    r"""Compute the unique inflows and subsequent outflow statistics.

    Parameters
    ----------
    data : pd.DataFrame
        cleaned dataframe of the trajectory data
    params : dict
        flow-specific parameters, including:

        * "network" (str): name of the network that was used when generating
          the emission file. Must be one of the network names mentioned in
          ACCEPTABLE_NETWORKS,
        * "net_params" (flow.core.params.NetParams): network-specific
          parameters. This is used to collect the lengths of various network
          links.

    Returns
    -------
    ndarray (or dict < str, np.ndarray >)
        3d array (n_segments x 2 x 2) containing segments to be plotted.
        every inner 2d array is comprised of two 1d arrays representing
        [start time, start distance] and [end time, end distance] pairs.

        in the case of I210, the nested arrays are wrapped into a dict,
        keyed on the lane number, so that each lane can be plotted
        separately.

    Raises
    ------
    AssertionError
        if the specified network is not supported by this method
    """
    # check that the network is appropriate
    assert params['network'] in ACCEPTABLE_NETWORKS, \
        'Network must be one of: ' + ', '.join([network.__name__ for network in ACCEPTABLE_NETWORKS])

    # switcher used to compute the positions based on the type of network
    switcher = {
        RingNetwork: _ring_road,
        MergeNetwork: _merge,
        FigureEightNetwork: _figure_eight,
        I210SubNetwork: _i210_subnetwork,
        HighwayNetwork: _highway,
    }

    # Get the function from switcher dictionary
    func = switcher[params['network']]

    # Execute the function
    segs, data = func(data)

    return segs, data


def _merge(data):
    r"""Generate position and speed data for the merge.

    This only include vehicles on the main highway, and not on the adjacent
    on-ramp.

    Parameters
    ----------
    data : pd.DataFrame
        cleaned dataframe of the trajectory data

    Returns
    -------
    ndarray
        3d array (n_segments x 2 x 2) containing segments to be plotted.
        every inner 2d array is comprised of two 1d arrays representing
        [start time, start distance] and [end time, end distance] pairs.
    pd.DataFrame
        modified trajectory dataframe
    """
    # Omit ghost edges
    keep_edges = {'inflow_merge', 'bottom', ':bottom_0'}
    data = data[data['edge_id'].isin(keep_edges)]

    segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))

    return segs, data


def _highway(data):
    r"""Generate time and position data for the highway.

    We generate plots for all lanes, so the segments are wrapped in
    a dictionary.

    Parameters
    ----------
    data : pd.DataFrame
        cleaned dataframe of the trajectory data

    Returns
    -------
    ndarray
        3d array (n_segments x 2 x 2) containing segments to be plotted.
        every inner 2d array is comprised of two 1d arrays representing
        [start time, start distance] and [end time, end distance] pairs.
    pd.DataFrame
        modified trajectory dataframe
    """
    data.loc[:, :] = data[(data['distance'] > 500)]
    data.loc[:, :] = data[(data['distance'] < 2300)]
    segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))

    return segs, data


def _ring_road(data):
    r"""Generate position and speed data for the ring road.

    Vehicles that reach the top of the plot simply return to the bottom and
    continue.

    Parameters
    ----------
    data : pd.DataFrame
        cleaned dataframe of the trajectory data

    Returns
    -------
    ndarray
        3d array (n_segments x 2 x 2) containing segments to be plotted.
        every inner 2d array is comprised of two 1d arrays representing
        [start time, start distance] and [end time, end distance] pairs.
    pd.DataFrame
        unmodified trajectory dataframe
    """
    segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))

    return segs, data


def _i210_subnetwork(data):
    r"""Generate time and position data for the i210 subnetwork.

    We generate plots for all lanes, so the segments are wrapped in
    a dictionary.

    Parameters
    ----------
    data : pd.DataFrame
        cleaned dataframe of the trajectory data

    Returns
    -------
    dict < str, np.ndarray >
        dictionary of 3d array (n_segments x 2 x 2) containing segments
        to be plotted. the dictionary is keyed on lane numbers, with the
        values being the 3d array representing the segments. every inner
        2d array is comprised of two 1d arrays representing
        [start time, start distance] and [end time, end distance] pairs.
    pd.DataFrame
        modified trajectory dataframe
    """
    # Omit ghost edges
    omit_edges = {'ghost0', '119257908#3'}
    data.loc[:, :] = data[~data['edge_id'].isin(omit_edges)]

    # Reset lane numbers that are offset by ramp lanes
    offset_edges = set(data[data['lane_id'] == 5]['edge_id'].unique())
    data.loc[data['edge_id'].isin(offset_edges), 'lane_id'] -= 1

    segs = dict()
    for lane, df in data.groupby('lane_id'):
        segs[lane] = df[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(df), 2, 2))

    return segs, data


def _figure_eight(data):
    r"""Generate position and speed data for the figure eight.

    The vehicles traveling towards the intersection from one side will be
    plotted from the top downward, while the vehicles from the other side will
    be plotted from the bottom upward.

    Parameters
    ----------
    data : pd.DataFrame
        cleaned dataframe of the trajectory data

    Returns
    -------
    ndarray
        3d array (n_segments x 2 x 2) containing segments to be plotted.
        every inner 2d array is comprised of two 1d arrays representing
        [start time, start distance] and [end time, end distance] pairs.
    pd.DataFrame
        unmodified trajectory dataframe
    """
    segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))

    return segs, data


def _get_abs_pos(df, params):
    """Compute the absolute positions from edges and relative positions.

    This is the variable we will ultimately use to plot individual vehicles.

    Parameters
    ----------
    df : pd.DataFrame
        dataframe of trajectory data
    params : dict
        flow-specific parameters

    Returns
    -------
    pd.Series
        the absolute positive for every sample
    """
    if params['network'] == MergeNetwork:
        inflow_edge_len = 100
        premerge = params['net'].additional_params['pre_merge_length']
        postmerge = params['net'].additional_params['post_merge_length']

        # generate edge starts
        edgestarts = {
            'inflow_highway': 0,
            'left': inflow_edge_len + 0.1,
            'center': inflow_edge_len + premerge + 22.6,
            'inflow_merge': inflow_edge_len + premerge + postmerge + 22.6,
            'bottom': 2 * inflow_edge_len + premerge + postmerge + 22.7,
            ':left_0': inflow_edge_len,
            ':center_0': inflow_edge_len + premerge + 0.1,
            ':center_1': inflow_edge_len + premerge + 0.1,
            ':bottom_0': 2 * inflow_edge_len + premerge + postmerge + 22.6
        }
    elif params['network'] == RingNetwork:
        ring_length = params['net'].additional_params["length"]
        junction_length = 0.1  # length of inter-edge junctions

        edgestarts = {
            "bottom": 0,
            ":right_0": 0.25 * ring_length,
            "right": 0.25 * ring_length + junction_length,
            ":top_0": 0.5 * ring_length + junction_length,
            "top": 0.5 * ring_length + 2 * junction_length,
            ":left_0": 0.75 * ring_length + 2 * junction_length,
            "left": 0.75 * ring_length + 3 * junction_length,
            ":bottom_0": ring_length + 3 * junction_length
        }
    elif params['network'] == FigureEightNetwork:
        net_params = params['net']
        ring_radius = net_params.additional_params['radius_ring']
        ring_edgelen = ring_radius * np.pi / 2.
        intersection = 2 * ring_radius
        junction = 2.9 + 3.3 * net_params.additional_params['lanes']
        inner = 0.28

        # generate edge starts
        edgestarts = {
            'bottom': inner,
            'top': intersection / 2 + junction + inner,
            'upper_ring': intersection + junction + 2 * inner,
            'right': intersection + 3 * ring_edgelen + junction + 3 * inner,
            'left': 1.5 * intersection + 3 * ring_edgelen + 2 * junction + 3 * inner,
            'lower_ring': 2 * intersection + 3 * ring_edgelen + 2 * junction + 4 * inner,
            ':bottom_0': 0,
            ':center_1': intersection / 2 + inner,
            ':top_0': intersection + junction + inner,
            ':right_0': intersection + 3 * ring_edgelen + junction + 2 * inner,
            ':center_0': 1.5 * intersection + 3 * ring_edgelen + junction + 3 * inner,
            ':left_0': 2 * intersection + 3 * ring_edgelen + 2 * junction + 3 * inner,
            # for aimsun
            'bottom_to_top': intersection / 2 + inner,
            'right_to_left': junction + 3 * inner,
        }
    elif params['network'] == HighwayNetwork:
        return df['x']
    elif params['network'] == I210SubNetwork:
        edgestarts = {
            '119257914': -5.0999999999995795,
            '119257908#0': 56.49000000018306,
            ':300944379_0': 56.18000000000016,
            ':300944436_0': 753.4599999999871,
            '119257908#1-AddedOnRampEdge': 756.3299999991157,
            ':119257908#1-AddedOnRampNode_0': 853.530000000022,
            '119257908#1': 856.7699999997207,
            ':119257908#1-AddedOffRampNode_0': 1096.4499999999707,
            '119257908#1-AddedOffRampEdge': 1099.6899999995558,
            ':1686591010_1': 1198.1899999999541,
            '119257908#2': 1203.6499999994803,
            ':1842086610_1': 1780.2599999999056,
            '119257908#3': 1784.7899999996537,
        }
    else:
        edgestarts = defaultdict(float)

    ret = df.apply(lambda x: x['relative_position'] + edgestarts[x['edge_id']], axis=1)

    if params['network'] == FigureEightNetwork:
        # reorganize data for space-time plot
        figure_eight_len = 6 * ring_edgelen + 2 * intersection + 2 * junction + 10 * inner
        intersection_loc = [edgestarts[':center_1'] + intersection / 2,
                            edgestarts[':center_0'] + intersection / 2]
        ret.loc[ret < intersection_loc[0]] += figure_eight_len
        ret.loc[(ret > intersection_loc[0]) & (ret < intersection_loc[1])] += -intersection_loc[1]
        ret.loc[ret > intersection_loc[1]] = \
            - ret.loc[ret > intersection_loc[1]] + figure_eight_len + intersection_loc[0]
    return ret


def plot_tsd(ax, df, segs, args, lane=None):
    """Plot the time-space diagram.

    Take the pre-processed segments and other meta-data, then plot all the line segments.

    Parameters
    ----------
    ax : matplotlib.axes.Axes
        figure axes that will be plotted on
    df : pd.DataFrame
        data used for axes bounds and speed coloring
    segs : list of list of lists
        line segments to be plotted, where each segment is a list of two [x,y] pairs
    args : dict
        parsed arguments
    lane : int, optional
        lane number to be shown in plot title

    Returns
    -------
    None
    """
    norm = plt.Normalize(args.min_speed, args.max_speed)

    xmin = max(df['time_step'].min(), args.start)
    xmax = min(df['time_step'].max(), args.stop)
    xbuffer = (xmax - xmin) * 0.025  # 2.5% of range
    ymin, ymax = df['distance'].min(), df['distance'].max()
    ybuffer = (ymax - ymin) * 0.025  # 2.5% of range

    ax.set_xlim(xmin - xbuffer, xmax + xbuffer)
    ax.set_ylim(ymin - ybuffer, ymax + ybuffer)

    lc = LineCollection(segs, cmap=my_cmap, norm=norm)
    lc.set_array(df['speed'].values)
    lc.set_linewidth(1)
    ax.add_collection(lc)
    ax.autoscale()

    if lane:
        ax.set_title('Time-Space Diagram: Lane {}'.format(lane), fontsize=25)
    else:
        ax.set_title('Time-Space Diagram', fontsize=25)
    ax.set_ylabel('Position (m)', fontsize=20)
    ax.set_xlabel('Time (s)', fontsize=20)
    plt.xticks(fontsize=18)
    plt.yticks(fontsize=18)

    cbar = plt.colorbar(lc, ax=ax, norm=norm)
    cbar.set_label('Velocity (m/s)', fontsize=20)
    cbar.ax.tick_params(labelsize=18)


if __name__ == '__main__':
    # create the parser
    parser = argparse.ArgumentParser(
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description='[Flow] Generates time space diagrams for flow networks.',
        epilog='python time_space_diagram.py </path/to/emission>.csv '
               '</path/to/flow_params>.json')

    # required arguments
    parser.add_argument('trajectory_path', type=str,
                        help='path to the Flow trajectory csv file.')
    parser.add_argument('flow_params', type=str,
                        help='path to the flow_params json file.')

    # optional arguments
    parser.add_argument('--steps', type=int, default=1,
                        help='rate at which steps are plotted.')
    parser.add_argument('--title', type=str, default='Time Space Diagram',
                        help='rate at which steps are plotted.')
    parser.add_argument('--max_speed', type=int, default=8,
                        help='The maximum speed in the color range.')
    parser.add_argument('--min_speed', type=int, default=0,
                        help='The minimum speed in the color range.')
    parser.add_argument('--start', type=float, default=0,
                        help='initial time (in sec) in the plot.')
    parser.add_argument('--stop', type=float, default=float('inf'),
                        help='final time (in sec) in the plot.')

    args = parser.parse_args()

    # flow_params is imported as a dictionary
    if '.json' in args.flow_params:
        flow_params = get_flow_params(args.flow_params)
    else:
        module = __import__("examples.exp_configs.non_rl", fromlist=[args.flow_params])
        flow_params = getattr(module, args.flow_params).flow_params

    # some plotting parameters
    cdict = {
        'red': ((0, 0, 0), (0.2, 1, 1), (0.6, 1, 1), (1, 0, 0)),
        'green': ((0, 0, 0), (0.2, 0, 0), (0.6, 1, 1), (1, 1, 1)),
        'blue': ((0, 0, 0), (0.2, 0, 0), (0.6, 0, 0), (1, 0, 0))
    }
    my_cmap = colors.LinearSegmentedColormap('my_colormap', cdict, 1024)

    # Read trajectory csv into pandas dataframe
    traj_df = import_data_from_trajectory(args.trajectory_path, flow_params)

    # Convert df data into segments for plotting
    segs, traj_df = get_time_space_data(traj_df, flow_params)

    if flow_params['network'] == I210SubNetwork:
        nlanes = traj_df['lane_id'].nunique()
        fig = plt.figure(figsize=(16, 9*nlanes))

        for lane, df in traj_df.groupby('lane_id'):
            ax = plt.subplot(nlanes, 1, lane+1)

            plot_tsd(ax, df, segs[lane], args, lane)
    else:
        # perform plotting operation
        fig = plt.figure(figsize=(16, 9))
        ax = plt.axes()

        plot_tsd(ax, traj_df, segs, args)

    ###########################################################################
    #                       Note: For MergeNetwork only                       #
    if flow_params['network'] == 'MergeNetwork':                              #
        plt.plot([df['time_step'].min(), df['time_step'].max()],
                 [0, 0], linewidth=3, color="white")        #
        plt.plot([df['time_step'].min(), df['time_step'].max()],
                 [-0.1, -0.1], linewidth=3, color="white")     #
    ###########################################################################

    plt.show()

1	"""Generate a time space diagram for some networks.
2
3	This method accepts as input a csv file containing the sumo-formatted emission
4	file, and then uses this data to generate a time-space diagram, with the x-axis
5	being the time (in seconds), the y-axis being the position of a vehicle, and
6	color representing the speed of te vehicles.
7
8	If the number of simulation steps is too dense, you can plot every nth step in
9	the plot by setting the input `--steps=n`.
10
11	Note: This script assumes that the provided network has only one lane on the
12	each edge, or one lane on the main highway in the case of MergeNetwork.
13
14	Usage
15	-----
16	::
17	python time_space_diagram.py </path/to/emission>.csv </path/to/params>.json
18	"""
19	from flow.utils.rllib import get_flow_params	1✔
20	from flow.networks import RingNetwork, FigureEightNetwork, MergeNetwork, I210SubNetwork, HighwayNetwork	1✔
21
22	import argparse	1✔
23	from collections import defaultdict	1✔
24	try:	1✔
25	from matplotlib import pyplot as plt	1✔
26	except ImportError:	×
27	import matplotlib	×
28	matplotlib.use('TkAgg')	×
29	from matplotlib import pyplot as plt	×
30	from matplotlib.collections import LineCollection	1✔
31	import matplotlib.colors as colors	1✔
32	import numpy as np	1✔
33	import pandas as pd	1✔
34
35
36	# networks that can be plotted by this method
37	ACCEPTABLE_NETWORKS = [	1✔
38	RingNetwork,
39	FigureEightNetwork,
40	MergeNetwork,
41	I210SubNetwork,
42	HighwayNetwork
43	]
44
45
46	def import_data_from_trajectory(fp, params=dict()):	1✔
47	r"""Import and preprocess data from the Flow trajectory (.csv) file.
48
49	Parameters
50	----------
51	fp : str
52	file path (for the .csv formatted file)
53	params : dict
54	flow-specific parameters, including:
55
56	* "network" (str): name of the network that was used when generating
57	the emission file. Must be one of the network names mentioned in
58	ACCEPTABLE_NETWORKS,
59	* "net_params" (flow.core.params.NetParams): network-specific
60	parameters. This is used to collect the lengths of various network
61	links.
62
63	Returns
64	-------
65	pd.DataFrame
66	"""
67	# Read trajectory csv into pandas dataframe
68	df = pd.read_csv(fp)	1✔
69
70	# Convert column names for backwards compatibility using emissions csv
71	column_conversions = {	1✔
72	'time': 'time_step',
73	'lane_number': 'lane_id',
74	}
75	df = df.rename(columns=column_conversions)	1✔
76	if 'distance' not in df.columns:	1✔
77	df['distance'] = _get_abs_pos(df, params)	1✔
78
79	# Compute line segment ends by shifting dataframe by 1 row
80	df[['next_pos', 'next_time']] = df.groupby('id')[['distance', 'time_step']].shift(-1)	1✔
81
82	# Remove nans from data
83	df = df[df['next_time'].notna()]	1✔
84
85	return df	1✔
86
87
88	def get_time_space_data(data, params):	1✔
89	r"""Compute the unique inflows and subsequent outflow statistics.
90
91	Parameters
92	----------
93	data : pd.DataFrame
94	cleaned dataframe of the trajectory data
95	params : dict
96	flow-specific parameters, including:
97
98	* "network" (str): name of the network that was used when generating
99	the emission file. Must be one of the network names mentioned in
100	ACCEPTABLE_NETWORKS,
101	* "net_params" (flow.core.params.NetParams): network-specific
102	parameters. This is used to collect the lengths of various network
103	links.
104
105	Returns
106	-------
107	ndarray (or dict < str, np.ndarray >)
108	3d array (n_segments x 2 x 2) containing segments to be plotted.
109	every inner 2d array is comprised of two 1d arrays representing
110	[start time, start distance] and [end time, end distance] pairs.
111
112	in the case of I210, the nested arrays are wrapped into a dict,
113	keyed on the lane number, so that each lane can be plotted
114	separately.
115
116	Raises
117	------
118	AssertionError
119	if the specified network is not supported by this method
120	"""
121	# check that the network is appropriate
122	assert params['network'] in ACCEPTABLE_NETWORKS, \	1✔
123	'Network must be one of: ' + ', '.join([network.__name__ for network in ACCEPTABLE_NETWORKS])
124
125	# switcher used to compute the positions based on the type of network
126	switcher = {	1✔
127	RingNetwork: _ring_road,
128	MergeNetwork: _merge,
129	FigureEightNetwork: _figure_eight,
130	I210SubNetwork: _i210_subnetwork,
131	HighwayNetwork: _highway,
132	}
133
134	# Get the function from switcher dictionary
135	func = switcher[params['network']]	1✔
136
137	# Execute the function
138	segs, data = func(data)	1✔
139
140	return segs, data	1✔
141
142
143	def _merge(data):	1✔
144	r"""Generate position and speed data for the merge.
145
146	This only include vehicles on the main highway, and not on the adjacent
147	on-ramp.
148
149	Parameters
150	----------
151	data : pd.DataFrame
152	cleaned dataframe of the trajectory data
153
154	Returns
155	-------
156	ndarray
157	3d array (n_segments x 2 x 2) containing segments to be plotted.
158	every inner 2d array is comprised of two 1d arrays representing
159	[start time, start distance] and [end time, end distance] pairs.
160	pd.DataFrame
161	modified trajectory dataframe
162	"""
163	# Omit ghost edges
164	keep_edges = {'inflow_merge', 'bottom', ':bottom_0'}	1✔
165	data = data[data['edge_id'].isin(keep_edges)]	1✔
166
167	segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))	1✔
168
169	return segs, data	1✔
170
171
172	def _highway(data):	1✔
173	r"""Generate time and position data for the highway.
174
175	We generate plots for all lanes, so the segments are wrapped in
176	a dictionary.
177
178	Parameters
179	----------
180	data : pd.DataFrame
181	cleaned dataframe of the trajectory data
182
183	Returns
184	-------
185	ndarray
186	3d array (n_segments x 2 x 2) containing segments to be plotted.
187	every inner 2d array is comprised of two 1d arrays representing
188	[start time, start distance] and [end time, end distance] pairs.
189	pd.DataFrame
190	modified trajectory dataframe
191	"""
192	data.loc[:, :] = data[(data['distance'] > 500)]	×
193	data.loc[:, :] = data[(data['distance'] < 2300)]	×
194	segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))	×
195
196	return segs, data	×
197
198
199	def _ring_road(data):	1✔
200	r"""Generate position and speed data for the ring road.
201
202	Vehicles that reach the top of the plot simply return to the bottom and
203	continue.
204
205	Parameters
206	----------
207	data : pd.DataFrame
208	cleaned dataframe of the trajectory data
209
210	Returns
211	-------
212	ndarray
213	3d array (n_segments x 2 x 2) containing segments to be plotted.
214	every inner 2d array is comprised of two 1d arrays representing
215	[start time, start distance] and [end time, end distance] pairs.
216	pd.DataFrame
217	unmodified trajectory dataframe
218	"""
219	segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))	1✔
220
221	return segs, data	1✔
222
223
224	def _i210_subnetwork(data):	1✔
225	r"""Generate time and position data for the i210 subnetwork.
226
227	We generate plots for all lanes, so the segments are wrapped in
228	a dictionary.
229
230	Parameters
231	----------
232	data : pd.DataFrame
233	cleaned dataframe of the trajectory data
234
235	Returns
236	-------
237	dict < str, np.ndarray >
238	dictionary of 3d array (n_segments x 2 x 2) containing segments
239	to be plotted. the dictionary is keyed on lane numbers, with the
240	values being the 3d array representing the segments. every inner
241	2d array is comprised of two 1d arrays representing
242	[start time, start distance] and [end time, end distance] pairs.
243	pd.DataFrame
244	modified trajectory dataframe
245	"""
246	# Omit ghost edges
247	omit_edges = {'ghost0', '119257908#3'}	1✔
248	data.loc[:, :] = data[~data['edge_id'].isin(omit_edges)]	1✔
249
250	# Reset lane numbers that are offset by ramp lanes
251	offset_edges = set(data[data['lane_id'] == 5]['edge_id'].unique())	1✔
252	data.loc[data['edge_id'].isin(offset_edges), 'lane_id'] -= 1	1✔
253
254	segs = dict()	1✔
255	for lane, df in data.groupby('lane_id'):	1✔
256	segs[lane] = df[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(df), 2, 2))	1✔
257
258	return segs, data	1✔
259
260
261	def _figure_eight(data):	1✔
262	r"""Generate position and speed data for the figure eight.
263
264	The vehicles traveling towards the intersection from one side will be
265	plotted from the top downward, while the vehicles from the other side will
266	be plotted from the bottom upward.
267
268	Parameters
269	----------
270	data : pd.DataFrame
271	cleaned dataframe of the trajectory data
272
273	Returns
274	-------
275	ndarray
276	3d array (n_segments x 2 x 2) containing segments to be plotted.
277	every inner 2d array is comprised of two 1d arrays representing
278	[start time, start distance] and [end time, end distance] pairs.
279	pd.DataFrame
280	unmodified trajectory dataframe
281	"""
282	segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))	1✔
283
284	return segs, data	1✔
285
286
287	def _get_abs_pos(df, params):	1✔
288	"""Compute the absolute positions from edges and relative positions.
289
290	This is the variable we will ultimately use to plot individual vehicles.
291
292	Parameters
293	----------
294	df : pd.DataFrame
295	dataframe of trajectory data
296	params : dict
297	flow-specific parameters
298
299	Returns
300	-------
301	pd.Series
302	the absolute positive for every sample
303	"""
304	if params['network'] == MergeNetwork:	1✔
305	inflow_edge_len = 100	1✔
306	premerge = params['net'].additional_params['pre_merge_length']	1✔
307	postmerge = params['net'].additional_params['post_merge_length']	1✔
308
309	# generate edge starts
310	edgestarts = {	1✔
311	'inflow_highway': 0,
312	'left': inflow_edge_len + 0.1,
313	'center': inflow_edge_len + premerge + 22.6,
314	'inflow_merge': inflow_edge_len + premerge + postmerge + 22.6,
315	'bottom': 2 * inflow_edge_len + premerge + postmerge + 22.7,
316	':left_0': inflow_edge_len,
317	':center_0': inflow_edge_len + premerge + 0.1,
318	':center_1': inflow_edge_len + premerge + 0.1,
319	':bottom_0': 2 * inflow_edge_len + premerge + postmerge + 22.6
320	}
321	elif params['network'] == RingNetwork:	1✔
322	ring_length = params['net'].additional_params["length"]	1✔
323	junction_length = 0.1 # length of inter-edge junctions	1✔
324
325	edgestarts = {	1✔
326	"bottom": 0,
327	":right_0": 0.25 * ring_length,
328	"right": 0.25 * ring_length + junction_length,
329	":top_0": 0.5 * ring_length + junction_length,
330	"top": 0.5 * ring_length + 2 * junction_length,
331	":left_0": 0.75 * ring_length + 2 * junction_length,
332	"left": 0.75 * ring_length + 3 * junction_length,
333	":bottom_0": ring_length + 3 * junction_length
334	}
335	elif params['network'] == FigureEightNetwork:	1✔
336	net_params = params['net']	1✔
337	ring_radius = net_params.additional_params['radius_ring']	1✔
338	ring_edgelen = ring_radius * np.pi / 2.	1✔
339	intersection = 2 * ring_radius	1✔
340	junction = 2.9 + 3.3 * net_params.additional_params['lanes']	1✔
341	inner = 0.28	1✔
342
343	# generate edge starts
344	edgestarts = {	1✔
345	'bottom': inner,
346	'top': intersection / 2 + junction + inner,
347	'upper_ring': intersection + junction + 2 * inner,
348	'right': intersection + 3 * ring_edgelen + junction + 3 * inner,
349	'left': 1.5 * intersection + 3 * ring_edgelen + 2 * junction + 3 * inner,
350	'lower_ring': 2 * intersection + 3 * ring_edgelen + 2 * junction + 4 * inner,
351	':bottom_0': 0,
352	':center_1': intersection / 2 + inner,
353	':top_0': intersection + junction + inner,
354	':right_0': intersection + 3 * ring_edgelen + junction + 2 * inner,
355	':center_0': 1.5 * intersection + 3 * ring_edgelen + junction + 3 * inner,
356	':left_0': 2 * intersection + 3 * ring_edgelen + 2 * junction + 3 * inner,
357	# for aimsun
358	'bottom_to_top': intersection / 2 + inner,
359	'right_to_left': junction + 3 * inner,
360	}
361	elif params['network'] == HighwayNetwork:	×
362	return df['x']	×
363	elif params['network'] == I210SubNetwork:	×
364	edgestarts = {	×
365	'119257914': -5.0999999999995795,
366	'119257908#0': 56.49000000018306,
367	':300944379_0': 56.18000000000016,
368	':300944436_0': 753.4599999999871,
369	'119257908#1-AddedOnRampEdge': 756.3299999991157,
370	':119257908#1-AddedOnRampNode_0': 853.530000000022,
371	'119257908#1': 856.7699999997207,
372	':119257908#1-AddedOffRampNode_0': 1096.4499999999707,
373	'119257908#1-AddedOffRampEdge': 1099.6899999995558,
374	':1686591010_1': 1198.1899999999541,
375	'119257908#2': 1203.6499999994803,
376	':1842086610_1': 1780.2599999999056,
377	'119257908#3': 1784.7899999996537,
378	}
379	else:
380	edgestarts = defaultdict(float)	×
381
382	ret = df.apply(lambda x: x['relative_position'] + edgestarts[x['edge_id']], axis=1)	1✔
383
384	if params['network'] == FigureEightNetwork:	1✔
385	# reorganize data for space-time plot
386	figure_eight_len = 6 * ring_edgelen + 2 * intersection + 2 * junction + 10 * inner	1✔
387	intersection_loc = [edgestarts[':center_1'] + intersection / 2,	1✔
388	edgestarts[':center_0'] + intersection / 2]
389	ret.loc[ret < intersection_loc[0]] += figure_eight_len	1✔
390	ret.loc[(ret > intersection_loc[0]) & (ret < intersection_loc[1])] += -intersection_loc[1]	1✔
391	ret.loc[ret > intersection_loc[1]] = \	1✔
392	- ret.loc[ret > intersection_loc[1]] + figure_eight_len + intersection_loc[0]
393	return ret	1✔
394
395
396	def plot_tsd(ax, df, segs, args, lane=None):	1✔
397	"""Plot the time-space diagram.
398
399	Take the pre-processed segments and other meta-data, then plot all the line segments.
400
401	Parameters
402	----------
403	ax : matplotlib.axes.Axes
404	figure axes that will be plotted on
405	df : pd.DataFrame
406	data used for axes bounds and speed coloring
407	segs : list of list of lists
408	line segments to be plotted, where each segment is a list of two [x,y] pairs
409	args : dict
410	parsed arguments
411	lane : int, optional
412	lane number to be shown in plot title
413
414	Returns
415	-------
416	None
417	"""
418	norm = plt.Normalize(args.min_speed, args.max_speed)	×
419
420	xmin = max(df['time_step'].min(), args.start)	×
421	xmax = min(df['time_step'].max(), args.stop)	×
422	xbuffer = (xmax - xmin) * 0.025 # 2.5% of range	×
423	ymin, ymax = df['distance'].min(), df['distance'].max()	×
424	ybuffer = (ymax - ymin) * 0.025 # 2.5% of range	×
425
426	ax.set_xlim(xmin - xbuffer, xmax + xbuffer)	×
427	ax.set_ylim(ymin - ybuffer, ymax + ybuffer)	×
428
429	lc = LineCollection(segs, cmap=my_cmap, norm=norm)	×
430	lc.set_array(df['speed'].values)	×
431	lc.set_linewidth(1)	×
432	ax.add_collection(lc)	×
433	ax.autoscale()	×
434
435	if lane:	×
436	ax.set_title('Time-Space Diagram: Lane {}'.format(lane), fontsize=25)	×
437	else:
438	ax.set_title('Time-Space Diagram', fontsize=25)	×
439	ax.set_ylabel('Position (m)', fontsize=20)	×
440	ax.set_xlabel('Time (s)', fontsize=20)	×
441	plt.xticks(fontsize=18)	×
442	plt.yticks(fontsize=18)	×
443
444	cbar = plt.colorbar(lc, ax=ax, norm=norm)	×
445	cbar.set_label('Velocity (m/s)', fontsize=20)	×
446	cbar.ax.tick_params(labelsize=18)	×
447
448
449	if __name__ == '__main__':
450	# create the parser
451	parser = argparse.ArgumentParser(
452	formatter_class=argparse.RawDescriptionHelpFormatter,
453	description='[Flow] Generates time space diagrams for flow networks.',
454	epilog='python time_space_diagram.py </path/to/emission>.csv '
455	'</path/to/flow_params>.json')
456
457	# required arguments
458	parser.add_argument('trajectory_path', type=str,
459	help='path to the Flow trajectory csv file.')
460	parser.add_argument('flow_params', type=str,
461	help='path to the flow_params json file.')
462
463	# optional arguments
464	parser.add_argument('--steps', type=int, default=1,
465	help='rate at which steps are plotted.')
466	parser.add_argument('--title', type=str, default='Time Space Diagram',
467	help='rate at which steps are plotted.')
468	parser.add_argument('--max_speed', type=int, default=8,
469	help='The maximum speed in the color range.')
470	parser.add_argument('--min_speed', type=int, default=0,
471	help='The minimum speed in the color range.')
472	parser.add_argument('--start', type=float, default=0,
473	help='initial time (in sec) in the plot.')
474	parser.add_argument('--stop', type=float, default=float('inf'),
475	help='final time (in sec) in the plot.')
476
477	args = parser.parse_args()
478
479	# flow_params is imported as a dictionary
480	if '.json' in args.flow_params:
481	flow_params = get_flow_params(args.flow_params)
482	else:
483	module = __import__("examples.exp_configs.non_rl", fromlist=[args.flow_params])
484	flow_params = getattr(module, args.flow_params).flow_params
485
486	# some plotting parameters
487	cdict = {
488	'red': ((0, 0, 0), (0.2, 1, 1), (0.6, 1, 1), (1, 0, 0)),
489	'green': ((0, 0, 0), (0.2, 0, 0), (0.6, 1, 1), (1, 1, 1)),
490	'blue': ((0, 0, 0), (0.2, 0, 0), (0.6, 0, 0), (1, 0, 0))
491	}
492	my_cmap = colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
493
494	# Read trajectory csv into pandas dataframe
495	traj_df = import_data_from_trajectory(args.trajectory_path, flow_params)
496
497	# Convert df data into segments for plotting
498	segs, traj_df = get_time_space_data(traj_df, flow_params)
499
500	if flow_params['network'] == I210SubNetwork:
501	nlanes = traj_df['lane_id'].nunique()
502	fig = plt.figure(figsize=(16, 9*nlanes))
503
504	for lane, df in traj_df.groupby('lane_id'):
505	ax = plt.subplot(nlanes, 1, lane+1)
506
507	plot_tsd(ax, df, segs[lane], args, lane)
508	else:
509	# perform plotting operation
510	fig = plt.figure(figsize=(16, 9))
511	ax = plt.axes()
512
513	plot_tsd(ax, traj_df, segs, args)
514
515	###########################################################################
516	# Note: For MergeNetwork only #
517	if flow_params['network'] == 'MergeNetwork': #
518	plt.plot([df['time_step'].min(), df['time_step'].max()],
519	[0, 0], linewidth=3, color="white") #
520	plt.plot([df['time_step'].min(), df['time_step'].max()],
521	[-0.1, -0.1], linewidth=3, color="white") #
522	###########################################################################
523
524	plt.show()

flow-project / flow / 6687

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous