gipps

.gitignore

@@ -1,3 +1,5 @@
 *.avi
 .vscode
-.DS_Store
+.DS_Store
+__pycache__
+gipps/result

gipps/gipps.py

@@ -2,10 +2,11 @@ import numpy as np
 import matplotlib.pyplot as plt
 import time
 from colour import Color
+import imagesV1 as images
 
 # ===========
 t0 = 0
-tf = 30
+tf = 40
 dt = 1
 t = t0
 # ===========
@@ -25,6 +26,7 @@ An = 1.7 # accel max                                          sampled from a nor
 Bn = -2 * An # frein max                                          equated to - 2An
 Sn =  6.5 # taille de la voiture plus marge                    sampled from a normal distribution. N(6.5,0.3²) m
 Vd = 20.0 # vitesse désirée                                    sampled from a normal distribution. N(20.0,3.2²) m/sec
+Vmin = 1
 # X*n # position fin de freinage (calculable)
 Tr = 2/3 + (2/3)/2 # temps de réaction + sûreté                 (= tau + θ = 2/3 + tau/2)
 # B supposé égal à Bn-1 (si pas égal alors amplifications ??)
@@ -40,83 +42,85 @@ def rainbow_gradient(num_colors):
     return colors
 colors = rainbow_gradient(nbv)
 
-def px(xx):             # Avance au cours du temps
-    xx += 1
-    return xx
+def px(tt):             # Avance au cours du temps
+    tt += 1
+    return tt
 
-def vitesseatt(t, yy):       # Vitesse qu'il peut réellement atteindre d'un point de vue dynamique
-
-
-
-    Vnt = yy[-1]
-    
-    value = Vnt + 2.5 * An * Tr * ( 1 - (Vnt/Vd) ) * np.sqrt( ( 0.025 + (Vnt/Vd) ))
-    print('value: ', value)
-
-    yy[0] = value
-    newyy = yy
-    print('newyy: ', newyy)
-    return newyy
+def vitesseatt(vtold):       # Vitesse qu'il peut réellement atteindre d'un point de vue dynamique
+    value = vtold + 2.5 * An * Tr * ( 1 - (vtold/Vd) ) * np.sqrt( ( 0.025 + (vtold/Vd) ))
+    return value
     
 
-def vitesseadop(t, yy):      # Vitesse qu'il est possible d'adopter en connaissant les contraintes de sécurité liées à la présence du véhicule leader
-    t = t + Tr
-    pass
+def vitesseadop(vtold, xxpold):      # Vitesse qu'il est possible d'adopter en connaissant les contraintes de sécurité liées à la présence du véhicule leader
+    dst = np.diff(xxpold)
+    value = Bn * Tr + np.sqrt( ((Bn)**2) * ((Tr)**2) - Bn * ( 2 * dst) - vtold[0] * Tr - ( (xxold[-1])**2 / Bn )  )
+    newvalue = np.insert(value, 1, vtold[1])
+    print('newvalue: ', newvalue)
+    return newvalue
 
-def vitessereelle(t, yyold):    # Vitesse du véhicule
-    print(len(yy))
-    t = t + Tr
-    if (t>= 0) and (t<=10):
-        yy[-1] = 0              # Arrêt du leader
-    elif (t>= 15) and (t<=20):
-
-    else:
-        yy[-1] = Vd           # Leader avance normalement
-
-
-# a = np.where(t <= 10, (Umax - Umin) / 10, - (Umax - Umin) / 10)
-# vt = np.where(t <= 10, Umin + a * t, Umax + 2 * a * (t - 10))
+def vitessereelle(t, vtold, xxpold):    # Vitesse du véhicule
+    t+=t
+    if t==0:
+        vtold[-1] = 0.1
+    elif (t> 0) and (t<=10):     # Accélération du leader
+        a = (Vd - Vmin) / 10
+        vtleader = Vmin + a * t
+        vtold[-1] = vtleader
+    elif (t>= 16) and (t<=20):  # Leader freine
+        a = - (Vd - Vmin) / 10
+        vtleader = Vd + 2 * a * (t - 16)
+        vtold[-1] = vtleader
+    elif (t>= 20) and (t<=30):  # Accélération du leader
+        a = (Vd - Vmin) / 10
+        vtleader = Vmin + a * (t-20)
+        vtold[-1] = vtleader
+    else:                   # Leader avance normalement
+        vtold[-1] = Vd
+    
+    vatt = vitesseatt(vtold)
+    vadop = vitesseadop(vtold, xxpold)
+    minimum = np.minimum(vatt, vadop)
+    print('minimum: ', minimum)
+    return minimum
 
 
 
+def position(fposition, newv):
+    newp = fposition + newv * dt
+    return newp
 
-    vatt = vitesseatt(t, yyold)
-    vadop = vitesseadop(t, yyold)
-    # return min(vatt, vadop)
-    return vatt
-
-
-xxbase = np.linspace(-nbv, -1, nbv)
-yybase = np.linspace(0, 0, nbv)
+xxbase = np.linspace(-nbv, 1, nbv)
+xxpbase = np.linspace(0, 1, nbv)
+yybase = np.linspace(0, 1, nbv)
 
 xxold = xxbase.copy()
-yyold = yybase.copy()
+xxpold = xxpbase.copy()
+vtold = yybase.copy()
 
 while(t<tf):
     plt.figure(1,figsize=[16,9])
     plt.clf()
-    plt.xlim([-1,31])
+    plt.xlim([-1,41])
     plt.ylim([-0.5, Vd+1])
     
-    
     xx = px(xxold)
-    print('xx: ', len(xx))
 
-    yy = vitessereelle(t, yyold)
-    print('yyold: ', len(yyold))
-    print('yy: ', len(yy))
+    vt = vitessereelle(t, vtold, xxpold)
 
-    
-    plt.scatter(xx, yy, c=colors)
+    xxp = position(xxpold, vt)
 
+    plt.scatter(xx, vt, c=colors)
 
-    plt.plot([0,30],[Vd, Vd], color='k', linestyle='-', linewidth=1)
+    plt.plot([0,40],[Vd, Vd], color='k', linestyle='-', linewidth=1)
     plt.xlabel('temps en s')
     plt.ylabel('vitesse en m.s-¹')
-    plt.title('Vitesse maximale désirée\nvitesse du leader : ' + str(Vd) + 'm.s-¹\ndistance minimale entre deux voitures : ' + str('') + 'm\n\nTemps : ' + str(t))
+    plt.title('Vitesse maximale désirée\nvitesse du leader : ' + str(Vd) + 'm.s-¹\ndistance entre deux voitures : ' + str(np.diff(xxpold)) + 'm\n\nTemps : ' + str(t))
     plt.draw()
-    # plt.savefig(str(t)+'.png')
-    plt.pause(1)
-    t += dt
+    plt.savefig('gipps/result/' + str(t)+'.png', transparent=True)
+    plt.pause(0.1)
+    t += dt/4
     xxold = xx.copy()
-    yyold = yy.copy()
+    xxpold = xxp.copy()
+    vtold = vt.copy()
+
+images.merge()

gipps/gippsV2.py

@@ -0,0 +1,130 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import time
+from colour import Color
+import imagesV2 as images
+
+fps = 4
+
+# ===========
+t0 = 0
+tf = 40
+dt = 1
+t = t0
+# ===========
+nbv = 2
+
+"""# ===========       VARIABBLES
+Xn(t) # position au temps t
+Vn(t) # vitesse au temps t
+An(t+Tr) # accel au temps t + Tr
+ln # ?
+k # ?
+m # ?
+"""
+
+# ===========       CONSTANTES
+An = 1.7 # accel max                                          sampled from a normal distribution. N(1.7,0.3²) m/s²
+Bn = -2 * An # frein max                                          equated to - 2An
+Sn =  6.5 # taille de la voiture plus marge                    sampled from a normal distribution. N(6.5,0.3²) m
+Vd = 20.0 # vitesse désirée                                    sampled from a normal distribution. N(20.0,3.2²) m/sec
+Vmin = 1
+# X*n # position fin de freinage (calculable)
+Tr = 2/3 + (2/3)/2 # temps de réaction + sûreté                 (= tau + θ = 2/3 + tau/2)
+# B supposé égal à Bn-1 (si pas égal alors amplifications ??)
+
+
+def rainbow_gradient(num_colors):
+    colors = []
+    base_color = Color("violet")
+    gradient = list(base_color.range_to(Color("red"), num_colors))
+    for color in gradient:
+        hex_code = color.hex_l
+        colors.append(hex_code)
+    return colors
+colors = rainbow_gradient(nbv)
+
+def px(tt):             # Avance au cours du temps
+    tt += 1/fps
+    return tt
+
+def vitesseatt(vtold):       # Vitesse qu'il peut réellement atteindre d'un point de vue dynamique
+    value = vtold + 2.5 * An * Tr * ( 1 - (vtold/Vd) ) * np.sqrt( ( 0.025 + (vtold/Vd) ))
+    return value
+    
+
+def vitesseadop(vtold, xxpold):      # Vitesse qu'il est possible d'adopter en connaissant les contraintes de sécurité liées à la présence du véhicule leader
+    dst = np.diff(xxpold)
+    value = Bn * Tr + np.sqrt( ((Bn)**2) * ((Tr)**2) - Bn * ( 2 * dst) - vtold[0] * Tr - ( (xxold[-1])**2 / Bn )  )
+    newvalue = np.insert(value, 1, vtold[1])
+    print('newvalue: ', newvalue)
+    return newvalue
+
+def vitessereelle(t, vtold, xxpold):    # Vitesse du véhicule
+    
+    if t==0:
+        vtold[-1] = 0.1
+    elif (t> 0) and (t<=10):     # Accélération du leader
+        a = (10 - Vmin) / 10
+        vtleader = Vmin + a * t
+        vtold[-1] = vtleader
+    elif (t>= 16) and (t<=20):  # Leader freine
+        a = - (10 - Vmin) / 10
+        vtleader = 10 + 2 * a * (t - 16)
+        vtold[-1] = vtleader
+    elif (t> 20) and (t<=29):  # Accélération du leader
+        a = (Vd - Vmin) / 10
+        vtleader = Vmin + a * (t-19)
+        vtold[-1] = vtleader
+    elif (t> 29) and (t<=40):  # Accélération du leader
+        vtold[-1] = 20
+    else:                   # Leader avance normalement
+        vtold[-1] = 10  
+    
+    vatt = vitesseatt(vtold)
+    vadop = vitesseadop(vtold, xxpold)
+    minimum = np.minimum(vatt, vadop)
+    print('minimum: ', minimum)
+    return minimum
+
+
+
+def position(fposition, newv):
+    newp = fposition + newv * dt
+    return newp
+
+xxbase = np.linspace(-nbv, 1, nbv)
+xxpbase = np.linspace(0, 1, nbv)
+yybase = np.linspace(0, 1, nbv)
+
+xxold = xxbase.copy()
+xxpold = xxpbase.copy()
+vtold = yybase.copy()
+
+while(t<tf):
+    plt.figure(1,figsize=[16,9])
+    plt.clf()
+    plt.xlim([-1,41])
+    plt.ylim([-0.5, Vd+1])
+    
+    xx = px(xxold)
+
+    vt = vitessereelle(t, vtold, xxpold)
+
+    xxp = position(xxpold, vt)
+
+    plt.scatter(xx, vt, c=colors)
+
+    plt.plot([0,40],[Vd, Vd], color='k', linestyle='-', linewidth=1)
+    plt.xlabel('temps en s')
+    plt.ylabel('vitesse en m.s-¹')
+    plt.title('Vitesse maximale désirée\nvitesse du leader : ' + str(Vd) + 'm.s-¹\ndistance entre deux voitures : ' + str(np.diff(xxpold)) + 'm\n\nTemps : ' + str(t))
+    plt.draw()
+    plt.savefig('gipps/result/' + str(int(t * fps))+'.png', transparent=True)
+    # plt.pause(0.1)
+    t += dt/fps
+    xxold = xx.copy()
+    xxpold = xxp.copy()
+    vtold = vt.copy()
+
+images.merge(fps)

gipps/graph.py

@@ -11,12 +11,12 @@ Tr = 2/3 + (2/3)/2 # temps de réaction + sûreté                 (= tau + θ =
 # B supposé égal à Bn-1 (si pas égal alors amplifications ??)
 
 
-vv = np.linspace(0, 100, 200)
+vv = np.linspace(0, 36, 200)
 
 def vitesseatt(vv):       # Vitesse qu'il peut réellement atteindre d'un point de vue dynamique
     value = vv + 2.5 * An * Tr * ( 1 - (vv/Vd) ) * np.sqrt( ( 0.025 + (vv/Vd) ))
     return value
-    
+
 
 def vitesseadop(vv):      # Vitesse qu'il est possible d'adopter en connaissant les contraintes de sécurité liées à la présence du véhicule leader
     value = 1
@@ -27,17 +27,26 @@ def vitessereelle(vv):      # Vitesse maximale désirée
     vadop = vitesseadop(vv)
     return min(vatt, vadop)
 
+def plotter(nb):
+    plt.plot([0,nb],[vitesseatt(nb), vitesseatt(nb)], color='k', linestyle='-', linewidth=1)
+    plt.plot([nb, nb],[0, vitesseatt(nb)], color='k', linestyle='-', linewidth=1)
+    plt.scatter(nb, vitesseatt(nb))
+
 plt.figure(figsize=[16,9])
+plt.xlim([0, 37])
+plt.ylim([0, 35])
 
-
-plt.plot(vv, vitesseatt(vv), '-', color='red', label='No mask')
+plt.plot(vv, vitesseatt(vv), '-', color='red', label="Vitesse qu'il peut réellement atteindre d'un point de vue dynamique")
 # plt.plot(vv, vitesseadop(vv), '-', color='green', label='No mask')
 
+plotter(10)
+plotter(20)
+plotter(30)
 
 plt.legend()
-plt.title('Variation de la vitesse de la voiture suivant en fonction de la voiture leader')
+plt.title('Variation de la vitesse de la voiture suivant en fonction de la voiture leader (première partie du modèle de Gipps)')
 plt.xlabel('vitesse de la voiture leader en m.s-¹')
 plt.ylabel('vitesse de la voiture qui suit en m.s-¹')
 plt.savefig('gipps/graph.png')
-plt.draw()  
+plt.draw()
 plt.pause(4)

gipps/imagesV1.py

@@ -0,0 +1,42 @@
+from PIL import Image
+import os
+import shutil
+
+try:os.remove('gipps/merged.png')
+except:pass
+
+def merge_images(overlay_folder, output_path):
+    overlay_path = f"{overlay_folder}/1.png"
+    overlay = Image.open(overlay_path)
+    result_width, result_height = overlay.size
+    result = Image.new('RGB', (result_width, result_height), color=(255, 255, 255))
+    x, y = 0, 0
+    for i in range(1,40):
+        overlay_path = f"{overlay_folder}/{i}.png"
+        overlay = Image.open(overlay_path)
+        result.paste(overlay, (x, y), overlay)
+    result.save(output_path)
+
+def detrf(folder_path):
+    try:
+        if os.path.exists(folder_path):
+            shutil.rmtree(folder_path)
+            print(f"Folder '{folder_path}' successfully deleted.")
+        else:
+            print(f"Folder '{folder_path}' does not exist.")
+
+        try:
+            os.makedirs(folder_path)
+            print(f"Folder '{folder_path}' successfully created.")
+        except OSError as e:
+            print(f"Error creating folder: {e}")
+
+    except OSError as e:
+        print(f"Error deleting folder: {e}")
+
+def merge(fps):
+    overlay_folder = "gipps/result"
+    output_path = "gipps/merged.png"
+    merge_images(overlay_folder, output_path)
+    detrf('gipps/result')
+    print('merge done')

gipps/imagesV2.py

@@ -0,0 +1,42 @@
+from PIL import Image
+import os
+import shutil
+
+try:os.remove('gipps/merged.png')
+except:pass
+
+def merge_images(overlay_folder, output_path, fps):
+    overlay_path = f"{overlay_folder}/1.png"
+    overlay = Image.open(overlay_path)
+    result_width, result_height = overlay.size
+    result = Image.new('RGB', (result_width, result_height), color=(255, 255, 255))
+    x, y = 0, 0
+    for i in range(1,40*fps):
+        overlay_path = f"{overlay_folder}/{i}.png"
+        overlay = Image.open(overlay_path)
+        result.paste(overlay, (x, y), overlay)
+    result.save(output_path)
+
+def detrf(folder_path):
+    try:
+        if os.path.exists(folder_path):
+            shutil.rmtree(folder_path)
+            print(f"Folder '{folder_path}' successfully deleted.")
+        else:
+            print(f"Folder '{folder_path}' does not exist.")
+
+        try:
+            os.makedirs(folder_path)
+            print(f"Folder '{folder_path}' successfully created.")
+        except OSError as e:
+            print(f"Error creating folder: {e}")
+
+    except OSError as e:
+        print(f"Error deleting folder: {e}")
+
+def merge(fps):
+    overlay_folder = "gipps/result"
+    output_path = "gipps/merged.png"
+    merge_images(overlay_folder, output_path, fps)
+    detrf('gipps/result')
+    print('merge done')

modelv.py

@@ -53,7 +53,6 @@ while(t<tf):
     xx = position(xxold, vt)
     # color = ['#ff0000', '#ff5300', '#ffa500', '#ffd200', '#ffff00', '#80c000', '#008000', '#004080', '#0000ff', '#2600c1', '#4b0082']
     plt.scatter(xx, vt)
-    print(xx)
     plt.scatter(xx, y, c=colors)
     plt.plot([0,20],[1.25, 1.25], color='k', linestyle='-', linewidth=1)
     plt.xlabel('distance w  en m')

pipes/dist sécurité.py

@@ -1,5 +1,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
 
 vt = 1.25  # 4,5 km/h
 Umin = 1  # vitesse m/s
@@ -10,20 +11,54 @@ t = np.linspace(0, 15, 400)
 def vitesse(t):
     a = np.where(t <= 10, (Umax - Umin) / 10, - (Umax - Umin) / 10)
     vt = np.where(t <= 10, Umin + a * t, Umax + 2 * a * (t - 10))
+    print('vt: ', vt)
     return vt
 
 
 def security(t):
     vt = vitesse(t)
+    # ici la vitesse est encore en m/s
+    miles_per_meter = 0.000621371
+    seconds_per_hour = 3600
+    vt = vt * miles_per_meter * seconds_per_hour
     dist = Wm * (1 + (vt/(16.1/3.6)))
     # print(dist)
     return dist
 
-plt.figure(figsize=[16, 9])
-plt.xlim([-1,16])
-plt.xlabel('temps (s)')
-plt.ylabel('distance de sécurité (m)')
-plt.plot(t, security(t))
+# plt.figure(figsize=[16, 9])
+# plt.xlim([-1,16])
+# plt.xlabel('temps (s)')
+# plt.ylabel('Distance de sécurité en m et Vitesse en m/s')
+# plt.plot(t, security(t), label='Distance de sécurité')
+# plt.plot(t, vitesse(t), label='Vitesse de la voiture leader')
+# plt.legend()
+# plt.savefig('pipes/dist sécurités.png')
+# plt.draw()
+# plt.pause(5)
+
+
+fig, ax1 = plt.subplots(figsize=[16, 9])
+ax1.set_xlim([-1, 16])
+ax1.set_xlabel('temps (s)')
+ax1.set_ylabel('Distance de sécurité en m', color='b')
+ax1.plot(t, security(t), label='Distance de sécurité', color='b')
+ax1.tick_params(axis='y', labelcolor='b')
+
+ax2 = ax1.twinx()
+ax2.set_ylabel('Vitesse de la voiture leader en m/s', color='r')
+vitesse_data = vitesse(t)
+ax2.plot(t, vitesse_data, label='Vitesse de la voiture leader', color='r')
+ax2.tick_params(axis='y', labelcolor='r')
+
+
+ax1.set_ylim(-1, 100)
+ax2.set_ylim(-1, 100)
+
+ax1.yaxis.set_major_locator(ticker.LinearLocator(numticks=10))
+ax2.yaxis.set_major_locator(ticker.LinearLocator(numticks=10))
+
+plt.title(label='Variation de la distance de sécurité en fonction de la vitesse du leader selon le modèle de Pipes')
+fig.legend(loc='upper right')
 plt.savefig('pipes/dist sécurités.png')
 plt.draw()
 plt.pause(5)