]> rtime.felk.cvut.cz Git - hubacji1/iamcar.git/blobdiff - gplot.py
projects / hubacji1 / iamcar.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add FP as first node in slot cusps
[hubacji1/iamcar.git] / gplot.py
diff --git a/gplot.py b/gplot.py
index c3e89e30058cddfefe3e4a2ab68af62505e8a06b..0cc1168665b16ff3173d6eaf6b0005e82e6f209c 100644 (file)
--- a/gplot.py
+++ b/gplot.py
@@ -4,6 +4,26 @@ from json import loads
 from matplotlib import pyplot as plt
 from os import listdir
 from sys import argv, exit
 from matplotlib import pyplot as plt
 from os import listdir
 from sys import argv, exit
+import numpy as np
+import scipy.stats as ss
+
+# ed - euclidean distance
+# rs - reeds and shepp path length
+# sh - reeds and shepp, same heading
+
+# ad - optimize with dijkstra, all nodes
+# as - optimize with smart, all nodes
+# ar - optimize with remove redundant points, all nodes
+# cd - optimize with dijkstra, cusp nodes
+# cs - optimize with smart, cusp nodes
+# cr - optimize with remove redundant points, cusp nodes
+
+LOGF = "log_wo"
+LOG = [
+    {"f": "T2", "c": "orange", "l": "T2"},
+]
+
+r = {}
 
 def load_trajectory(fname):
     """Load trajectory from file.
 
 def load_trajectory(fname):
     """Load trajectory from file.
@@ -31,7 +51,7 @@ def load_trajectories(dname):
     return trajectories
 
 def gplot():
     return trajectories
 
 def gplot():
-    """Plot graph."""
+    """Plot graph. Template."""
     plt.rcParams["font.size"] = 24
     fig = plt.figure()
     ax = fig.add_subplot(111)
     plt.rcParams["font.size"] = 24
     fig = plt.figure()
     ax = fig.add_subplot(111)
@@ -51,6 +71,22 @@ def gplot():
     plt.show()
     #plt.savefig("WHATEVER")
 
     plt.show()
     #plt.savefig("WHATEVER")
 
+def mean_conf_int(data, conf=0.95):
+    """Return (mean, lower, uppper) of data.
+
+    see https://stackoverflow.com/questions/15033511/compute-a-confidence-interval-from-sample-data
+
+    Keyword arguments:
+    data -- A list of data.
+    conf -- Confidence interval.
+    """
+    a = np.array(data)
+    n = len(a)
+    m = np.mean(a)
+    se = ss.sem(a)
+    h = se * ss.t.ppf((1 + conf) / 2, n - 1)
+    return (m, m - h, m + h)
+
 def count_if_exist(trajectories, what):
     """From multiple trajectories compute the number of occurences.
 
 def count_if_exist(trajectories, what):
     """From multiple trajectories compute the number of occurences.
 
@@ -79,7 +115,7 @@ def get_lasts_if_exist(trajectories, what):
         try:
             val.append(t[what][-1])
         except:
         try:
             val.append(t[what][-1])
         except:
-            val.append(9999)
+            pass
     return val
 
 def get_maxs_if_exist(trajectories, what):
     return val
 
 def get_maxs_if_exist(trajectories, what):
@@ -94,53 +130,272 @@ def get_maxs_if_exist(trajectories, what):
         try:
             val.append(max(t[what]))
         except:
         try:
             val.append(max(t[what]))
         except:
-            val.append(9999)
+            pass
     return val
 
     return val
 
-def plot_successrate():
-    """Plot success rate of single/multi-core implementations."""
-    LOGF="logs_sq"
-    ALG=["Karaman2011", "Kuwata2008", "LaValle1998"]
-    ALGT={"Karaman2011": "RRT*",
-            "Kuwata2008": "RRT + heur",
-            "LaValle1998": "RRT"}
-    ST=["3", "4"]
-    STT={"3": "R&S", "4": "Sim"}
-    CO=["1", "2"]
-    COT={"1": "E2", "2": "R&S"}
-
-    r={}
-    for a in ALG:
-        for st in ST:
-            for co in CO:
-                r["{}, {}, {}".format(ALGT[a], STT[st], COT[co])] = (
-                        load_trajectories("{}/{}st{}co{}_lpar".format(
-                            LOGF, a, st, co)) +
-                        load_trajectories("{}/{}st{}co{}_rper".format(
-                            LOGF, a, st, co)))
+def get_val_if_exist(trajectories, what):
+    """From m ultiple trajectories get value.
 
 
-    v={}
+    Keyword arguments:
+    trajectories -- The list of trajectories.
+    what -- What to take.
+    """
+    val = []
+    for t in trajectories:
+        try:
+            val.append(t[what])
+        except:
+            pass
+    return val
+
+def plot_costdist():
+    """Plot distribution of last costs across measured tests."""
+    v = {}
     for a in r.keys():
     for a in r.keys():
-        v[a] = (100 * count_if_exist(r[a], "traj") /
-                count_if_exist(r[a], "elap"))
-    vs = sorted(v.items(), key=lambda kv: kv[1])
+        v[a] = get_lasts_if_exist(r[a], "cost")
 
 
-    plt.rcParams["font.size"] = 24
     fig = plt.figure()
     ax = fig.add_subplot(111)
     fig = plt.figure()
     ax = fig.add_subplot(111)
-    ax.set_title("Trajectories found in 20 seconds period (sequential)")
-
-    ax.set_ylabel("Framework tested [-]")
-    ax.set_xlabel("Found successfully [%]")
-    ax.set_xlim(0, 100)
-    ax.set_yticklabels([])
-    j = 0
-    for (k, i) in vs:
-        ax.barh(j, float(i), 4, label=k)
-        j += -5
-    ax.legend()
+    ax.set_title("Path cost histogram")
 
 
+    ax.set_ylabel("Number of paths with given cost [-]")
+    ax.set_xlabel("Path cost [m]")
+    ax.set_yscale("log")
+
+    for a in LOG:
+        plt.hist(
+                v[a["f"]],
+                alpha = 0.5,
+                label = a["l"],
+                bins = 100,
+                histtype = "step",
+                color = a["c"])
+        try:
+                X_WHERE = np.percentile(v[a["f"]], [95])
+                plt.axvline(X_WHERE, lw=1, color=a["c"], linestyle="--")
+        except:
+                pass
+
+    plt.legend()
     plt.show()
 
     plt.show()
 
+def plot_maxtime():
+    """Plot time of the last traj (the maximum time)."""
+    v = {}
+    for a in r.keys():
+        v[a] = get_lasts_if_exist(r[a], "secs")
+
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+    ax.set_title("Histogram of time to find the path")
+
+    ax.set_ylabel("Number of paths found [-]")
+    ax.set_xlabel("Algorithm computation time [s]")
+    ax.set_yscale("log")
+
+    for a in LOG:
+        plt.hist(
+                v[a["f"]],
+                alpha = 0.5,
+                label = a["l"],
+                bins = np.arange(0, 10, 0.1),
+                histtype = "step",
+                color = a["c"])
+        try:
+                X_WHERE = np.percentile(v[a["f"]], [95])
+                plt.axvline(X_WHERE, lw=1, color=a["c"], linestyle="--")
+        except:
+                pass
+
+    plt.legend()
+    plt.show()
+
+def plot_nothingdone():
+    """Plot *nothing done* time of ``overlaptrees`` procedure."""
+    v = {}
+    for a in r.keys():
+        v[a] = get_lasts_if_exist(r[a], "nodo")
+
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+    ax.set_title("Histogram of nothing-done-time")
+
+    ax.set_ylabel("Occurences [-]")
+    ax.set_xlabel("Nothing-done-time percentage [-]")
+
+    for a in LOG:
+        plt.hist(
+                v[a["f"]],
+                alpha = 0.5,
+                label = a["l"],
+                bins = np.arange(0, 1, 0.1),
+                histtype = "step",
+                color = a["c"])
+        try:
+                X_WHERE = np.percentile(v[a["f"]], [95])
+                plt.axvline(X_WHERE, lw=1, color=a["c"], linestyle="--")
+        except:
+                pass
+
+    plt.legend()
+    plt.show()
+
+def print_nofnodes():
+    """Print average number of nodes."""
+    v={}
+    for a in r.keys():
+        lasts = get_lasts_if_exist(r[a], "node")
+        v[a] = np.average(lasts)
+
+    print("Average number of nodes:")
+    for a in LOG:
+        print("{}: {}".format(a["f"], v[a["f"]]))
+
+def print_successrate():
+    """Print success rate of implementations."""
+    v={}
+    for a in r.keys():
+        v[a] = (100.0 * count_if_exist(r[a], "traj") /
+                count_if_exist(r[a], "elap"))
+
+    print("Success rate:")
+    for a in LOG:
+        print("{}: {}".format(a["f"], v[a["f"]]))
+
 if __name__ == "__main__":
 if __name__ == "__main__":
-    plot_successrate()
+    plt.rcParams["font.size"] = 29
+    res = []
+    LOGF = "log-slotplanner"
+    for d in listdir(LOGF):
+        r = {}
+        for sf in [i["f"] for i in LOG]:
+            r[sf] = load_trajectories("{}/{}/{}".format(LOGF, d, sf))
+            res.append({
+                "f": d,
+                "elap": get_val_if_exist(r["T2"], "elap"),
+                "rrte": get_val_if_exist(r["T2"], "rrte"),
+                "ppse": get_val_if_exist(r["T2"], "ppse"),
+                "succ": (
+                    count_if_exist(r["T2"], "traj") /
+                        count_if_exist(r["T2"], "elap")
+                ),
+            })
+    res2 = []
+    LOGF = "log-rrt"
+    for d in listdir(LOGF):
+        r = {}
+        for sf in [i["f"] for i in LOG]:
+            r[sf] = load_trajectories("{}/{}/{}".format(LOGF, d, sf))
+            res2.append({
+                "f": d,
+                "elap": get_val_if_exist(r["T2"], "elap"),
+                "rrte": get_val_if_exist(r["T2"], "rrte"),
+                "ppse": get_val_if_exist(r["T2"], "ppse"),
+                "succ": (
+                    count_if_exist(r["T2"], "traj") /
+                        count_if_exist(r["T2"], "elap")
+                ),
+            })
+
+    fig = plt.figure()
+    # For color scheme
+    # see https://github.com/vega/vega/wiki/Scales#scale-range-literals
+    ax = fig.add_subplot(111)
+    ax.set_title("""Elapsed time for different lengths
+                of parallel parking slot""")
+
+    ax.set_ylabel("Time [s]")
+    ax.set_xlabel("Parking slot length [m]")
+
+    # res Slot Planner
+    coord = [float(r["f"].split("_")[1]) for r in res]
+
+    #val = [sum(r["ppse"])/len(r["ppse"]) for r in res]
+    #fin = [(x, y) for (x, y) in zip(coord, val)]
+    #fin.sort()
+    #plt.plot(
+    #    [x for (x, y) in fin],
+    #    [y for (x, y) in fin],
+    #    color = "g",
+    #    label = "Slot Planner",
+    #)
+
+    val = [max(r["elap"]) for r in res]
+    fin = [(x, y) for (x, y) in zip(coord, val)]
+    fin.sort()
+    plt.plot(
+        [x for (x, y) in fin],
+        [y for (x, y) in fin],
+        color = "#e6550d",
+        linestyle = "--",
+        label = "Elapsed worst",
+    )
+
+    #val = [sum(r["rrte"])/len(r["rrte"]) for r in res]
+    #fin = [(x, y) for (x, y) in zip(coord, val)]
+    #fin.sort()
+    #plt.plot(
+    #    [x for (x, y) in fin],
+    #    [y for (x, y) in fin],
+    #    color = "#fd8d3c",
+    #    label = "RRT",
+    #)
+
+    val = [sum(r["elap"])/len(r["elap"]) for r in res]
+    fin = [(x, y) for (x, y) in zip(coord, val)]
+    fin.sort()
+    plt.plot(
+        [x for (x, y) in fin],
+        [y for (x, y) in fin],
+        color = "#e6550d",
+        label = "Elapsed average",
+    )
+
+    val = [r["succ"] for r in res]
+    fin = [(x, y) for (x, y) in zip(coord, val)]
+    fin.sort()
+    plt.plot(
+        [x for (x, y) in fin],
+        [y for (x, y) in fin],
+        #color = "#fd8d3c",
+        color = "#fdae6b",
+        label = "Success rate",
+    )
+
+    # res2 RRT
+    coord = [float(r["f"].split("_")[1]) for r in res2]
+
+    val = [max(r["elap"]) for r in res2]
+    fin = [(x, y) for (x, y) in zip(coord, val)]
+    fin.sort()
+    plt.plot(
+        [x for (x, y) in fin],
+        [y for (x, y) in fin],
+        color = "#3182bd",
+        linestyle = "--",
+        label = "Elapsed worst",
+    )
+
+    val = [sum(r["elap"])/len(r["elap"]) for r in res2]
+    fin = [(x, y) for (x, y) in zip(coord, val)]
+    fin.sort()
+    plt.plot(
+        [x for (x, y) in fin],
+        [y for (x, y) in fin],
+        color = "#3182bd",
+        label = "Elapsed average",
+    )
+
+    val = [r["succ"] for r in res2]
+    fin = [(x, y) for (x, y) in zip(coord, val)]
+    fin.sort()
+    plt.plot(
+        [x for (x, y) in fin],
+        [y for (x, y) in fin],
+        #color = "#6baed6",
+        color = "#9ecae1",
+        label = "Success rate",
+    )
+
+    plt.legend(bbox_to_anchor=(1, 1), loc=1, borderaxespad=0)
+    plt.show()