test Lane Detection

ColorPicker.py

@@ -0,0 +1,55 @@
+import cv2
+import numpy as np
+ 
+frameWidth = 640
+frameHeight = 480
+cap = cv2.VideoCapture(1)
+cap.set(3, frameWidth)
+cap.set(4, frameHeight)
+ 
+ 
+def empty(a):
+    pass
+ 
+cv2.namedWindow("HSV")
+cv2.resizeWindow("HSV", 640, 240)
+cv2.createTrackbar("HUE Min", "HSV", 0, 179, empty)
+cv2.createTrackbar("HUE Max", "HSV", 179, 179, empty)
+cv2.createTrackbar("SAT Min", "HSV", 0, 255, empty)
+cv2.createTrackbar("SAT Max", "HSV", 255, 255, empty)
+cv2.createTrackbar("VALUE Min", "HSV", 0, 255, empty)
+cv2.createTrackbar("VALUE Max", "HSV", 255, 255, empty)
+ 
+cap = cv2.VideoCapture('vid1.mp4')
+frameCounter = 0
+ 
+while True:
+    frameCounter +=1
+    if cap.get(cv2.CAP_PROP_FRAME_COUNT) ==frameCounter:
+        cap.set(cv2.CAP_PROP_POS_FRAMES,0)
+        frameCounter=0
+ 
+    _, img = cap.read()
+    imgHsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+ 
+    h_min = cv2.getTrackbarPos("HUE Min", "HSV")
+    h_max = cv2.getTrackbarPos("HUE Max", "HSV")
+    s_min = cv2.getTrackbarPos("SAT Min", "HSV")
+    s_max = cv2.getTrackbarPos("SAT Max", "HSV")
+    v_min = cv2.getTrackbarPos("VALUE Min", "HSV")
+    v_max = cv2.getTrackbarPos("VALUE Max", "HSV")
+    print(h_min)
+ 
+    lower = np.array([h_min, s_min, v_min])
+    upper = np.array([h_max, s_max, v_max])
+    mask = cv2.inRange(imgHsv, lower, upper)
+    result = cv2.bitwise_and(img, img, mask=mask)
+ 
+    mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
+    hStack = np.hstack([img, mask, result])
+    cv2.imshow('Horizontal Stacking', hStack)
+    if cv2.waitKey(1) and 0xFF == ord('q'):
+        break
+ 
+cap.release()
+cv2.destroyAllWindows()

LaneDetectionModule.py

@@ -0,0 +1,102 @@
+import cv2
+import numpy as np
+import utils
+
+
+curveList = []
+avgVal = 10
+
+def getLaneCurve(img, display = 2):
+
+    imgCopy = img.copy()
+    imgResult = img.copy()
+    #### STEP 1
+    imgThres = utils.thresholding(img)
+    
+    #### STEP 2
+    hT, wT, c = img.shape
+    points = utils.valTrackbars()
+    imgWarp = utils.warpImg(imgThres, points, wT, hT)
+    imgWarpPoints = utils.drawPoints(imgCopy, points)
+
+    #### STEP 3
+    middlePoint,imgHist = utils.getHistogram(imgWarp,display=True,minPer=0.5,region=4)
+    curveAveragePoint, imgHist = utils.getHistogram(imgWarp, display=True, minPer=0.9)
+    curveRaw = curveAveragePoint - middlePoint
+    
+    #### STEP 4
+    curveList.append(curveRaw)
+    if len(curveList)>avgVal:
+        curveList.pop(0)
+    curve = int(sum(curveList)/len(curveList))
+    '''
+    cv2.imshow('Thres', imgThres)
+    cv2.imshow('Warp', imgWarp)
+    cv2.imshow('Warp Points', imgWarpPoints)
+    cv2.imshow('Histogram', imgHist)
+    return None
+    '''
+     #### STEP 5
+    if display != 0:
+        imgInvWarp = utils.warpImg(imgWarp, points, wT, hT, inv=True)
+        imgInvWarp = cv2.cvtColor(imgInvWarp, cv2.COLOR_GRAY2BGR)
+        imgInvWarp[0:hT // 3, 0:wT] = 0, 0, 0
+        imgLaneColor = np.zeros_like(img)
+        imgLaneColor[:] = 0, 255, 0
+        imgLaneColor = cv2.bitwise_and(imgInvWarp, imgLaneColor)
+        imgResult = cv2.addWeighted(imgResult, 1, imgLaneColor, 1, 0)
+        midY = 450
+        cv2.putText(imgResult, str(curve), (wT // 2 - 80, 85), cv2.FONT_HERSHEY_COMPLEX, 2, (255, 0, 255), 3)
+        cv2.line(imgResult, (wT // 2, midY), (wT // 2 + (curve * 3), midY), (255, 0, 255), 5)
+        cv2.line(imgResult, ((wT // 2 + (curve * 3)), midY - 25), (wT // 2 + (curve * 3), midY + 25), (0, 255, 0), 5)
+        for x in range(-30, 30):
+            w = wT // 20
+            cv2.line(imgResult, (w * x + int(curve // 50), midY - 10),
+                     (w * x + int(curve // 50), midY + 10), (0, 0, 255), 2)
+        #fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer);
+        #cv2.putText(imgResult, 'FPS ' + str(int(fps)), (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (230, 50, 50), 3);
+    if display == 2:
+        imgStacked = utils.stackImages(0.7, ([img, imgWarpPoints, imgWarp],
+                                             [imgHist, imgLaneColor, imgResult]))
+        cv2.imshow('ImageStack', imgStacked)
+    elif display == 1:
+        cv2.imshow('Resutlt', imgResult)
+
+    '''
+    cv2.imshow('Thres', imgThres)
+    cv2.imshow('Warp', imgWarp)
+    cv2.imshow('Warp Points', imgWarpPoints)
+    cv2.imshow('Histogramp', imgHist)
+    '''
+    #### NORMALIZATION
+    curve = curve/100
+    if curve>1: curve ==1
+    if curve<-1:curve == -1
+ 
+    return curve
+
+    
+
+if __name__ == '__main__':
+    cap = cv2.VideoCapture('vid1.mp4')
+    initialTrackBarVals = [116, 138, 20, 232]
+    utils.initializeTrackbars(initialTrackBarVals)
+    frameCounter = 0
+    curveList = []
+
+    while True:
+        frameCounter +=1
+        if cap.get(cv2.CAP_PROP_FRAME_COUNT) ==frameCounter:
+            cap.set(cv2.CAP_PROP_POS_FRAMES,0)
+            frameCounter=0
+
+        success, img = cap.read()
+        img = cv2.resize(img,(480,240))
+        curve = getLaneCurve(img, display = 1)
+        print(curve)
+        #cv2.imshow('Vid', img)
+        cv2.waitKey(1)
+
+
+
+

utils.py

@@ -0,0 +1,104 @@
+import cv2
+import numpy as np
+
+
+
+def thresholding(img):
+    imgHsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
+    lowerWhite = np.array([19,0,150])
+    upperWhite = np.array([170,70,255])
+    maskWhite = cv2.inRange(imgHsv,lowerWhite,upperWhite)
+    return maskWhite
+
+def warpImg(img,points,w,h,inv = False):
+    pts1 = np.float32(points)
+    pts2 = np.float32([[0,0],[w,0],[0,h],[w,h]])
+    if inv:
+        matrix = cv2.getPerspectiveTransform(pts2, pts1)
+    else:
+        matrix = cv2.getPerspectiveTransform(pts1,pts2)
+    imgWarp = cv2.warpPerspective(img,matrix,(w,h))
+    return imgWarp
+ 
+def nothing(a):
+    pass
+ 
+def initializeTrackbars(intialTracbarVals,wT=480, hT=240):
+    cv2.namedWindow("Trackbars")
+    cv2.resizeWindow("Trackbars", 360, 240)
+    cv2.createTrackbar("Width Top", "Trackbars", intialTracbarVals[0],wT//2, nothing)
+    cv2.createTrackbar("Height Top", "Trackbars", intialTracbarVals[1], hT, nothing)
+    cv2.createTrackbar("Width Bottom", "Trackbars", intialTracbarVals[2],wT//2, nothing)
+    cv2.createTrackbar("Height Bottom", "Trackbars", intialTracbarVals[3], hT, nothing)
+ 
+def valTrackbars(wT=480, hT=240):
+    widthTop = cv2.getTrackbarPos("Width Top", "Trackbars")
+    heightTop = cv2.getTrackbarPos("Height Top", "Trackbars")
+    widthBottom = cv2.getTrackbarPos("Width Bottom", "Trackbars")
+    heightBottom = cv2.getTrackbarPos("Height Bottom", "Trackbars")
+    points = np.float32([(widthTop, heightTop), (wT-widthTop, heightTop),
+                      (widthBottom , heightBottom ), (wT-widthBottom, heightBottom)])
+    return points
+ 
+def drawPoints(img,points):
+    for x in range(4):
+        cv2.circle(img,(int(points[x][0]),int(points[x][1])),15,(0,0,255),cv2.FILLED)
+    return img
+
+
+def getHistogram(img,minPer=0.1,display= False,region=1):
+ 
+    if region == 1:
+        histValues = np.sum(img, axis= 0)
+    else:
+        histValues = np.sum(img[img.shape[0]//region:,:], axis = 0)
+    
+ 
+    maxValue = np.max(histValues)
+    minValue = minPer*maxValue
+
+    indexArray = np.where(histValues >= minValue)
+    basePoint = int(np.average(indexArray))
+    #print(basePoint)
+
+    if display:
+        imgHist = np.zeros((img.shape[0],img.shape[1],3),np.uint8)
+        for x,intensity in enumerate(histValues):
+            cv2.line(imgHist,(x,img.shape[0]),(x,img.shape[0]-intensity//255//region),(255,0,255),1)
+            cv2.circle(imgHist,(basePoint,img.shape[0]),20,(0,255,255),cv2.FILLED)
+            
+        return basePoint,imgHist
+ 
+    return basePoint
+
+
+def stackImages(scale,imgArray):
+    rows = len(imgArray)
+    cols = len(imgArray[0])
+    rowsAvailable = isinstance(imgArray[0], list)
+    width = imgArray[0][0].shape[1]
+    height = imgArray[0][0].shape[0]
+    if rowsAvailable:
+        for x in range ( 0, rows):
+            for y in range(0, cols):
+                if imgArray[x][y].shape[:2] == imgArray[0][0].shape [:2]:
+                    imgArray[x][y] = cv2.resize(imgArray[x][y], (0, 0), None, scale, scale)
+                else:
+                    imgArray[x][y] = cv2.resize(imgArray[x][y], (imgArray[0][0].shape[1], imgArray[0][0].shape[0]), None, scale, scale)
+                if len(imgArray[x][y].shape) == 2: imgArray[x][y]= cv2.cvtColor( imgArray[x][y], cv2.COLOR_GRAY2BGR)
+        imageBlank = np.zeros((height, width, 3), np.uint8)
+        hor = [imageBlank]*rows
+        hor_con = [imageBlank]*rows
+        for x in range(0, rows):
+            hor[x] = np.hstack(imgArray[x])
+        ver = np.vstack(hor)
+    else:
+        for x in range(0, rows):
+            if imgArray[x].shape[:2] == imgArray[0].shape[:2]:
+                imgArray[x] = cv2.resize(imgArray[x], (0, 0), None, scale, scale)
+            else:
+                imgArray[x] = cv2.resize(imgArray[x], (imgArray[0].shape[1], imgArray[0].shape[0]), None,scale, scale)
+            if len(imgArray[x].shape) == 2: imgArray[x] = cv2.cvtColor(imgArray[x], cv2.COLOR_GRAY2BGR)
+        hor= np.hstack(imgArray)
+        ver = hor
+    return ver