gplot.py

   1 # -*- coding: utf-8 -*-
   2 """This module contain functions to ease graph plots."""
   3 from json import loads
   4 from matplotlib import pyplot as plt
   5 from os import listdir
   6 from sys import argv, exit
   7 import numpy as np
   8
   9 def load_trajectory(fname):
  10     """Load trajectory from file.
  11
  12     Keyword arguments:
  13     fname -- The file name.
  14     """
  15     if fname is None:
  16         raise ValueError("File name as argument needed")
  17     with open(fname, "r") as f:
  18         trajectory = loads(f.read())
  19         return trajectory
  20
  21 def load_trajectories(dname):
  22     """Load trajectories from directory.
  23
  24     Keyword arguments:
  25     dname -- The directory name.
  26     """
  27     if dname is None:
  28         raise ValueError("Directory name as argument needed")
  29     trajectories = []
  30     for f in listdir(dname):
  31         trajectories.append(load_trajectory("{}/{}".format(dname, f)))
  32     return trajectories
  33
  34 def gplot():
  35     """Plot graph."""
  36     plt.rcParams["font.size"] = 24
  37     fig = plt.figure()
  38     ax = fig.add_subplot(111)
  39     #ax.set_aspect("equal")
  40     #ax.set_yscale("log")
  41     #ax.set_title("TITLE")
  42     #ax.set_xlabel("Time [s]")
  43     #ax.set_ylabel("YLABEL")
  44     #ax.set_xlim(0, 100)
  45     #ax.set_ylim(0, 100)
  46
  47     #plt.plot(xcoords, ycoords, color="blue", label="LABEL")
  48     #plt.hist(vals) # log=?, range=[?], bins=?
  49     #ax.bar(xvals, yvals) # width=?
  50     #ax.set_xticklabels(xvals, rotation=90)
  51
  52     plt.show()
  53     #plt.savefig("WHATEVER")
  54
  55 def count_if_exist(trajectories, what):
  56     """From multiple trajectories compute the number of occurences.
  57
  58     Keyword arguments:
  59     trajectories -- The list of trajectories.
  60     what -- Number of occurences of what to compute.
  61     """
  62     occ = 0
  63     for t in trajectories:
  64         try:
  65             if t[what]:
  66                 occ += 1
  67         except:
  68             pass
  69     return occ
  70
  71 def get_lasts_if_exist(trajectories, what):
  72     """From multiple trajectories get the list of last values.
  73
  74     Keyword arguments:
  75     trajectories -- The list of trajectories.
  76     what -- The last values of what to take.
  77     """
  78     val = []
  79     for t in trajectories:
  80         try:
  81             val.append(t[what][-1])
  82         except:
  83             pass
  84     return val
  85
  86 def get_maxs_if_exist(trajectories, what):
  87     """From multiple trajectories get the list of maximum values.
  88
  89     Keyword arguments:
  90     trajectories -- The list of trajectories.
  91     what -- The maximum values of what to take.
  92     """
  93     val = []
  94     for t in trajectories:
  95         try:
  96             val.append(max(t[what]))
  97         except:
  98             pass
  99     return val
 100
 101 def plot_successrate():
 102     """Plot success rate of single/multi-core implementations."""
 103     LOGF="logs_T2st3co2_lpar"
 104     LOGSF=["opt1_nn3", "opt1_nn4", "opt1_nn4_save-heading"]
 105     LEG={
 106             LOGSF[0]: "T2, st3, co2, nn3",
 107             LOGSF[1]: "T2, st3, co2, nn4",
 108             LOGSF[2]: "T2, st3, co2, nn4 save heading"}
 109
 110     r={}
 111     for sf in LOGSF:
 112         r["{}".format(LEG[sf])] = load_trajectories("{}/{}".format(LOGF, sf))
 113
 114     v={}
 115     for a in r.keys():
 116         v[a] = (100 * count_if_exist(r[a], "traj") /
 117                 count_if_exist(r[a], "elap"))
 118     vs = sorted(v.items(), key=lambda kv: kv[1])
 119
 120     plt.rcParams["font.size"] = 24
 121     fig = plt.figure()
 122     ax = fig.add_subplot(111)
 123     ax.set_title("Trajectories found in 10 seconds period")
 124
 125     ax.set_ylabel("Framework tested [-]")
 126     ax.set_xlabel("Found successfully [%]")
 127     ax.set_xlim(0, 100)
 128     ax.set_yticklabels([])
 129     j = 0
 130     for (k, i) in vs:
 131         print("{}: {}%".format(k, i))
 132         ax.barh(j, float(i), 4, label=k)
 133         j += -5
 134     ax.legend()
 135
 136     plt.show()
 137
 138 def plot_mintrajcost():
 139     """Plot minimum trajectory cost found."""
 140     LOGF="logs_inf_sq"
 141     ALG=["Karaman2011", "Kuwata2008", "LaValle1998"]
 142     ALGT={"Karaman2011": "RRT*",
 143             "Kuwata2008": "RRT + heur",
 144             "LaValle1998": "RRT"}
 145     ST=["3"]
 146     STT={"3": "R&S"}
 147     CO=["5"]
 148     COT={"5": "E2"}
 149
 150     r={}
 151     for a in ALG:
 152         for st in ST:
 153             for co in CO:
 154                 r["{}, {}, {}".format(ALGT[a], STT[st], COT[co])] = (
 155                         load_trajectories("{}/{}st{}co{}_lpar".format(
 156                             LOGF, a, st, co)))
 157
 158     v={}
 159     for a in r.keys():
 160         v[a] = get_lasts_if_exist(r[a], "cost")
 161
 162     #plt.rcParams["font.size"] = 24
 163     fig = plt.figure()
 164     for i in range(len(r.keys())):
 165         ax = fig.add_subplot(3, 1, i + 1)
 166         ax.set_title("Minimum trajectory cost found in 10 seconds (sequential)")
 167
 168         ax.set_ylabel("Framework tested [-]")
 169         ax.set_xlabel("Minimum trajectory cost [m]")
 170         #ax.set_yticklabels([])
 171
 172         plt.bar(range(len(v[r.keys()[i]])), v[r.keys()[i]], label=r.keys()[i])
 173
 174         ax.legend()
 175     plt.show()
 176     return
 177
 178 def plot_costdist():
 179     """Plot distribution of last costs across measured tests."""
 180     LOGF="logs_T2st3co2_lpar"
 181     LOGSF=["opt0", "opt1_nn4", "opt2_nn4"]
 182     LEG={
 183             LOGSF[0]: "T2, st3, co2, no opt",
 184             LOGSF[1]: "T2, st3, co2, Dijkstra opt",
 185             LOGSF[2]: "T2, st3, co2, Triangular opt"}
 186
 187     r={}
 188     for sf in LOGSF:
 189         r["{}".format(LEG[sf])] = load_trajectories("{}/{}".format(LOGF, sf))
 190
 191     v={}
 192     for a in r.keys():
 193         v[a] = get_lasts_if_exist(r[a], "cost")
 194
 195     plt.rcParams["font.size"] = 24
 196     fig = plt.figure()
 197     ax = fig.add_subplot(111)
 198     ax.set_title("Trajectories last costs distribution")
 199
 200     ax.set_ylabel("[-]")
 201     ax.set_xlabel("Minimum trajectory cost [m]")
 202     ax.set_yticklabels([])
 203     ax.set_yscale("log")
 204
 205     for a in r.keys():
 206         plt.hist(v[a], label=a, alpha=0.5, bins=200)
 207
 208     plt.legend()
 209     plt.show()
 210
 211 def plot_maxtime():
 212     """Plot time of the last traj (the maximum time)."""
 213     LOGF="logs_T2st3co2_lpar"
 214     LOGSF=["opt1_nn3", "opt1_nn4", "opt1_nn4_save-heading"]
 215     LEG={
 216             LOGSF[0]: "T2, st3, co2, nn3",
 217             LOGSF[1]: "T2, st3, co2, nn4",
 218             LOGSF[2]: "T2, st3, co2, nn4 save heading"}
 219
 220     r={}
 221     for sf in LOGSF:
 222         r["{}".format(LEG[sf])] = load_trajectories("{}/{}".format(LOGF, sf))
 223
 224     v={}
 225     for a in r.keys():
 226         v[a] = get_lasts_if_exist(r[a], "secs")
 227
 228     plt.rcParams["font.size"] = 24
 229     fig = plt.figure()
 230     ax = fig.add_subplot(111)
 231     ax.set_title("The last trajectory time")
 232
 233     ax.set_ylabel("[-]")
 234     ax.set_xlabel("The last trajectory time [s]")
 235     ax.set_yticklabels([])
 236     ax.set_yscale("log")
 237
 238     for a in r.keys():
 239         plt.hist(v[a], label=a, alpha=0.5, bins=np.arange(0, 10, 0.05))
 240
 241     plt.legend()
 242     plt.show()
 243
 244 if __name__ == "__main__":
 245     plot_costdist()