人工智能系统在自动驾驶汽车中的应用

    import cv2 as cv
    
    cap = cv.VideoCapture(0) # 打开摄像头
    
    while cap.isOpened():
    ret, frame = cap.read()
    
    if not ret:
        break
    
    hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV) # 将图片转换到HSV色彩空间
    lower_blue = np.array([90,50,50]) 
    upper_blue = np.array([130,255,255]) 
    
    mask = cv.inRange(hsv, lower_blue, upper_blue) # 找到蓝色范围
    res = cv.bitwise_and(frame, frame, mask=mask) # 在蓝色区域显示为白色，其他区域显示为黑色
    
    cv.imshow("camera", res) # 显示视频
    
    k = cv.waitKey(5) & 0xFF # 检查键盘按键
    if k == ord('q'):
        break
    
    cv.destroyAllWindows() # 关闭窗口
    cap.release() # 释放摄像头资源
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    import numpy as np
    from PIL import Image
    import cv2
    import os
    
    def yolo_detect(img):
    
    model_cfg='yolov4.cfg'
    weights='yolov4.weights'
    class_names=['person', 'bicycle', 'car','motorcycle', 'airplane',
                 'bus', 'train', 'truck', 'boat', 'traffic light',
                 'fire hydrant', '','stop sign', 'parking meter', 'bench']
    
    net = cv2.dnn.readNetFromDarknet(model_cfg, weights)
    ln = net.getLayerNames()
    ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]
    
    hsv_min = np.array((0., 0., 0.))
    hsv_max = np.array((180., 255., 255.))
    img_pil = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    blob = cv2.dnn.blobFromImage(img, 1/255.0, (416, 416),
                                 swapRB=True, crop=False)
    net.setInput(blob)
    layerOutputs = net.forward(ln)
    
    boxes = []
    confidences = []
    classIDs = []
    
    for output in layerOutputs:
        for detection in output:
            scores = detection[5:]
            classID = np.argmax(scores)
            confidence = scores[classID]
    
            if confidence > 0.5:
                box = detection[:4]*np.array([w,h,w,h])
                (centerX, centerY, width, height) = box.astype("int")
    
                x = int(centerX - (width / 2))
                y = int(centerY - (height / 2))
    
                boxes.append([x,y,int(width),int(height)])
                confidences.append(float(confidence))
                classIDs.append(classID)
    
    indices = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
    
    font = cv2.FONT_HERSHEY_SIMPLEX
    colors = pkl.load(open("./pallete","rb"))
    
    for i in indices:
        i = i[0]
        box = boxes[i]
        x = box[0]
        y = box[1]
        w = box[2]
        h = box[3]
    
        color = colors[classIDs[i]]
    
        cv2.rectangle(img, (x,y), (x+w,y+h), color, 2)
        text = "{} {:.4f}".format(class_names[classIDs[i]],confidences[i])
        cv2.putText(img,text,(x,y-5), font, 0.5,color,2)
    
    return img
    
    if __name__=='__main__':
    
    video_capture = cv2.VideoCapture(0)
    
    while True:
        _, frame = video_capture.read()
        result = yolo_detect(frame)
    
        cv2.namedWindow("Detections", cv2.WINDOW_NORMAL)
        cv2.resizeWindow("Detections", 800, 600)
        cv2.imshow("Detections", result)
        key = cv2.waitKey(1)
        if key == ord("q"):
            break
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    import pandas as pd
    import datetime
    
    class trafficStat:
    
    def __init__(self, timeSpan, databaseName="traffic.csv"):
        self.timeSpan = timeSpan
        self.databaseName = databaseName
        self.createDatabaseTable()
    
    def createDatabaseTable(self):
        columns = ["Time", "CarCount"]
        df = pd.DataFrame(columns=columns)
        df.to_csv(self.databaseName, index=False)
    
    def recordTraffic(self, count):
        now = str(datetime.datetime.now())
        data = {"Time":now,"CarCount":count}
        with open(self.databaseName,'a') as f:
            f.write(",".join([str(data[key]) for key in data.keys()])+"
    ")
    
    def getTrafficData(self):
        df = pd.read_csv(self.databaseName)
        currentTime = str(datetime.datetime.now())[:-7].replace("-","/") + ":00"
        currentHour = int(currentTime[-5:-3])
        dataInTimeSpan = df[(df['Time'] >= (currentTime - self.timeSpan))]
        sumOfData = dataInTimeSpan["CarCount"].sum()
        avgPerHour = round(sumOfData/(self.timeSpan.seconds//3600), 1)
        totalAvg = round(avgPerHour * 24 // 10, 1)
    
        print("Traffic Data In Last {}:
    ".format(self.timeSpan))
        print(dataInTimeSpan.tail().style.set_caption("Raw Data").set_precision(2).hide_index(),"
    ")
        print("Total Cars Per Hour (Last {}):
    {} cars per hour
    ".format(self.timeSpan, avgPerHour))
        print("Total Average Cars Per Day (Last {} Hours):
    {} cars per day".format(self.timeSpan.seconds//3600, totalAvg))
    
    if __name__=="__main__":
    ts = trafficStat(datetime.timedelta(hours=24))
    # add some traffic
    for _ in range(100):
        ts.recordTraffic(_)
    # show the latest data
    ts.getTrafficData()
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    

    import pandas as pd
    import matplotlib.pyplot as plt
    import seaborn as sns
    sns.set()
    
    class trafficDensity:
    
    def __init__(self, distanceInterval, databaseName="traffic.csv"):
        self.distanceInterval = distanceInterval
        self.databaseName = databaseName
        self.createDatabaseTable()
    
    def createDatabaseTable(self):
        columns = ["Distance", "CarCount"]
        df = pd.DataFrame(columns=columns)
        df.to_csv(self.databaseName, index=False)
    
    def calculateDistance(self, velocity, duration):
        distance = ((velocity*(duration))/1000)*(self.distanceInterval/1000)
        return round(distance, 2)
    
    def updateDistanceRecord(self, velocity, duration, timestamp):
        distance = self.calculateDistance(velocity, duration)
        data = {"Distance":distance, "CarCount":1}
        with open(self.databaseName,'a') as f:
            f.write(",".join([str(timestamp), str(data[key]) for key in data.keys()])+"
    ")
    
    def plotTrafficDensity(self):
        df = pd.read_csv(self.databaseName)
        ax = sns.lineplot(x="Distance", y="CarCount", data=df)
        plt.show()
    
    if __name__=="__main__":
    td = trafficDensity(20)
    # add some records
    for _ in range(100):
        td.updateDistanceRecord(_,_,_)
    # plot density chart
    td.plotTrafficDensity()