first commit

Projet Innovation/Franchissement.py

@@ -0,0 +1,238 @@
+import cv2
+#import numpy as np
+import time
+import sys
+
+#Hauteur des zones de détection.
+ymin=550
+ymax=551
+#Largeur de la zone de détection de gauche.
+xmin1=130
+xmax1=300
+#Largeur de la zone de détection de droite.
+xmin2=700
+xmax2=870
+
+
+#Fonction Point qui créée un point avec une position correspondant à celle du contour détecté.
+def point(capteur):
+    s1=len(capteur)-1
+    s2=len(capteur)-1
+    for i in range(len(capteur)):
+        if capteur[i]!=0:
+            s1=i
+            break
+    if s1!=len(capteur)-1:
+        for i in range(len(capteur)-1, s1-1, -1):
+            if capteur[i]!=0:
+                s2=i
+                break
+        return int((s1+s2)/2)
+    return -1
+
+
+#Variables
+s1_old=0
+s2_old=0
+s1=0
+s2=0
+s1_time=0
+s2_time=0
+
+#Seuils utilisés pour la fonction Canny (détection des contours)
+th1=75
+th2=150
+
+stop=0
+
+#Niveau de flou de l'image
+k=3
+
+#On commence par récupérer la vidéo à traiter.
+cap=cv2.VideoCapture("C:/Users/Pauline/Documents/INSA/5eme Année INSA ISS/Projet ISS/Video_Test.mp4")
+
+while True:
+    
+    if not stop:
+        #On ségmente la vidéo et on récupère les images, image par image.
+        ret, frame=cap.read()
+        
+        if ret is False:
+            sys.exit()
+        
+        image=frame.copy()
+
+#Detection de la ligne de gauche (avec une zone de détection).
+        #Je transforme mon image en gris (avec différentes nuances de gris).
+        #Pour ma zone de détection située à gauche.
+        gray1=cv2.cvtColor(image[ymin:ymax, xmin1:xmax1], cv2.COLOR_BGR2GRAY)
+        
+        if k!=1:
+            gray1=cv2.blur(gray1, (k, k))
+        
+        #La fonction Canny permet de détecter les contours des différents objets présents sur l'image.
+        #Elle prend en argument l'image transformée en gris et les deux seuils.
+        capteur1=cv2.Canny(gray1, th1, th2)
+
+#Detection de la ligne de droite (avec une zone de détection).
+        #Je transforme mon image en gris (avec différentes nuances de gris).
+        #Pour ma zone de détection située à droite.
+        gray2=cv2.cvtColor(image[ymin:ymax, xmin2:xmax2], cv2.COLOR_BGR2GRAY)
+        
+        if k!=1:
+            gray2=cv2.blur(gray2, (k, k))
+        
+        #La fonction Canny permet de détecter les contours des différents objets présents sur l'image.
+        #Elle prend en argument l'image transformée en gris et les deux seuils.
+        capteur2=cv2.Canny(gray2, th1, th2)
+
+        #Affichage des contours des deux zones de détection.
+        cv2.rectangle(image, (xmin1, ymin), (xmax1, ymax), (255, 0, 0), 1)
+        cv2.rectangle(image, (xmin2, ymin), (xmax2, ymax), (255, 0, 0), 1)
+
+#Pour palier à la détection qui vacile au niveau des lignes discontinus ainsi qu'à la venue d'éventuelles
+#erreurs. On va conserver l'information ligne détectée pendant une seconde après la dernière détection.
+#Cela nous permettra de ne pas considérer l'absence de ligne lorsqu'il s'agit simplement d'une ligne discontinue par exemple!
+
+#Capteur situé sur la zone de détection de gauche.
+        #Création d'un point dans la zone de détection qui désigne la position du contour détecté.
+        s1=point(capteur1[0])
+        
+        #Si un contour est détecté.
+        if s1!=-1:
+            #Affichage d'un point de couleur verte lorsque la zone détecte la ligne.
+            cv2.circle(image, (s1+xmin1, ymin), 3, (0, 255, 0), 3)
+            #On concerve l'information (ligne détectée).
+            s1_old=s1
+            #On enregistre le moment où la ligne a été détectée.
+            s1_time=time.time()
+        
+        else:
+            #Si le temps écoulé depuis la dernière perte de détection est inférieur à une seconde.
+            if time.time()-s1_time<1:
+                #Affichage d'un point de couleur jaune lorsque la zone ne détecte pas la ligne.
+                cv2.circle(image, (s1_old+xmin1, ymin), 3, (100, 255, 255), 3)
+                s1=s1_old
+            
+            #Pour un temps supérieur on ne concerve pas l'information (ligne détectée).
+            else:
+                s1=-1
+
+#Capteur situé sur la zone de détection de droite.
+        #Création d'un point dans la zone de détection qui désigne la position du contour détecté.
+        s2=point(capteur2[0])
+        
+        #Si un contour est détecté.
+        if s2!=-1:
+            #Affichage d'un point de couleur verte lorsque la zone détecte la ligne.
+            cv2.circle(image, (s2+xmin2, ymin), 3, (0, 255, 0), 3)
+            #On concerve l'information (ligne détectée).
+            s2_old=s2
+            #On enregistre le moment où la ligne a été détectée.
+            s2_time=time.time()
+        
+        else:
+            #Si le temps écoulé depuis la dernière perte de détection est inférieur à une seconde.
+            if time.time()-s2_time<1:
+                #Affichage d'un point de couleur jaune lorsque la zone ne détecte pas la ligne.
+                cv2.circle(image, (s2_old+xmin2, ymin), 3, (100, 255, 255), 3)
+                s2=s2_old
+            
+            #Pour un temps supérieur on ne concerve pas l'information (ligne détectée).
+            else:
+                s2=-1
+
+#Alerte du décalage à gauche ou à droite de la voiture sur la chaussée.
+        #Si un contour est détecté dans les deux zones de détection.
+        if s1!=-1 and s2!=-1:
+            #Variable permettant d'évaluer un décalage trop important à droite ou à gauche.
+            s2_=abs(xmax2-xmin2-s2)
+            
+            #Si un décalage trop important est observé d'un côté ou de l'autre de la voie.
+            if abs(s2_-s1)>20:
+                c=(0, max(0, 255-10*int(abs(s1-s2_)/2)), min(255, 10*int(abs(s1-s2_)/2)))
+                #Affichage d'un cercle de couleur variable en fonction d'un décalage plus ou moins conséquent.
+                cv2.circle(image, (int((xmax2-xmin1)/2)+xmin1, ymax-25), 5, c, 7)
+                #Affichage d'une flèche d'orientation et de couleur variable en fonction d'un décalage plus ou moins conséquent et de sa direction.
+                cv2.arrowedLine(image, (int((xmax2-xmin1)/2)+xmin1, ymax-25), (int((xmax2-xmin1)/2)+xmin1+2*int((s1-s2_)/2), ymax-25), c, 3, tipLength=0.4)
+            
+            #La voiture est bien centrée au milieu de sa voie.
+            else:
+                cv2.putText(image, "OK", (int((xmax2-xmin1)/2)+xmin1-15, ymax-16), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 255, 0), 1)
+
+#Renseignement à l'écran des valeurs de Seuil, de niveau de Flou, des touches d'Arrêt et Ajustement de la ligne de détection
+    cv2.putText(image, "Seuil 1: {:d} , Seuil 2: {:d} , Niveau de Flou: {:d}".format(th1, th2, k), (10, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 220, 255), 1)
+    cv2.putText(image, "Entrer 's' : STOP , Entrer 'q' : QUITTER", (10, 60), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 220, 255), 1)
+    cv2.putText(image, "Commandes d'Ajustement de la ligne de Detection", (50, 90), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 220, 255), 1)
+    cv2.putText(image, "Entrer 'm' : Abaisser la ligne de Detection , Entrer 'p' : Elever la ligne de Detection", (10, 120), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 220, 255), 1)
+    cv2.putText(image, "Entrer 'o' : Decaler vers la droite la ligne , Entrer 'l' : Decaler vers la gauche la ligne", (10, 150), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 220, 255), 1)
+    #Création fenêtre avec l'image de la vidéo et les annotions renseignées précédemment.
+    cv2.imshow("image", image)
+    
+    #Je transforme mon image en gris (avec différentes nuances de gris).
+    gray=cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    
+    if k!=1:
+        #Application du flou sur l'image.
+        gray=cv2.blur(gray, (k, k))
+    
+    #Création fenêtre avec l'image de la vidéo en niveaux de gris et floutée.
+    cv2.imshow("blur", gray)
+    
+    #La fonction Canny permet de détecter les contours des différents objets présents sur l'image.
+    gray_canny=cv2.Canny(gray, th1, th2)
+    #Création fenêtre avec l'image de la vidéo contourée grâce à la fonction Canny.
+    cv2.imshow("canny", gray_canny)
+
+    if not stop:
+        key=cv2.waitKey(20)&0xFF
+    
+    else:
+        key=cv2.waitKey()
+        image=frame.copy()
+
+    if key==ord('q'):
+        break
+    
+#Modification du positionnement des lignes de détection
+    if key==ord('m'):
+        ymin+=1
+        ymax+=1
+    if key==ord('p'):
+        ymin-=1
+        ymax-=1
+    if key==ord('o'):
+        xmin1+=1
+        xmax1+=1
+        xmin2+=1
+        xmax2+=1
+    if key==ord('l'):
+        xmin1-=1
+        xmax1-=1
+        xmin2-=1
+        xmax2-=1
+    
+#Modification des seuils de la fonction Canny et du niveau de flou
+    # if key==ord('y'):
+    #     k=min(255, k+2)
+    # if key==ord('h'):
+    #     k=max(1, k-2)
+    # if key==ord('u'):
+    #     th1=min(255, th1+1)
+    # if key==ord('j'):
+    #     th1=max(0, th1-1)
+    # if key==ord('i'):
+    #     th2=min(255, th2+1)
+    # if key==ord('k'):
+    #     th2=max(0, th2-1)
+    
+    if key==ord('s'):
+        stop=not stop
+        
+    # if key==ord('a'):
+    #     for cpt in range(200):
+    #         ret, frame=cap.read()
+    #         image=frame.copy()
+
+cap.release()
+cv2.destroyAllWindows()