def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
optParser.add_option("-w", "--width", dest="width",
type="float", default=20, help="Defines the width of the dots")
optParser.add_option("-c", "--color", dest="color",
default='r', help="Defines the dot color")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=1, help="Defines the edge width")
optParser.add_option("--edge-color", dest="defaultColor",
default='k', help="Defines the edge color")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net is None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
tlsn = {}
for tid in net._id2tls:
t = net._id2tls[tid]
tlsn[tid] = set()
for c in t._connections:
n = c[0].getEdge().getToNode()
tlsn[tid].add(n)
tlspX = []
tlspY = []
for tid in tlsn:
x = 0
y = 0
n = 0
for node in tlsn[tid]:
x += node._coord[0]
y += node._coord[1]
n = n + 1
x = x / n
y = y / n
tlspX.append(x)
tlspY.append(y)
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, {}, {}, options)
plt.plot(tlspX, tlspY, options.color, linestyle='.',
marker='o', markersize=options.width)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
optParser.add_option("-w", "--width", dest="width",
type="float", default=20, help="Defines the width of the dots")
optParser.add_option("-c", "--color", dest="color",
default='r', help="Defines the dot color")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=1, help="Defines the edge width")
optParser.add_option("--edge-color", dest="defaultColor",
default='k', help="Defines the edge color")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print "Error: a network to load must be given."
return 1
if options.verbose:
print "Reading network from '%s'" % options.net
net = sumolib.net.readNet(options.net)
tlsn = {}
for tid in net._id2tls:
t = net._id2tls[tid]
tlsn[tid] = set()
for c in t._connections:
n = c[0].getEdge().getToNode()
tlsn[tid].add(n)
tlspX = []
tlspY = []
for tid in tlsn:
x = 0
y = 0
n = 0
for node in tlsn[tid]:
x += node._coord[0]
y += node._coord[1]
n = n + 1
x = x / n
y = y / n
tlspX.append(x)
tlspY.append(y)
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, {}, {}, options)
plt.plot(tlspX, tlspY, options.color, linestyle='.',
marker='o', markersize=options.width)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i", "--input", dest="input", metavar="FILE",
help="Defines the csv file to use as input")
optParser.add_option("-p", "--percentage", dest="percentage", action="store_true",
default=False, help="Interprets read measures as percentages")
optParser.add_option("-r", "--revert", dest="revert", action="store_true",
default=False, help="Reverts the order of read values")
optParser.add_option("--no-labels", dest="nolabels", action="store_true",
default=False, help="Does not plot the labels")
optParser.add_option("--shadow", dest="shadow", action="store_true",
default=False, help="Puts a shadow below the circle")
optParser.add_option("--startangle", dest="startangle",
type="float", default=0, help="Sets the start angle")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.input == None:
print("Error: at least one csv file must be given")
sys.exit(1)
fd = open(options.input)
labels = []
vals = []
total = 0
for line in fd:
v = line.strip().split(";")
if len(v) < 2:
continue
labels.append(v[0].replace("\\n", "\n"))
vals.append(float(v[1]))
total += float(v[1])
if options.revert:
labels.reverse()
vals.reverse()
colors = []
for i, e in enumerate(labels):
colors.append(helpers.getColor(options, i, len(labels)))
fig, ax = helpers.openFigure(options)
if options.nolabels:
labels = None
shadow = options.shadow
if options.percentage:
autopct = lambda p: '{:.1f}%'.format(p)
else:
autopct = lambda p: '{:.0f}'.format(p * total / 100)
patches, texts, autotexts = plt.pie(
vals, labels=labels, autopct=autopct, colors=colors, shadow=shadow, startangle=options.startangle)
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i", "--input", dest="input", metavar="FILE",
help="Defines the csv file to use as input")
optParser.add_option("-p", "--percentage", dest="percentage", action="store_true",
default=False, help="Interprets read measures as percentages")
optParser.add_option("-r", "--revert", dest="revert", action="store_true",
default=False, help="Reverts the order of read values")
optParser.add_option("--no-labels", dest="nolabels", action="store_true",
default=False, help="Does not plot the labels")
optParser.add_option("--shadow", dest="shadow", action="store_true",
default=False, help="Puts a shadow below the circle")
optParser.add_option("--startangle", dest="startangle",
type="float", default=0, help="Sets the start angle")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.input == None:
print("Error: at least one csv file must be given")
sys.exit(1)
fd = open(options.input)
labels = []
vals = []
total = 0
for line in fd:
v = line.strip().split(";")
if len(v) < 2:
continue
labels.append(v[0].replace("\\n", "\n"))
vals.append(float(v[1]))
total += float(v[1])
if options.revert:
labels.reverse()
vals.reverse()
colors = []
for i, e in enumerate(labels):
colors.append(helpers.getColor(options, i, len(labels)))
fig, ax = helpers.openFigure(options)
if options.nolabels:
labels = None
shadow = options.shadow
if options.percentage:
autopct = lambda p: '{:.1f}%'.format(p)
else:
autopct = lambda p: '{:.0f}'.format(p * total / 100)
patches, texts, autotexts = plt.pie(
vals, labels=labels, autopct=autopct, colors=colors, shadow=shadow, startangle=options.startangle)
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i",
"--input",
dest="input",
metavar="FILE",
help="Defines the input file to use")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
optParser.add_option("-c",
"--columns",
dest="columns",
default=None,
help="Defines which columns shall be plotted")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, _ = optParser.parse_args(args=args)
if options.input is None:
print("Error: an input file must be given")
sys.exit(1)
minV = 0
maxV = 0
if options.columns is not None:
options.columns = [int(i) for i in options.columns.split(",")]
nums = readValues(options.input, options.verbose, options.columns)
for f in nums:
maxV = max(maxV, len(nums[f]))
ts = range(minV, maxV + 1)
fig, ax = helpers.openFigure(options)
for i in nums:
v = nums[i]
ci = i
if options.columns is not None:
ci = options.columns.index(i)
c = helpers.getColor(options, ci, len(nums))
plt.plot(ts[0:len(v)],
v,
label=helpers.getLabel(str(i), ci, options),
color=c)
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option(
"-i",
"--summary-inputs",
dest="summary",
metavar="FILE",
help="Defines the summary-output files to use as input")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
optParser.add_option("-m",
"--measure",
dest="measure",
default="running",
help="Define which measure to plot")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.summary is None:
print("Error: at least one summary file must be given")
sys.exit(1)
minV = 0
maxV = 0
files = options.summary.split(",")
nums = readValues(files, options.verbose, options.measure)
times = readValues(files, options.verbose, "time")
for f in files:
maxV = max(maxV, len(nums[f]))
ts = range(minV, maxV + 1)
fig, ax = helpers.openFigure(options)
for i, f in enumerate(files):
v = sumolib.output.toList(nums[f], options.measure)
t = sumolib.output.toList(times[f], "time")
c = helpers.getColor(options, i, len(files))
l = helpers.getLabel(f, i, options)
plt.plot(t, v, label=l, color=c)
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i", "--selection", dest="selection", metavar="FILE",
help="Defines the selection to read")
optParser.add_option("--selected-width", dest="selectedWidth",
type="float", default=1, help="Defines the width of selected edges")
optParser.add_option("--color", "--selected-color", dest="selectedColor",
default='r', help="Defines the color of selected edges")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=.2, help="Defines the width of not selected edges")
optParser.add_option("--edge-color", dest="defaultColor",
default='#606060', help="Defines the color of not selected edges")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print("Error: a network to load must be given.")
return 1
if options.selection == None:
print("Error: a selection to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
selection = sumolib.files.selection.read(options.selection)
colors = {}
widths = {}
for e in selection["edge"]:
colors[e] = options.selectedColor
widths[e] = options.selectedWidth
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i", "--selection", dest="selection", metavar="FILE",
help="Defines the selection to read")
optParser.add_option("--selected-width", dest="selectedWidth",
type="float", default=1, help="Defines the width of selected edges")
optParser.add_option("--color", "--selected-color", dest="selectedColor",
default='r', help="Defines the color of selected edges")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=.2, help="Defines the width of not selected edges")
optParser.add_option("--edge-color", dest="defaultColor",
default='#606060', help="Defines the color of not selected edges")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print("Error: a network to load must be given.")
return 1
if options.selection == None:
print("Error: a selection to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
selection = sumolib.files.selection.read(options.selection)
colors = {}
widths = {}
for e in selection["edge"]:
colors[e] = options.selectedColor
widths[e] = options.selectedWidth
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option(
"-i",
"--summary-inputs",
dest="summary",
metavar="FILE",
help="Defines the summary-output files to use as input",
)
optParser.add_option(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing",
)
optParser.add_option("-m", "--measure", dest="measure", default="running", help="Define which measure to plot")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.summary == None:
print("Error: at least one summary file must be given")
sys.exit(1)
minV = 0
maxV = 0
files = options.summary.split(",")
nums = readValues(files, options.verbose, options.measure)
for f in files:
maxV = max(maxV, len(nums[f]))
ts = range(minV, maxV + 1)
fig, ax = helpers.openFigure(options)
for i, f in enumerate(files):
v = sumolib.output.toList(nums[f], options.measure)
c = helpers.getColor(options, i, len(files))
l = helpers.getLabel(f, i, options)
plt.plot(ts[0 : len(v)], v, label=l, color=c)
helpers.closeFigure(fig, ax, options)
def main():
args = []
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i", "--selection", dest="selection", metavar="FILE",
help="Defines the selection to read")
optParser.add_option("--selected-width", dest="selectedWidth",
type="float", default=1, help="Defines the width of selected edges")
optParser.add_option("--color", "--selected-color", dest="selectedColor",
default='r', help="Defines the color of selected edges")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=.2, help="Defines the width of not selected edges")
optParser.add_option("--edge-color", dest="defaultColor",
default='#606060', help="Defines the color of not selected edges")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
options, remaining_args = optParser.parse_args(args=args)
net = sumolib.net.readNet('../network/nyc.net.xml')
selections = []
color_list = ['r','g','b','c','m','y','b']
colors = {}
widths = {}
zone_path = '../network'
zone_files = [os.path.join(zone_path,f) for f in os.listdir(zone_path) if 'zone' in f]
print(zone_files)
for zone in zone_files:
selections.append(sumolib.files.selection.read(zone))
for i,selection in enumerate(selections):
for e in selection["edge"]:
colors[e] = color_list[i%7]
widths[e] = 0.5
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i", "--input", dest="input", metavar="FILE", help="Defines the input file to use")
optParser.add_option(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing",
)
optParser.add_option("-c", "--columns", dest="columns", default=None, help="Defines which columns shall be plotted")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.input == None:
print("Error: an input file must be given")
sys.exit(1)
minV = 0
maxV = 0
if options.columns != None:
options.columns = [int(i) for i in options.columns.split(",")]
nums = readValues(options.input, options.verbose, options.columns)
for f in nums:
maxV = max(maxV, len(nums[f]))
ts = range(minV, maxV + 1)
fig, ax = helpers.openFigure(options)
for i in nums:
v = nums[i]
ci = i
if options.columns != None:
ci = options.columns.index(i)
c = helpers.getColor(options, ci, len(nums))
l = helpers.getLabel(str(i), ci, options)
plt.plot(ts[0 : len(v)], v, label=l, color=c)
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option(
"-i",
"--summary-inputs",
dest="summary",
metavar="FILE",
help="Defines the summary-output files to use as input")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
optParser.add_option("-m",
"--measure",
dest="measure",
default="running",
help="Define which measure to plot")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, _ = optParser.parse_args(args=args)
if options.summary is None:
print("Error: at least one summary file must be given")
sys.exit(1)
files = options.summary.split(",")
fig, ax = helpers.openFigure(options)
for i, f in enumerate(files):
t = []
v = []
for time, val in sumolib.xml.parse_fast(f, "step",
("time", options.measure)):
t.append(sumolib.miscutils.parseTime(time))
v.append(float(val))
c = helpers.getColor(options, i, len(files))
plt.plot(t, v, label=helpers.getLabel(f, i, options), color=c)
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
optParser.add_option("-w", "--width", dest="width",
type="float", default=20, help="Defines the width of the dots")
optParser.add_option("-c", "--color", dest="color",
default='r', help="Defines the dot color")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=1, help="Defines the edge width")
optParser.add_option("--edge-color", dest="defaultColor",
default='k', help="Defines the edge color")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net is None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, {}, {}, options)
ax.set_xticklabels('')
ax.set_yticklabels('')
fig.patch.set_visible(False)
ax.axis('off')
#fig.set_size_inches(4.5, 3.5)
#fig.savefig('cenario.eps', bbox_inches = 'tight', pad_inches = 0.05, transparent=True)
plt.show()
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option(
"-i",
"--tripinfos-inputs",
dest="tripinfos",
metavar="FILE",
help="Defines the tripinfo-output files to use as input")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
optParser.add_option("-m",
"--measure",
dest="measure",
default="duration",
help="Define which measure to plot")
optParser.add_option("--bins",
dest="bins",
type="int",
default=20,
help="Define the bin number")
optParser.add_option("--norm",
dest="norm",
type="float",
default=1.,
help="Read values will be devided by this number")
optParser.add_option("--minV",
dest="minV",
type="float",
default=None,
help="Define the minimum value boundary")
optParser.add_option("--maxV",
dest="maxV",
type="float",
default=None,
help="Define the maximum value boundary")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.tripinfos == None:
print "Error: at least one tripinfo file must be given"
sys.exit(1)
minV = options.minV
maxV = options.maxV
files = options.tripinfos.split(",")
values = {}
for f in files:
if options.verbose:
print "Reading '%s'..." % f
nums = sumolib.output.parse_sax__asList(f, "tripinfo",
[options.measure])
fvp = sumolib.output.toList(nums, options.measure)
fv = [x / options.norm for x in fvp]
sumolib.output.prune(fv, options.minV, options.maxV)
values[f] = fv
if minV == None:
minV = fv[0]
maxV = fv[0]
minV = min(minV, min(fv))
maxV = max(maxV, max(fv))
hists = {}
binWidth = (maxV - minV) / float(options.bins)
for f in files:
h = [0] * options.bins
for v in values[f]:
i = min(int((v - minV) / binWidth), options.bins - 1)
h[i] = h[i] + 1
hists[f] = h
width = binWidth / float(len(files)) * .8
offset = binWidth * .1
center = []
for j in range(0, options.bins):
center.append(binWidth * j + offset)
fig, ax = helpers.openFigure(options)
for i, f in enumerate(files):
c = helpers.getColor(options, i, len(files))
l = helpers.getLabel(f, i, options)
plt.bar(center, hists[f], width=width, label=l, color=c)
for j in range(0, options.bins):
center[j] = center[j] + width
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n",
"--net",
dest="net",
metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i",
"--dump-inputs",
dest="dumps",
metavar="FILE",
help="Defines the dump-output files to use as input")
optParser.add_option("-m",
"--measures",
dest="measures",
default="speed,entered",
help="Define which measure to plot")
optParser.add_option("--min-width",
dest="minWidth",
type="float",
default=.5,
help="Defines the minimum edge width")
optParser.add_option("--max-width",
dest="maxWidth",
type="float",
default=3,
help="Defines the maximum edge width")
optParser.add_option("--log-colors",
dest="logColors",
action="store_true",
default=False,
help="If set, colors are log-scaled")
optParser.add_option("--log-widths",
dest="logWidths",
action="store_true",
default=False,
help="If set, widths are log-scaled")
optParser.add_option("--min-color-value",
dest="colorMin",
type="float",
default=None,
help="If set, defines the minimum edge color value")
optParser.add_option("--max-color-value",
dest="colorMax",
type="float",
default=None,
help="If set, defines the maximum edge color value")
optParser.add_option("--min-width-value",
dest="widthMin",
type="float",
default=None,
help="If set, defines the minimum edge width value")
optParser.add_option("--max-width-value",
dest="widthMax",
type="float",
default=None,
help="If set, defines the maximum edge width value")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
helpers.addNetOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
if options.measures == None:
print("Error: a dump file must be given.")
return 1
times = []
hc = None
if options.dumps.split(",")[0] != "":
if options.verbose:
print("Reading colors from '%s'" % options.dumps.split(",")[0])
hc = WeightsReader(options.measures.split(",")[0])
sumolib.output.parse_sax(options.dumps.split(",")[0], hc)
times = hc._edge2value
hw = None
if options.dumps.split(",")[1] != "":
if options.verbose:
print("Reading widths from '%s'" % options.dumps.split(",")[1])
hw = WeightsReader(options.measures.split(",")[1])
sumolib.output.parse_sax(options.dumps.split(",")[1], hw)
times = hw._edge2value
for t in times:
colors = {}
maxColorValue = None
minColorValue = None
for e in net._id2edge:
if hc and t in hc._edge2value and e in hc._edge2value[t]:
if options.colorMax != None and hc._edge2value[t][
e] > options.colorMax:
hc._edge2value[t][e] = options.colorMax
if options.colorMin != None and hc._edge2value[t][
e] < options.colorMin:
hc._edge2value[t][e] = options.colorMin
if maxColorValue == None or maxColorValue < hc._edge2value[t][
e]:
maxColorValue = hc._edge2value[t][e]
if minColorValue == None or minColorValue > hc._edge2value[t][
e]:
minColorValue = hc._edge2value[t][e]
colors[e] = hc._edge2value[t][e]
if options.colorMax != None:
maxColorValue = options.colorMax
if options.colorMin != None:
minColorValue = options.colorMin
if options.logColors:
helpers.logNormalise(colors, maxColorValue)
else:
helpers.linNormalise(colors, minColorValue, maxColorValue)
for e in colors:
colors[e] = helpers.getColor(options, colors[e], 1.)
if options.verbose:
print("Color values are between %s and %s" %
(minColorValue, maxColorValue))
widths = {}
maxWidthValue = None
minWidthValue = None
for e in net._id2edge:
if hw and t in hw._edge2value and e in hw._edge2value[t]:
v = abs(hw._edge2value[t][e])
if options.widthMax != None and v > options.widthMax:
v = options.widthMax
if options.widthMin != None and v < options.widthMin:
v = options.widthMin
if not maxWidthValue or maxWidthValue < v:
maxWidthValue = v
if not minWidthValue or minWidthValue > v:
minWidthValue = v
widths[e] = v
if options.widthMax != None:
maxWidthValue = options.widthMax
if options.widthMin != None:
minWidthValue = options.widthMin
if options.logWidths:
helpers.logNormalise(widths, options.colorMax)
else:
helpers.linNormalise(widths, minWidthValue, maxWidthValue)
for e in widths:
widths[e] = options.minWidth + widths[e] * \
(options.maxWidth - options.minWidth)
if options.verbose:
print("Width values are between %s and %s" %
(minWidthValue, maxWidthValue))
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
# drawing the legend, at least for the colors
sm = plt.cm.ScalarMappable(
cmap=matplotlib.cm.get_cmap(options.colormap),
norm=matplotlib.colors.Normalize(vmin=minColorValue,
vmax=maxColorValue))
# "fake up the array of the scalar mappable. Urgh..." (pelson, http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots)
sm._A = []
plt.colorbar(sm)
options.nolegend = True
optName = None
if options.output and options.output.find("%s") >= 0:
m, s = divmod(int(t), 60)
h, m = divmod(m, 60)
timeStr = "%02d:%02d:%02d" % (h, m, s)
ax.text(7300,
15500,
timeStr,
bbox={
'facecolor': 'white',
'pad': 10
},
size=16)
optName = options.output.replace("%s", str(t))
helpers.closeFigure(fig, ax, options, False, optName)
if optName == None:
return 0
return 0
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i", "--dump-inputs", dest="dumps", metavar="FILE",
help="Defines the dump-output files to use as input")
optParser.add_option("-m", "--measures", dest="measures",
default="speed,entered", help="Define which measure to plot")
optParser.add_option("--min-width", dest="minWidth",
type="float", default=.5, help="Defines the minimum edge width")
optParser.add_option("--max-width", dest="maxWidth",
type="float", default=3, help="Defines the maximum edge width")
optParser.add_option("--log-colors", dest="logColors", action="store_true",
default=False, help="If set, colors are log-scaled")
optParser.add_option("--log-widths", dest="logWidths", action="store_true",
default=False, help="If set, widths are log-scaled")
optParser.add_option("--min-color-value", dest="colorMin",
type="float", default=None,
help="If set, defines the minimum edge color value")
optParser.add_option("--max-color-value", dest="colorMax",
type="float", default=None,
help="If set, defines the maximum edge color value")
optParser.add_option("--min-width-value", dest="widthMin",
type="float", default=None,
help="If set, defines the minimum edge width value")
optParser.add_option("--max-width-value", dest="widthMax",
type="float", default=None,
help="If set, defines the maximum edge width value")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False,
help="If set, the script says what it's doing")
optParser.add_option("--color-bar-label", dest="colorBarLabel", default="",
help="The label to put on the color bar")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
helpers.addNetOptions(optParser)
# Override the help string for the output option
outputOpt = optParser.get_option("--output")
outputOpt.help = "Comma separated list of filename(s) the figure shall be written to; " +\
"for multiple time intervals use \'\%s\' in the filename as a " +\
"placeholder for the beginning of the time interval"
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net is None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
if options.measures is None:
print("Error: a dump file must be given.")
return 1
times = []
hc = None
colorDump = options.dumps.split(",")[0]
colorMeasure = options.measures.split(",")[0]
if colorDump:
if options.verbose:
print("Reading colors from '%s'" % colorDump)
hc = WeightsReader(colorMeasure)
sumolib.output.parse_sax(colorDump, hc)
times = hc._edge2value
hw = None
widthDump = options.dumps.split(",")[1]
widthMeasure = options.measures.split(",")[1]
if widthDump != "":
if options.verbose:
print("Reading widths from '%s'" % widthDump)
hw = WeightsReader(widthMeasure)
sumolib.output.parse_sax(widthDump, hw)
times = hw._edge2value
# Should we also save the figure to a file / list of files (comma
# separated)? Then we need to check the output filename(s)
if options.output:
options.nolegend = True
optOutputNames = options.output
# If we have multiple intervals to be plotted, make sure we have
# proper output filenames (with a %s as a placeholder in it)
if len(times) > 1 and optOutputNames.find('%s') < 0:
print('Warning: multiple time intervals detected, but ' +
'the output filename(s) do not contain a \'%s\' placeholder. ' +
'Continuing by using a default placeholder.')
# Modify each filename by putting a '-%s' right before the
# extension
filenames = optOutputNames.split(',')
for i in range(0, len(filenames)):
filename, extension = os.path.splitext(filenames[i])
filenames[i] = filename + '-%s' + extension
optOutputNames = ','.join(filenames)
# Now go through each time interval and create the figures
for t in times:
if options.verbose:
print("Processing interval with a beginning of %s" % t)
colors = {}
maxColorValue = None
minColorValue = None
for e in net._id2edge:
if hc and t in hc._edge2value and e in hc._edge2value[t]:
if options.colorMax is not None and hc._edge2value[t][e] > options.colorMax:
hc._edge2value[t][e] = options.colorMax
if options.colorMin is not None and hc._edge2value[t][e] < options.colorMin:
hc._edge2value[t][e] = options.colorMin
if maxColorValue is None or maxColorValue < hc._edge2value[t][e]:
maxColorValue = hc._edge2value[t][e]
if minColorValue is None or minColorValue > hc._edge2value[t][e]:
minColorValue = hc._edge2value[t][e]
colors[e] = hc._edge2value[t][e]
if options.colorMax is not None:
maxColorValue = options.colorMax
if options.colorMin is not None:
minColorValue = options.colorMin
if options.logColors:
helpers.logNormalise(colors, maxColorValue)
else:
helpers.linNormalise(colors, minColorValue, maxColorValue)
for e in colors:
colors[e] = helpers.getColor(options, colors[e], 1.)
if options.verbose:
print("Color values are between %s and %s" %
(minColorValue, maxColorValue))
widths = {}
maxWidthValue = None
minWidthValue = None
for e in net._id2edge:
if hw and t in hw._edge2value and e in hw._edge2value[t]:
v = abs(hw._edge2value[t][e])
if options.widthMax is not None and v > options.widthMax:
v = options.widthMax
if options.widthMin is not None and v < options.widthMin:
v = options.widthMin
if maxWidthValue is None or maxWidthValue < v:
maxWidthValue = v
if minWidthValue is None or minWidthValue > v:
minWidthValue = v
widths[e] = v
if options.widthMax is not None:
maxWidthValue = options.widthMax
if options.widthMin is not None:
minWidthValue = options.widthMin
if options.logWidths:
helpers.logNormalise(widths, options.colorMax)
else:
helpers.linNormalise(widths, minWidthValue, maxWidthValue)
for e in widths:
widths[e] = options.minWidth + widths[e] * \
(options.maxWidth - options.minWidth)
if options.verbose:
print("Width values are between %s and %s" %
(minWidthValue, maxWidthValue))
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
# drawing the legend, at least for the colors
norm = matplotlib.colors.LogNorm if options.logColors else matplotlib.colors.Normalize
sm = plt.cm.ScalarMappable(cmap=matplotlib.cm.get_cmap(options.colormap),
norm=norm(vmin=minColorValue, vmax=maxColorValue))
# "fake up the array of the scalar mappable. Urgh..."
# (pelson, http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots)
sm._A = []
color_bar = plt.colorbar(sm)
color_bar.set_label(options.colorBarLabel)
# Should we also save the figure to a file / list of files (comma
# separated)?
if options.output:
# If we have a "%s" in the name of the output then replace it with the
# interval begin of the current interval
expandedOutputNames = optOutputNames
if expandedOutputNames.find('%s') >= 0:
expandedOutputNames = expandedOutputNames.replace("%s", str(t))
# Can be used to print additional text in the figure:
#
# m, s = divmod(int(t), 60)
# h, m = divmod(m, 60)
# timeStr = "%02d:%02d:%02d" % (h, m, s)
# ax.text(0.2, 0.2, timeStr, bbox={
# 'facecolor': 'white', 'pad': 10}, size=16)
helpers.closeFigure(fig, ax, options, False, expandedOutputNames)
return 0
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i",
"--input",
dest="input",
metavar="FILE",
help="Defines the csv file to use as input")
optParser.add_option("-c",
"--column",
dest="column",
type="int",
default=1,
help="Selects the column to read values from")
optParser.add_option("-r",
"--revert",
dest="revert",
action="store_true",
default=False,
help="Reverts the order of read values")
optParser.add_option("-w",
"--width",
dest="width",
type="float",
default=.8,
help="Defines the width of the bars")
optParser.add_option("--space",
dest="space",
type="float",
default=.2,
help="Defines the space between the bars")
optParser.add_option(
"--norm",
dest="norm",
type="float",
default=1.,
help="Divides the read numbers by this value before plotting them")
optParser.add_option("--show-values",
dest="showValues",
action="store_true",
default=False,
help="Shows the values")
optParser.add_option("--values-offset",
dest="valuesOffset",
type="float",
default=1.,
help="Position offset for values")
optParser.add_option("--vertical",
dest="vertical",
action="store_true",
default=False,
help="vertical bars are used")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.input is None:
print("Error: at least one csv file must be given")
sys.exit(1)
fd = open(options.input)
labels = []
vlabels = []
vals = []
total = 0
xs = []
ts = []
s = options.width + options.space
t = options.width / 2. + options.space / 2.
x = options.space / 2.
for line in fd:
v = line.strip().split(";")
if len(v) < 2:
continue
labels.append(v[0].replace("\\n", "\n"))
value = float(v[options.column]) / options.norm
vals.append(value)
vlabels.append(str(value) + "%")
total += value
xs.append(x)
ts.append(t)
x = x + s
t = t + s
if options.revert:
labels.reverse()
vals.reverse()
vlabels.reverse()
colors = []
for i, e in enumerate(labels):
colors.append(helpers.getColor(options, i, len(labels)))
fig, ax = helpers.openFigure(options)
if not options.vertical:
rects = plt.barh(xs, vals, height=options.width)
for i, rect in enumerate(rects):
if options.showValues:
width = rect.get_width()
ax.text(width + options.valuesOffset,
rect.get_y() + rect.get_height() / 2.,
vlabels[i],
va='center',
ha='left')
rect.set_color(colors[i])
rect.set_edgecolor('k')
plt.ylim(0, x)
plt.yticks(ts, labels)
else:
rects = plt.bar(xs, vals, width=options.width)
for i, rect in enumerate(rects):
if options.showValues:
height = rect.get_height()
ax.text(rect.get_x() + rect.get_width() / 2.,
height + options.valuesOffset,
vlabels[i],
ha='center',
va='bottom')
rect.set_color(colors[i])
rect.set_edgecolor('k')
plt.xlim(0, x)
plt.xticks(ts, labels)
helpers.closeFigure(fig, ax, options, False)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("--edge-width", dest="defaultWidth",
type="float", default=1, help="Defines the edge width")
optParser.add_option("--edge-color", dest="defaultColor",
default='k', help="Defines the edge color")
optParser.add_option("--minV", dest="minV",
type="float", default=None, help="Define the minimum value boundary")
optParser.add_option("--maxV", dest="maxV",
type="float", default=None, help="Define the maximum value boundary")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
speeds = {}
minV = None
maxV = None
for e in net._id2edge:
v = net._id2edge[e]._speed
if minV == None or minV > v:
minV = v
if maxV == None or maxV < v:
maxV = v
speeds[e] = v
if options.minV != None:
minV = options.minV
if options.maxV != None:
maxV = options.maxV
# if options.logColors:
# helpers.logNormalise(colors, maxColorValue)
# else:
# helpers.linNormalise(colors, minColorValue, maxColorValue)
helpers.linNormalise(speeds, minV, maxV)
for e in speeds:
speeds[e] = helpers.getColor(options, speeds[e], 1.)
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, speeds, {}, options)
# drawing the legend, at least for the colors
print("%s -> %s" % (minV, maxV))
sm = matplotlib.cm.ScalarMappable(
cmap=get_cmap(options.colormap), norm=plt.normalize(vmin=minV, vmax=maxV))
# "fake up the array of the scalar mappable. Urgh..." (pelson, http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots)
sm._A = []
plt.colorbar(sm)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i", "--dump-inputs", dest="dumps", metavar="FILE",
help="Defines the dump-output files to use as input")
optParser.add_option("-m", "--measures", dest="measures",
default="speed,entered", help="Define which measure to plot")
optParser.add_option("--min-width", dest="minWidth",
type="float", default=.5, help="Defines the minimum edge width")
optParser.add_option("--max-width", dest="maxWidth",
type="float", default=3, help="Defines the maximum edge width")
optParser.add_option("--log-colors", dest="logColors", action="store_true",
default=False, help="If set, colors are log-scaled")
optParser.add_option("--log-widths", dest="logWidths", action="store_true",
default=False, help="If set, widths are log-scaled")
optParser.add_option("--min-color-value", dest="colorMin",
type="float", default=None,
help="If set, defines the minimum edge color value")
optParser.add_option("--max-color-value", dest="colorMax",
type="float", default=None,
help="If set, defines the maximum edge color value")
optParser.add_option("--min-width-value", dest="widthMin",
type="float", default=None,
help="If set, defines the minimum edge width value")
optParser.add_option("--max-width-value", dest="widthMax",
type="float", default=None,
help="If set, defines the maximum edge width value")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False,
help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
helpers.addNetOptions(optParser)
# Override the help string for the output option
outputOpt = optParser.get_option("--output")
outputOpt.help = "Comma separated list of filename(s) the figure shall be written to; " +\
"for multiple time intervals use \'\%s\' in the filename as a " +\
"placeholder for the beginning of the time interval"
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
if options.measures == None:
print("Error: a dump file must be given.")
return 1
times = []
hc = None
colorDump = options.dumps.split(",")[0]
colorMeasure = options.measures.split(",")[0]
if colorDump:
if options.verbose:
print("Reading colors from '%s'" % colorDump)
hc = WeightsReader(colorMeasure)
sumolib.output.parse_sax(colorDump, hc)
times = hc._edge2value
hw = None
widthDump = options.dumps.split(",")[1]
widthMeasure = options.measures.split(",")[1]
if widthDump != "":
if options.verbose:
print("Reading widths from '%s'" % widthDump)
hw = WeightsReader(widthMeasure)
sumolib.output.parse_sax(widthDump, hw)
times = hw._edge2value
# Should we also save the figure to a file / list of files (comma
# separated)? Then we need to check the output filename(s)
if options.output:
options.nolegend = True
optOutputNames = options.output
# If we have multiple intervals to be plotted, make sure we have
# proper output filenames (with a %s as a placeholder in it)
if len(times) > 1 and optOutputNames.find('%s') < 0:
print('Warning: multiple time intervals detected, but ' +
'the output filename(s) do not contain a \'%s\' placeholder. ' +
'Continuing by using a default placeholder.')
# Modify each filename by putting a '-%s' right before the
# extension
filenames = optOutputNames.split(',')
for i in range(0, len(filenames)):
filename, extension = os.path.splitext(filenames[i])
filenames[i] = filename + '-%s' + extension
optOutputNames = ','.join(filenames)
# Now go through each time interval and create the figures
for t in times:
if options.verbose:
print("Processing interval with a beginning of %s" % t)
colors = {}
maxColorValue = None
minColorValue = None
for e in net._id2edge:
if hc and t in hc._edge2value and e in hc._edge2value[t]:
if options.colorMax != None and hc._edge2value[t][e] > options.colorMax:
hc._edge2value[t][e] = options.colorMax
if options.colorMin != None and hc._edge2value[t][e] < options.colorMin:
hc._edge2value[t][e] = options.colorMin
if maxColorValue == None or maxColorValue < hc._edge2value[t][e]:
maxColorValue = hc._edge2value[t][e]
if minColorValue == None or minColorValue > hc._edge2value[t][e]:
minColorValue = hc._edge2value[t][e]
colors[e] = hc._edge2value[t][e]
if options.colorMax != None:
maxColorValue = options.colorMax
if options.colorMin != None:
minColorValue = options.colorMin
if options.logColors:
helpers.logNormalise(colors, maxColorValue)
else:
helpers.linNormalise(colors, minColorValue, maxColorValue)
for e in colors:
colors[e] = helpers.getColor(options, colors[e], 1.)
if options.verbose:
print("Color values are between %s and %s" %
(minColorValue, maxColorValue))
widths = {}
maxWidthValue = None
minWidthValue = None
for e in net._id2edge:
if hw and t in hw._edge2value and e in hw._edge2value[t]:
v = abs(hw._edge2value[t][e])
if options.widthMax != None and v > options.widthMax:
v = options.widthMax
if options.widthMin != None and v < options.widthMin:
v = options.widthMin
if not maxWidthValue or maxWidthValue < v:
maxWidthValue = v
if not minWidthValue or minWidthValue > v:
minWidthValue = v
widths[e] = v
if options.widthMax != None:
maxWidthValue = options.widthMax
if options.widthMin != None:
minWidthValue = options.widthMin
if options.logWidths:
helpers.logNormalise(widths, options.colorMax)
else:
helpers.linNormalise(widths, minWidthValue, maxWidthValue)
for e in widths:
widths[e] = options.minWidth + widths[e] * \
(options.maxWidth - options.minWidth)
if options.verbose:
print("Width values are between %s and %s" %
(minWidthValue, maxWidthValue))
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
# drawing the legend, at least for the colors
sm = plt.cm.ScalarMappable(cmap=matplotlib.cm.get_cmap(options.colormap),
norm=matplotlib.colors.Normalize(vmin=minColorValue,
vmax=maxColorValue))
# "fake up the array of the scalar mappable. Urgh..."
# (pelson, http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots)
sm._A = []
plt.colorbar(sm)
# Should we also save the figure to a file / list of files (comma
# separated)?
if options.output:
# If we have a "%s" in the name of the output then replace it with the
# interval begin of the current interval
expandedOutputNames = optOutputNames
if expandedOutputNames.find('%s') >= 0:
expandedOutputNames = expandedOutputNames.replace("%s", str(t))
# Can be used to print additional text in the figure:
#
# m, s = divmod(int(t), 60)
# h, m = divmod(m, 60)
# timeStr = "%02d:%02d:%02d" % (h, m, s)
# ax.text(0.2, 0.2, timeStr, bbox={
# 'facecolor': 'white', 'pad': 10}, size=16)
helpers.closeFigure(fig, ax, options, False, expandedOutputNames)
return 0
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE", help="Defines the network to read")
optParser.add_option("--edge-width", dest="defaultWidth", type="float", default=2.5, help="Defines the edge width")
optParser.add_option("--edge-color", dest="defaultColor", default="r", help="Defines the edge color")
optParser.add_option(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing",
)
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
options, remaining_args = optParser.parse_args(args=args)
options.colormap = "jet"
#Net file
net = sumolib.net.readNet(path)
#count = 0
key_max = max(edge_traversal_list.keys(), key=(lambda k: edge_traversal_list[k]))
key_min = min(edge_traversal_list.keys(), key=(lambda k: edge_traversal_list[k]))
minCount = edge_traversal_list[key_min]
maxCount = edge_traversal_list[key_max]
helpers.linNormalise(edge_traversal_list, minCount, maxCount)
for e in edge_traversal_list:
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i", "--tripinfos-inputs", dest="tripinfos", metavar="FILE",
help="Defines the tripinfo-output files to use as input")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
optParser.add_option("-m", "--measure", dest="measure",
default="duration", help="Define which measure to plot")
optParser.add_option("--bins", dest="bins",
type="int", default=20, help="Define the bin number")
optParser.add_option("--norm", dest="norm",
type="float", default=1., help="Read values will be devided by this number")
optParser.add_option("--minV", dest="minV",
type="float", default=None, help="Define the minimum value boundary")
optParser.add_option("--maxV", dest="maxV",
type="float", default=None, help="Define the maximum value boundary")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.tripinfos == None:
print "Error: at least one tripinfo file must be given"
sys.exit(1)
minV = options.minV
maxV = options.maxV
files = options.tripinfos.split(",")
values = {}
for f in files:
if options.verbose:
print "Reading '%s'..." % f
nums = sumolib.output.parse_sax__asList(
f, "tripinfo", [options.measure])
fvp = sumolib.output.toList(nums, options.measure)
fv = [x / options.norm for x in fvp]
sumolib.output.prune(fv, options.minV, options.maxV)
values[f] = fv
if minV == None:
minV = fv[0]
maxV = fv[0]
minV = min(minV, min(fv))
maxV = max(maxV, max(fv))
hists = {}
binWidth = (maxV - minV) / float(options.bins)
for f in files:
h = [0] * options.bins
for v in values[f]:
i = min(int((v - minV) / binWidth), options.bins - 1)
h[i] = h[i] + 1
hists[f] = h
width = binWidth / float(len(files)) * .8
offset = binWidth * .1
center = []
for j in range(0, options.bins):
center.append(binWidth * j + offset)
fig, ax = helpers.openFigure(options)
for i, f in enumerate(files):
c = helpers.getColor(options, i, len(files))
l = helpers.getLabel(f, i, options)
plt.bar(center, hists[f], width=width, label=l, color=c)
for j in range(0, options.bins):
center[j] = center[j] + width
helpers.closeFigure(fig, ax, options)
def plot(densities, md, net, filename=None):
args = []
optParser = OptionParser()
optParser.add_option("-n",
"--net",
dest="net",
metavar="FILE",
help="Defines the network to read")
optParser.add_option("--edge-width",
dest="defaultWidth",
type="float",
default=0.5,
help="Defines the width of not selected edges")
optParser.add_option("--edge-color",
dest="defaultColor",
default='#000000',
help="Defines the color of not selected edges")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
options, remaining_args = optParser.parse_args(args=args)
for i, interval in enumerate(densities):
colors = {}
widths = {}
max_density = 0
min_density = 10000
for e in interval.keys():
if max_density < interval[e]:
max_density = interval[e]
if min_density > interval[e]:
min_density = interval[e]
for e in interval.keys():
colors[e] = get_color(interval[e], md)
#widths[e] = normalize(interval[e], max_density, min_density) + 2.0
widths[e] = 4
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
lines = ax.get_lines()
for line in lines:
line.set_linestyle('--')
ax.set_title('{num1:02d}:00:00 to {num2:02d}:00:00 hrs'.format(
num1=(i + 6) % 24, num2=(i + 7) % 24))
if filename:
fig.savefig(f'../output/{filename}.pdf',
bbox_inches='tight',
pad_inches=0)
else:
fig.savefig('../output/hour' + str(i) + '.pdf',
bbox_inches='tight',
pad_inches=0)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option(
"-i",
"--summary-inputs",
dest="summary",
metavar="FILE",
help="Defines the summary-output files to use as input")
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
options, _ = optParser.parse_args(args=args)
#<interval begin="90.00" end="120.00" id="e1det_886398487#2.123_3" nVehContrib="0" flow="0.00" occupancy="0.00" speed="-1.00" harmonicMeanSpeed="-1.00" #length="-1.00" nVehEntered="0"/>
if options.summary is None:
print("Error: at least one summary file must be given")
sys.exit(1)
files = options.summary.split(",")
tid = 2
cols = [
"begin", "end", "id", "nVehContrib", "flow", "occupancy", "speed",
"harmonicMeanSpeed", "length", "nVehEntered"
]
label = cols[0:tid] + cols[tid + 1:]
data = {}
for raw in sumolib.xml.parse_fast(files[0], "interval", cols):
id = raw[tid]
if id not in data:
print("Adding ..", id)
data[id] = []
data[id].append([float(x) for x in raw[0:tid] + raw[tid + 1:]])
fig = plt.figure()
for i, k in enumerate(data):
tag = "e1{:02d}".format(i)
d = np.array(data[k])
t = d[:, 0]
plt.plot(t, d[:, 4], label=label[4])
plt.savefig("{}_occ.jpg".format(tag))
plt.xlabel("Time/s")
plt.legend()
plt.clf()
plt.plot(t, d[:, 5], label=label[5])
plt.plot(t, d[:, 6], label=label[6])
plt.savefig("{}_vel.jpg".format(tag))
plt.xlabel("Time/s")
plt.legend()
plt.clf()
plt.plot(t, d[:, 2], label=label[2])
plt.plot(t, d[:, 3], label=label[3])
plt.plot(t, d[:, 8], label=label[8])
plt.savefig("{}_flow.jpg".format(tag))
plt.xlabel("Time/s")
plt.legend()
plt.clf()
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i", "--summary-inputs", dest="summary", metavar="FILE",
help="Defines the summary-output files to use as input")
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
options, _ = optParser.parse_args(args=args)
#"begin",end="150.00" id="e2det_109505014#6.100_0" sampledSeconds="33.11" nVehEntered="3" nVehLeft="2" nVehSeen="3" meanSpeed="12.46" meanTimeLoss="2.76" meanOccupancy="0.34" maxOccupancy="3.08" meanMaxJamLengthInVehicles="0.02" meanMaxJamLengthInMeters="0.05" maxJamLengthInVehicles="1" maxJamLengthInMeters="2.10" jamLengthInVehiclesSum="7" jamLengthInMetersSum="14.70" meanHaltingDuration="4.50" maxHaltingDuration="4.50" haltingDurationSum="4.50" meanIntervalHaltingDuration="4.50" maxIntervalHaltingDuration="4.50" intervalHaltingDurationSum="4.50" startedHalts="1.00" meanVehicleNumber="0.23" maxVehicleNumber="2" />
if options.summary is None:
print("Error: at least one summary file must be given")
sys.exit(1)
files = options.summary.split(",")
tid=2
cols = ["begin","end","id",
"sampledSeconds","nVehEntered","nVehLeft","nVehSeen",
"meanSpeed","meanTimeLoss","meanOccupancy","maxOccupancy","meanMaxJamLengthInVehicles",
"meanMaxJamLengthInMeters","maxJamLengthInVehicles","maxJamLengthInMeters","jamLengthInVehiclesSum","jamLengthInMetersSum",
"meanHaltingDuration","maxHaltingDuration","haltingDurationSum","meanIntervalHaltingDuration","maxIntervalHaltingDuration", "intervalHaltingDurationSum","startedHalts","meanVehicleNumber","maxVehicleNumber" ]
print(cols)
label = cols[0:tid]+cols[tid+1:]
data = {}
for raw in sumolib.xml.parse_fast(files[0], "interval", cols ):
id = raw[tid]
if id not in data:
data[id] = []
data[id].append( [ float(x) for x in raw[0:tid]+raw[tid+1:] ] )
fig = plt.figure()
for i, k in enumerate(data):
tag="e2{:02d}".format(i)
d = np.array(data[k])
t = d[:,0]
plt.plot(t, d[:,7], label=label[7])
plt.plot(t, d[:,8], label=label[8])
plt.xlabel("Time/s")
plt.legend()
plt.savefig("{}_occ.jpg".format(tag))
plt.clf()
plt.plot(t, d[:,6], label=label[6])
plt.xlabel("Time/s")
plt.legend()
plt.savefig("{}_vel.jpg".format(tag))
plt.clf()
plt.plot(t, d[:,15], label=label[15])
plt.plot(t, d[:,16], label=label[16])
plt.plot(t, d[:,17], label=label[17])
plt.plot(t, d[:,18], label=label[18])
plt.plot(t, d[:,19], label=label[19])
plt.plot(t, d[:,20], label=label[20])
plt.plot(t, d[:,21], label=label[21])
plt.plot(t, d[:,22], label=label[22])
plt.xlabel("Time/s")
plt.legend()
plt.savefig("{}_flow.jpg".format(tag))
plt.clf()
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-i", "--input", dest="input", metavar="FILE",
help="Defines the csv file to use as input")
optParser.add_option("-c", "--column", dest="column",
type="int", default=1, help="Selects the column to read values from")
optParser.add_option("-r", "--revert", dest="revert", action="store_true",
default=False, help="Reverts the order of read values")
optParser.add_option("-w", "--width", dest="width",
type="float", default=.8, help="Defines the width of the bars")
optParser.add_option("--space", dest="space",
type="float", default=.2, help="Defines the space between the bars")
optParser.add_option("--norm", dest="norm",
type="float", default=1., help="Divides the read numbers by this value before plotting them")
optParser.add_option("--show-values", dest="showValues", action="store_true",
default=False, help="Shows the values")
optParser.add_option("--values-offset", dest="valuesOffset",
type="float", default=1., help="Position offset for values")
optParser.add_option("--vertical", dest="vertical", action="store_true",
default=False, help="vertical bars are used")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.input == None:
print("Error: at least one csv file must be given")
sys.exit(1)
fd = open(options.input)
labels = []
vlabels = []
vals = []
total = 0
xs = []
ts = []
s = options.width + options.space
t = options.width / 2. + options.space / 2.
x = options.space / 2.
for line in fd:
v = line.strip().split(";")
if len(v) < 2:
continue
labels.append(v[0].replace("\\n", "\n"))
value = float(v[options.column]) / options.norm
vals.append(value)
vlabels.append(str(value) + "%")
total += value
xs.append(x)
ts.append(t)
x = x + s
t = t + s
if options.revert:
labels.reverse()
vals.reverse()
vlabels.reverse()
colors = []
for i, e in enumerate(labels):
colors.append(helpers.getColor(options, i, len(labels)))
fig, ax = helpers.openFigure(options)
if not options.vertical:
rects = plt.barh(xs, vals, height=options.width)
for i, rect in enumerate(rects):
if options.showValues:
width = rect.get_width()
ax.text(width + options.valuesOffset, rect.get_y() +
rect.get_height() / 2., vlabels[i], va='center', ha='left')
rect.set_color(colors[i])
rect.set_edgecolor('k')
plt.ylim(0, x)
plt.yticks(ts, labels)
else:
rects = plt.bar(xs, vals, width=options.width)
for i, rect in enumerate(rects):
if options.showValues:
height = rect.get_height()
ax.text(rect.get_x() + rect.get_width() / 2., height +
options.valuesOffset, vlabels[i], ha='center', va='bottom')
rect.set_color(colors[i])
rect.set_edgecolor('k')
plt.xlim(0, x)
plt.xticks(ts, labels)
helpers.closeFigure(fig, ax, options, False)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n",
"--net",
dest="net",
metavar="FILE",
help="Defines the network to read")
optParser.add_option("--edge-width",
dest="defaultWidth",
type="float",
default=1,
help="Defines the edge width")
optParser.add_option("--edge-color",
dest="defaultColor",
default='k',
help="Defines the edge color")
optParser.add_option("--minV",
dest="minV",
type="float",
default=None,
help="Define the minimum value boundary")
optParser.add_option("--maxV",
dest="maxV",
type="float",
default=None,
help="Define the maximum value boundary")
optParser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net is None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
speeds = {}
minV = None
maxV = None
for e in net._id2edge:
v = net._id2edge[e]._speed
if minV is None or minV > v:
minV = v
if maxV is None or maxV < v:
maxV = v
speeds[e] = v
if options.minV is not None:
minV = options.minV
if options.maxV is not None:
maxV = options.maxV
# if options.logColors:
# helpers.logNormalise(colors, maxColorValue)
# else:
# helpers.linNormalise(colors, minColorValue, maxColorValue)
helpers.linNormalise(speeds, minV, maxV)
for e in speeds:
speeds[e] = helpers.getColor(options, speeds[e], 1.)
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, speeds, {}, options)
# drawing the legend, at least for the colors
print("%s -> %s" % (minV, maxV))
sm = matplotlib.cm.ScalarMappable(
cmap=matplotlib.cm.get_cmap(options.colormap),
norm=matplotlib.colors.normalize(vmin=minV, vmax=maxV))
# "fake up the array of the scalar mappable. Urgh..." (pelson, http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots)
sm._A = []
plt.colorbar(sm)
options.nolegend = True
helpers.closeFigure(fig, ax, options)
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option("-n", "--net", dest="net", metavar="FILE",
help="Defines the network to read")
optParser.add_option("-i", "--dump-inputs", dest="dumps", metavar="FILE",
help="Defines the dump-output files to use as input")
optParser.add_option("-m", "--measures", dest="measures",
default="speed,entered", help="Define which measure to plot")
optParser.add_option("--min-width", dest="minWidth",
type="float", default=.5, help="Defines the minimum edge width")
optParser.add_option("--max-width", dest="maxWidth",
type="float", default=3, help="Defines the maximum edge width")
optParser.add_option("--log-colors", dest="logColors", action="store_true",
default=False, help="If set, colors are log-scaled")
optParser.add_option("--log-widths", dest="logWidths", action="store_true",
default=False, help="If set, widths are log-scaled")
optParser.add_option("--min-color-value", dest="colorMin",
type="float", default=None, help="If set, defines the minimum edge color value")
optParser.add_option("--max-color-value", dest="colorMax",
type="float", default=None, help="If set, defines the maximum edge color value")
optParser.add_option("--min-width-value", dest="widthMin",
type="float", default=None, help="If set, defines the minimum edge width value")
optParser.add_option("--max-width-value", dest="widthMax",
type="float", default=None, help="If set, defines the maximum edge width value")
optParser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="If set, the script says what it's doing")
# standard plot options
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
helpers.addNetOptions(optParser)
# parse
options, remaining_args = optParser.parse_args(args=args)
if options.net == None:
print("Error: a network to load must be given.")
return 1
if options.verbose:
print("Reading network from '%s'" % options.net)
net = sumolib.net.readNet(options.net)
if options.measures == None:
print("Error: a dump file must be given.")
return 1
times = []
hc = None
if options.dumps.split(",")[0] != "":
if options.verbose:
print("Reading colors from '%s'" % options.dumps.split(",")[0])
hc = WeightsReader(options.measures.split(",")[0])
sumolib.output.parse_sax(options.dumps.split(",")[0], hc)
times = hc._edge2value
hw = None
if options.dumps.split(",")[1] != "":
if options.verbose:
print("Reading widths from '%s'" % options.dumps.split(",")[1])
hw = WeightsReader(options.measures.split(",")[1])
sumolib.output.parse_sax(options.dumps.split(",")[1], hw)
times = hw._edge2value
for t in times:
colors = {}
maxColorValue = None
minColorValue = None
for e in net._id2edge:
if hc and t in hc._edge2value and e in hc._edge2value[t]:
if options.colorMax != None and hc._edge2value[t][e] > options.colorMax:
hc._edge2value[t][e] = options.colorMax
if options.colorMin != None and hc._edge2value[t][e] < options.colorMin:
hc._edge2value[t][e] = options.colorMin
if maxColorValue == None or maxColorValue < hc._edge2value[t][e]:
maxColorValue = hc._edge2value[t][e]
if minColorValue == None or minColorValue > hc._edge2value[t][e]:
minColorValue = hc._edge2value[t][e]
colors[e] = hc._edge2value[t][e]
if options.colorMax != None:
maxColorValue = options.colorMax
if options.colorMin != None:
minColorValue = options.colorMin
if options.logColors:
helpers.logNormalise(colors, maxColorValue)
else:
helpers.linNormalise(colors, minColorValue, maxColorValue)
for e in colors:
colors[e] = helpers.getColor(options, colors[e], 1.)
if options.verbose:
print("Color values are between %s and %s" %
(minColorValue, maxColorValue))
widths = {}
maxWidthValue = None
minWidthValue = None
for e in net._id2edge:
if hw and t in hw._edge2value and e in hw._edge2value[t]:
v = abs(hw._edge2value[t][e])
if options.widthMax != None and v > options.widthMax:
v = options.widthMax
if options.widthMin != None and v < options.widthMin:
v = options.widthMin
if not maxWidthValue or maxWidthValue < v:
maxWidthValue = v
if not minWidthValue or minWidthValue > v:
minWidthValue = v
widths[e] = v
if options.widthMax != None:
maxWidthValue = options.widthMax
if options.widthMin != None:
minWidthValue = options.widthMin
if options.logWidths:
helpers.logNormalise(widths, options.colorMax)
else:
helpers.linNormalise(widths, minWidthValue, maxWidthValue)
for e in widths:
widths[e] = options.minWidth + widths[e] * \
(options.maxWidth - options.minWidth)
if options.verbose:
print("Width values are between %s and %s" %
(minWidthValue, maxWidthValue))
fig, ax = helpers.openFigure(options)
ax.set_aspect("equal", None, 'C')
helpers.plotNet(net, colors, widths, options)
# drawing the legend, at least for the colors
sm = plt.cm.ScalarMappable(cmap=matplotlib.cm.get_cmap(
options.colormap), norm=matplotlib.colors.Normalize(vmin=minColorValue, vmax=maxColorValue))
# "fake up the array of the scalar mappable. Urgh..." (pelson, http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots)
sm._A = []
plt.colorbar(sm)
options.nolegend = True
optName = None
if options.output and options.output.find("%s") >= 0:
m, s = divmod(int(t), 60)
h, m = divmod(m, 60)
timeStr = "%02d:%02d:%02d" % (h, m, s)
ax.text(7300, 15500, timeStr, bbox={
'facecolor': 'white', 'pad': 10}, size=16)
optName = options.output.replace("%s", str(t))
helpers.closeFigure(fig, ax, options, False, optName)
if optName == None:
return 0
return 0
def main(args=None):
"""The main function; parses options and plots"""
# ---------- build and read options ----------
from optparse import OptionParser
optParser = OptionParser()
optParser.add_option(
"-i",
"--summary-inputs",
dest="summary",
metavar="FILE",
help="Defines the summary-output files to use as input")
helpers.addInteractionOptions(optParser)
helpers.addPlotOptions(optParser)
options, _ = optParser.parse_args(args=args)
#<interval begin="0.00" end="150.00" id="e3_A0" meanTravelTime="27.93" meanOverlapTravelTime="28.57" meanSpeed="12.58" meanHaltsPerVehicle="0.39" meanTimeLoss="14.21" vehicleSum="36" meanSpeedWithin="7.42" meanHaltsPerVehicleWithin="0.84" meanDurationWithin="49.01" vehicleSumWithin="63" meanIntervalSpeedWithin="7.42" meanIntervalHaltsPerVehicleWithin="0.84" meanIntervalDurationWithin="49.01" meanTimeLossWithin="36.65"/>
if options.summary is None:
print("Error: at least one summary file must be given")
sys.exit(1)
files = options.summary.split(",")
tid = 2
cols = [
"begin", "end", "id", "meanTravelTime", "meanOverlapTravelTime",
"meanSpeed", "meanHaltsPerVehicle", "meanTimeLoss", "vehicleSum",
"meanSpeedWithin", "meanHaltsPerVehicleWithin", "meanDurationWithin",
"vehicleSumWithin", "meanIntervalSpeedWithin",
"meanIntervalHaltsPerVehicleWithin", "meanIntervalDurationWithin",
"meanTimeLossWithin"
]
print(cols)
label = cols[0:tid] + cols[tid + 1:]
data = {}
for raw in sumolib.xml.parse_fast(files[0], "interval", cols):
id = raw[tid]
if id not in data:
print("Adding ..", id)
data[id] = []
data[id].append([float(x) for x in raw[0:tid] + raw[tid + 1:]])
fig = plt.figure()
for k in data:
#tag="e3{:02d}".format(i)
tag = k
d = np.array(data[k])
t = d[:, 0]
plt.plot(t, d[:, 2], label=label[2])
plt.plot(t, d[:, 3], label=label[3])
plt.plot(t, d[:, 6], label=label[6])
plt.plot(t, d[:, 10], label=label[10])
plt.plot(t, d[:, 11], label=label[11])
plt.plot(t, d[:, 14], label=label[14])
plt.plot(t, d[:, 15], label=label[15])
plt.xlabel("Time/s")
plt.legend()
plt.savefig("{}_time.jpg".format(tag))
plt.clf()
plt.plot(t, d[:, 4], label=label[4])
plt.plot(t, d[:, 8], label=label[8])
plt.plot(t, d[:, 9], label=label[9])
plt.plot(t, d[:, 12], label=label[12])
plt.xlabel("Time/s")
plt.legend()
plt.savefig("{}_vel.jpg".format(tag))
plt.clf()
plt.plot(t, d[:, 5], label=label[5])
plt.plot(t, d[:, 7], label=label[7])
plt.plot(t, d[:, 13], label=label[13])
plt.xlabel("Time/s")
plt.legend()
plt.savefig("{}_flow.jpg".format(tag))
plt.clf()