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("-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 = []
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("-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("-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")
# 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("-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
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("--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)
maxCount = edge_traversal_list[key_max]
helpers.linNormalise(edge_traversal_list, minCount, maxCount)
for e in edge_traversal_list:
edge_traversal_list[e] = helpers.getColor(options, edge_traversal_list[e], 1.)
fig, ax = helpers.openFigure(options)
str_val = 'Edge Traversal count for robot "{}"'
fig.suptitle(str_val.format(robot_id), fontsize=12)
fig.patch.set_facecolor('white')
fig.patch.set_visible(True)
ax.axis('off')
ax.set_aspect("equal", None, 'C')\
helpers.plotNet(net, edge_traversal_list, {}, options)
sm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet)
sm._A = []
plt.tight_layout()
plt.colorbar(sm)
options.nolegend = True
str_val = save_path+'{}_edge_traverse_heatmap.png'
plt.savefig(str_val.format(robot_id))
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)