6758

pending completion

Build # 6758

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/<a class="double-link" href="https://git"><a class=hub.com/flow-project/flow/commit/<a class="double-link" href="https://git"><a class=hub.com/flow-project/flow/commit/<a class="double-link" href="https://git"><a class=hub.com/flow-project/flow/commit/32c24497163ae75a813ae003d40d7964f2d9df1c">32c244971">&lt;a href=&quot;https://github.com/flow-project/flow/commit/</a><a class="double-link" href="https://github.com/flow-project/flow/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/flow-project/flow/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/flow-project/flow/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/flow-project/flow/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/flow-project/flow/commit/32c24497163ae75a813ae003d40d7964f2d9df1c">32c244971</a><a href="https://github.com/flow-project/flow/commit/32c24497163ae75a813ae003d40d7964f2d9df1c">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/flow-project/flow/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/flow-project/flow/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/flow-project/flow/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/flow-project/flow/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/flow-project/flow/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/flow-project/flow/commit/32c24497163ae75a813ae003d40d7964f2d9df1c&quot;&gt;32c244971&lt;/a&gt;&lt;a href=&quot;https://github.com/flow-project/flow/commit/32c24497163ae75a813ae003d40d7964f2d9df1c&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/flow-project/flow/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/flow-project/flow/commit/&amp;amp;lt;a ... (continued)

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

Run Details

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

9438 of 10633 relevant lines covered (88.76%)

0.89 hits per line

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

59.84

/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, PatchCollection
from matplotlib.patches import Rectangle
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 time and position 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
    """
    segs = data[['time_step', 'distance', 'next_time', 'next_pos']].values.reshape((len(data), 2, 2))

    return segs, data


def _ring_road(data):
    r"""Generate time and position 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
    """
    # 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 time and position 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, ghost_edges=None, ghost_bounds=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
    ghost_edges : list or set of str
        ghost edge names to be greyed out, default None
    ghost_bounds : tuple
        lower and upper bounds of domain, excluding ghost edges, default None

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

    xmin, xmax = df['time_step'].min(), df['time_step'].max()
    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()

    rects = []
    if ghost_edges:
        y_domain_min = df[~df['edge_id'].isin(ghost_edges)]['distance'].min()
        y_domain_max = df[~df['edge_id'].isin(ghost_edges)]['distance'].max()
        rects.append(Rectangle((xmin, y_domain_min), args.start - xmin, y_domain_max - y_domain_min))
        rects.append(Rectangle((xmin, ymin), xmax - xmin, y_domain_min - ymin))
        rects.append(Rectangle((xmin, y_domain_max), xmax - xmin, ymax - y_domain_max))
    elif ghost_bounds:
        rects.append(Rectangle((xmin, ghost_bounds[0]), args.start - xmin, ghost_bounds[1] - ghost_bounds[0]))
        rects.append(Rectangle((xmin, ymin), xmax - xmin, ghost_bounds[0] - ymin))
        rects.append(Rectangle((xmin, ghost_bounds[1]), xmax - xmin, ymax - ghost_bounds[1]))
    else:
        rects.append(Rectangle((xmin, ymin), args.start - xmin, ymax - ymin))

    if rects:
        pc = PatchCollection(rects, facecolor='grey', alpha=0.5, edgecolor=None)
        pc.set_zorder(20)
        ax.add_collection(pc)

    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.')

    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, int(lane+1), ghost_edges={'ghost0', '119257908#3'})
        plt.tight_layout()
    else:
        # perform plotting operation
        fig = plt.figure(figsize=(16, 9))
        ax = plt.axes()

        if flow_params['network'] == HighwayNetwork:
            plot_tsd(ax, traj_df, segs, args, ghost_bounds=(500, 2300))
        else:
            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")     #
    ###########################################################################

    outfile = args.trajectory_path.replace('csv', 'png')
    plt.savefig(outfile)

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

flow-project / flow / 6758

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