Esempio n. 1
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("-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  = pie(vals, labels=labels, autopct=autopct, colors=colors, shadow=shadow, startangle=options.startangle)
  helpers.closeFigure(fig, ax, options)
Esempio n. 2
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("-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  = pie(vals, labels=labels, autopct=autopct, colors=colors, shadow=shadow, startangle=options.startangle)
  helpers.closeFigure(fig, ax, options)
Esempio n. 3
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("-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)
Esempio n. 4
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 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)
        plot(ts[0:len(v)], v, label=l, color=c)
    helpers.closeFigure(fig, ax, options)
Esempio n. 5
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",
    )
    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)
        plot(ts[0 : len(v)], v, label=l, color=c)
    helpers.closeFigure(fig, ax, options)
Esempio n. 6
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")
    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)
        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("-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", "--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)
    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", "--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)
    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("--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)
Esempio n. 11
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",
        "--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)
        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)
Esempio n. 12
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",
                         "--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)
Esempio n. 13
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("-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("-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 = 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')
    ylim(0, x)
    yticks(ts, labels)
  else:
    rects = 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')
    xlim(0, x)
    xticks(ts, labels)
  helpers.closeFigure(fig, ax, options)
Esempio n. 15
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 == 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)
Esempio n. 16
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 == 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 = 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')
        ylim(0, x)
        yticks(ts, labels)
    else:
        rects = 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')
        xlim(0, x)
        xticks(ts, labels)
    helpers.closeFigure(fig, ax, options)
Esempio n. 17
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("-w", "--default-width", dest="defaultWidth", 
                         type="float", default=.1, help="Defines the default edge width")
  optParser.add_option("-c", "--default-color", dest="defaultColor", 
                         default='k', help="Defines the default edge color")
  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)
  # 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 = matplotlib.cm.ScalarMappable(cmap=get_cmap(options.colormap), norm=plt.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
    helpers.closeFigure(fig, ax, options)
    return 0 # !!! hack 
  return 0
Esempio n. 18
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("-w",
                         "--default-width",
                         dest="defaultWidth",
                         type="float",
                         default=.1,
                         help="Defines the default edge width")
    optParser.add_option("-c",
                         "--default-color",
                         dest="defaultColor",
                         default='k',
                         help="Defines the default edge color")
    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)
    # 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 = matplotlib.cm.ScalarMappable(cmap=get_cmap(options.colormap),
                                          norm=plt.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
        helpers.closeFigure(fig, ax, options)
        return 0  # !!! hack
    return 0