• PPLiteSeg实时语义分割预测结果输出控制无人车转向角度方向实现沿车道无人驾驶

    一、前言

    承接上文已经完成对数据集的训练和对框架的修改实现实时输出mask的预测结果，但是仅仅做到这些是无法实现无人驾驶的。

    PPLiteSeg训练自己的数据集实现自动驾驶并爆改制作成API可供其他Python程序调用实时语义分割（超低延时）_Leonard2021的博客-CSDN博客

    百度飞浆EISeg高效交互式标注分割软件的使用教程_Leonard2021的博客-CSDN博客

    整体思路：实时语义分割的输出预测mask,将整体预测分割中的车道线分割结果mask独立读取出来，再通过opencv进行图像二值化Canny边缘检测后得到车道线的边缘后，再通过HoughLinesP霍尔线变化取得车道线上的大量零散坐标，在这些零散坐标中求得起点和终点的车道线中点后，设置逻辑判断车道线是通向前方、左方、还是右方，求得输出车道区域的中点和起点车道区域的中点之间的角度，设置逻辑将改输出角度同步到无人车的前方转向轮的方向角度控制，就可使小车沿车道无人车自动驾驶。

    数据集大概长这样：

     

    二、实战

    训练函数部分，我在上一篇文章里已经提及，这里不再重复，直接开始修改和使用调用的部分。

    新建  visualize_myself.py  ：

    1. # Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
    2. #
    3. # Licensed under the Apache License, Version 2.0 (the "License");
    4. # you may not use this file except in compliance with the License.
    5. # You may obtain a copy of the License at
    6. #
    7. #    http://www.apache.org/licenses/LICENSE-2.0
    8. #
    9. # Unless required by applicable law or agreed to in writing, software
    10. # distributed under the License is distributed on an "AS IS" BASIS,
    11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12. # See the License for the specific language governing permissions and
    13. # limitations under the License.
    14.  
    15. import os
    16.  
    17. import cv2
    18. import numpy as np
    19. from PIL import Image as PILImage
    20.  
    21.  
    22. def visualize(image, result, color_map, save_dir=None, weight=0.6):
    23.     """
    24.     Convert predict result to color image, and save added image.
    26.     Args:
    27.         image (str): The path of origin image.
    28.         result (np.ndarray): The predict result of image.
    29.         color_map (list): The color used to save the prediction results.
    30.         save_dir (str): The directory for saving visual image. Default: None.
    31.         weight (float): The image weight of visual image, and the result weight is (1 - weight). Default: 0.6
    33.     Returns:
    34.         vis_result (np.ndarray): If `save_dir` is None, return the visualized result.
    35.     """
    36.  
    37.     color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
    38.     color_map = np.array(color_map).astype("uint8")
    39.     # Use OpenCV LUT for color mapping
    40.     c1 = cv2.LUT(result, color_map[:, 0])
    41.     c2 = cv2.LUT(result, color_map[:, 1])
    42.     c3 = cv2.LUT(result, color_map[:, 2])
    43.     pseudo_img = np.dstack((c3, c2, c1))
    44.  
    45.     #im = cv2.imread(image)
    46.     im = image.copy()
    47.     vis_result = cv2.addWeighted(im, weight, pseudo_img, 1 - weight, 0)
    48.  
    49.     if save_dir is not None:
    50.         if not os.path.exists(save_dir):
    51.             os.makedirs(save_dir)
    52.         image_name = os.path.split(image)[-1]
    53.         out_path = os.path.join(save_dir, image_name)
    54.         cv2.imwrite(out_path, vis_result)
    55.     else:
    56.         return vis_result
    57.  
    58.  
    59. def get_pseudo_color_map(pred, color_map=None):
    60.     """
    61.     Get the pseudo color image.
    63.     Args:
    64.         pred (numpy.ndarray): the origin predicted image.
    65.         color_map (list, optional): the palette color map. Default: None,
    66.             use paddleseg's default color map.
    68.     Returns:
    69.         (numpy.ndarray): the pseduo image.
    70.     """
    71.     pred_mask = PILImage.fromarray(pred.astype(np.uint8), mode='P')
    72.     if color_map is None:
    73.         color_map = get_color_map_list(256)
    74.     pred_mask.putpalette(color_map)
    75.     #print(len(pred_mask.split()), type(pred_mask))
    76.     #image = pred_mask.convert("RGB")#单通道转化为3通道
    77.     #img = cv2.cvtColor(np.asarray(image), cv2.COLOR_BGR2GRAY)#转化为cv的格式返回
    78.     return pred_mask
    79.  
    80.  
    81. def get_color_map_list(num_classes, custom_color=None):
    82.     """
    83.     Returns the color map for visualizing the segmentation mask,
    84.     which can support arbitrary number of classes.
    86.     Args:
    87.         num_classes (int): Number of classes.
    88.         custom_color (list, optional): Save images with a custom color map. Default: None, use paddleseg's default color map.
    90.     Returns:
    91.         (list). The color map.
    92.     """
    93.  
    94.     num_classes += 1
    95.     color_map = num_classes * [0, 0, 0]
    96.     for i in range(0, num_classes):
    97.         j = 0
    98.         lab = i
    99.         while lab:
    100.             color_map[i * 3] |= (((lab >> 0) & 1) << (7 - j))
    101.             color_map[i * 3 + 1] |= (((lab >> 1) & 1) << (7 - j))
    102.             color_map[i * 3 + 2] |= (((lab >> 2) & 1) << (7 - j))
    103.             j += 1
    104.             lab >>= 3
    105.     color_map = color_map[3:]
    106.  
    107.     if custom_color:
    108.         color_map[:len(custom_color)] = custom_color
    109.     return color_map
    110.  
    111.  
    112. def paste_images(image_list):
    113.     """
    114.     Paste all image to a image.
    115.     Args:
    116.         image_list (List or Tuple): The images to be pasted and their size are the same.
    117.     Returns:
    118.         result_img (PIL.Image): The pasted image.
    119.     """
    120.     assert isinstance(image_list,
    121.                       (list, tuple)), "image_list should be a list or tuple"
    122.     assert len(
    123.         image_list) > 1, "The length of image_list should be greater than 1"
    124.  
    125.     pil_img_list = []
    126.     for img in image_list:
    127.         if isinstance(img, str):
    128.             assert os.path.exists(img), "The image is not existed: {}".format(
    129.                 img)
    130.             img = PILImage.open(img)
    131.             img = np.array(img)
    132.         elif isinstance(img, np.ndarray):
    133.             img = PILImage.fromarray(img)
    134.         pil_img_list.append(img)
    135.  
    136.     sample_img = pil_img_list[0]
    137.     size = sample_img.size
    138.     for img in pil_img_list:
    139.         assert size == img.size, "The image size in image_list should be the same"
    140.  
    141.     width, height = sample_img.size
    142.     result_img = PILImage.new(sample_img.mode,
    143.                               (width * len(pil_img_list), height))
    144.     for i, img in enumerate(pil_img_list):
    145.         result_img.paste(img, box=(width * i, 0))
    146.  
    147.     return result_img

    新建  predict_with_api.py  ： 修改过的predict，制作成了可实时运行的API接口

    1. import cv2
    2. import numpy as np
    3. import paddle
    4. from paddleseg.core import infer
    5. from paddleseg.utils import visualize
    6. import visualize_myself
    7. from PIL import Image as PILImage
    8.  
    9.  
    10. def preprocess(im_path, transforms):
    11.     data = {}
    12.     data['img'] = im_path
    13.     data = transforms(data)
    14.     data['img'] = data['img'][np.newaxis, ...]
    15.     data['img'] = paddle.to_tensor(data['img'])
    16.     return data
    17.  
    18. def predict(model,
    19.             model_path,
    20.             transforms,
    21.             image_list,
    22.             aug_pred=False,
    23.             scales=1.0,
    24.             flip_horizontal=True,
    25.             flip_vertical=False,
    26.             is_slide=False,
    27.             stride=None,
    28.             crop_size=None,
    29.             custom_color=None
    30.             ):
    31.     # 加载模型权重
    32.     para_state_dict = paddle.load(model_path)
    33.     model.set_dict(para_state_dict)
    34.     # 设置模型为评估模式
    35.     model.eval()
    36.     # 读取图像
    37.     im = image_list.copy()
    38.     color_map = visualize.get_color_map_list(256, custom_color=custom_color)
    39.     with paddle.no_grad():
    40.         data = preprocess(im, transforms)
    41.         # 是否开启多尺度翻转预测
    42.         if aug_pred:
    43.             pred, _ = infer.aug_inference(
    44.                 model,
    45.                 data['img'],
    46.                 trans_info=data['trans_info'],
    47.                 scales=scales,
    48.                 flip_horizontal=flip_horizontal,
    49.                 flip_vertical=flip_vertical,
    50.                 is_slide=is_slide,
    51.                 stride=stride,
    52.                 crop_size=crop_size)
    53.         else:
    54.             pred, _ = infer.inference(
    55.                 model,
    56.                 data['img'],
    57.                 trans_info=data['trans_info'],
    58.                 is_slide=is_slide,
    59.                 stride=stride,
    60.                 crop_size=crop_size)
    61.         # 将返回数据去除多余的通道，并转为uint8类型，方便保存为图片
    62.  
    63.         pred = paddle.squeeze(pred)
    64.         pred = pred.numpy().astype('uint8')
    65.  
    66.         # 展示结果
    67.         added_image = visualize_myself.visualize(image= im,result= pred,color_map=color_map, weight=0.6)
    68.         #cv2.imshow('image_predict', added_image)
    69.  
    70.         # save pseudo color prediction
    71.         pred_mask = visualize_myself.get_pseudo_color_map(pred, color_map)
    72.         #cv2.waitKey(0)
    73.         #cv2.destroyAllWindows()
    74.         return added_image,pred_mask

    新建  seg_read.py  ：  主要功能为将整体预测的输出改为指定输出某个种类的分割结果，这里我主要只输出车道线分割的预测部分

    1. from PIL import Image
    2. import numpy as np
    3. import cv2
    4.  
    5. #生成染色版
    6. def get_voc_palette(num_classes):
    7.     n = num_classes
    8.     palette = [0]*(n*3)
    9.     for j in range(0,n):
    10.             lab = j
    11.             palette[j*3+0] = 0
    12.             palette[j*3+1] = 0
    13.             palette[j*3+2] = 0
    14.             i = 0
    15.             while (lab > 0):
    16.                     palette[j*3+0] |= (((lab >> 0) & 1) << (7-i))
    17.                     palette[j*3+1] |= (((lab >> 1) & 1) << (7-i))
    18.                     palette[j*3+2] |= (((lab >> 2) & 1) << (7-i))
    19.                     i = i + 1
    20.                     lab >>= 3
    21.     return palette
    22.  
    23. #染色代码
    24. def colorize_mask(mask, palette):
    25.     zero_pad = 256 * 3 - len(palette)
    26.     for i in range(zero_pad):
    27.                     palette.append(0)
    28.     new_mask = Image.fromarray(mask.astype(np.uint8)).convert('P')
    29.     new_mask.putpalette(palette)
    30.     return new_mask
    31.  
    32. #生成指定类别的语义分割预测结果
    33. def generate_img_with_choice_class(img,classes:list,num_classes:int):
    34.     #传入 图像路径 和 需要预测的类别  总共的类别
    35.     #img = Image.open(img)#
    36.  
    37.     img = np.asarray(img)
    38.     f_img = img.copy()
    39.     for idx,c in enumerate(classes):
    40.         f_img[np.where(img==c)] = 0 #将对应位置置零
    41.     f_img = colorize_mask(f_img,get_voc_palette(num_classes)) # 进行染色处理
    42.     image = f_img.convert("RGB")
    43.     #image.save('output/process_img.png')
    44.     img = cv2.cvtColor(np.asarray(image), cv2.COLOR_BGR2GRAY)
    45.     return img
    46.  
    47. if __name__ == '__main__':
    48.     ''''''
    49.     img_path = r'data/annotations/000026.png'
    50.     choice_list = [0,2]
    51.     img = generate_img_with_choice_class(img_path,choice_list,3)
    52.     cv2.imshow('image',img)
    53.     #cv2.imwrite('output/3.jpg', img)
    54.     #cv2.waitKey(0)

    新建    opencv手动阈值分割.py   ：通过滑块手动调整canny边缘检测的阈值

    1. import cv2
    2. #载入图片
    3. img_original=cv2.imread('output/1.jpg')
    4. #设置窗口
    5. cv2.namedWindow('Canny')
    6. #定义回调函数
    7. def nothing(x):
    8.     pass
    9. #创建两个滑动条，分别控制threshold1，threshold2
    10. cv2.createTrackbar('threshold1','Canny',50,400,nothing)
    11. cv2.createTrackbar('threshold2','Canny',100,400,nothing)
    12. while(1):
    13.     #返回滑动条所在位置的值
    14.     threshold1=cv2.getTrackbarPos('threshold1','Canny')
    15.     threshold2=cv2.getTrackbarPos('threshold2','Canny')
    16.     #Canny边缘检测
    17.     img_edges=cv2.Canny(img_original,threshold1,threshold2)
    18.     #显示图片
    19.     cv2.imshow('original',img_original)
    20.     cv2.imshow('Canny',img_edges)
    21.     if cv2.waitKey(1)==ord('q'):
    22.         break
    23. cv2.destroyAllWindows()

    新建 HoughLines_return.py  ：主要功能通过canny特征检测提取车道线上的大量零散坐标，再抽取边缘（包括：最上方、最左方、最下方、最右方）的各4个最接近边缘的输出坐标，求平均得到4个的方向的中点坐标，若最左方的车道线边缘中点靠近左侧上方且不上方接触则输出角度为左侧边缘的中点与下方边缘中点之间的角度，右侧和上方的同理。输出后便可通过串口通讯实时同步无人车的前方转向轮的方向角度。

    1. import cv2
    2. import matplotlib.pyplot as plt
    3. import numpy as np
    4. from collections import Counter
    5. import math
    6.  
    7. def sort_max(list):
    8.     list1 = list.copy()#复制一份，不破坏原来的列表
    9.     list1.sort()#从小到大排序
    10.     max1 = list1[-1]#最大
    11.     max2 = list1[-2]#第二大
    12.     max3 = list1[-3]#第3大
    13.     max4 = list1[-4]#第4大
    14.     return max1,max2,max3,max4
    15.  
    16. def sort_min(list):
    17.     list1 = list.copy()  # 复制一份，不破坏原来的列表
    18.     list1.sort()  # 从小到大排序
    19.     min1 = list1[0]  # 最大
    20.     min2 = list1[1]  # 第二大
    21.     min3 = list1[2]  # 第3大
    22.     min4 = list1[3]  # 第4大
    23.     return min1, min2, min3, min4
    24.  
    25. def azimuthangle(x1, y1, x2, y2):
    26.     """ 已知两点坐标计算角度 -
    27.     :param x1: 原点横坐标值
    28.     :param y1: 原点纵坐标值
    29.     :param x2: 目标点横坐标值
    30.     :param y2: 目标纵坐标值
    31.     """
    32.     angle = 0.0
    33.     dx = x2 - x1
    34.     dy = y2 - y1
    35.     if x2 == x1:
    36.         angle = math.pi / 2.0
    37.         if y2 == y1:
    38.             angle = 0.0
    39.         elif y2 < y1:
    40.             angle = 3.0 * math.pi / 2.0
    41.     elif x2 > x1 and y2 > y1:
    42.         angle = math.atan(dx / dy)
    43.     elif x2 > x1 and y2 < y1:
    44.         angle = math.pi / 2 + math.atan(-dy / dx)
    45.     elif x2 < x1 and y2 < y1:
    46.         angle = math.pi + math.atan(dx / dy)
    47.     elif x2 < x1 and y2 > y1:
    48.         angle = 3.0 * math.pi / 2.0 + math.atan(dy / -dx)
    49.     return angle * 180 / math.pi
    50.  
    51.  
    52. def get_index(l, x, n):
    53.     # 函数作用: 获取某个元素第n次出现在列表的下标
    54.     # 参数列表: 第一个参数为可迭代对象, 第二个参数为要查找的数, 第三个参数为要查找第几个出现的x
    55.     l_count = l.count(x)
    56.     result = None
    57.     if n <= l_count:
    58.         num = 0
    59.         for item in enumerate(l):
    60.             if item[1] == x:
    61.                 num += 1
    62.             if num == n:
    63.                 result = item[0]
    64.                 break
    65.     else:
    66.         print("列表里总共有{}个{}".format(l_count, x))
    67.     return result
    68.  
    69. def get_top_mid(x_list,y_list,judge):#真为上方，假为下方
    70.     if judge ==True:
    71.         min1_y, min2_y, min3_y, min4_y = sort_min(y_list)
    72.     else:
    73.         min1_y, min2_y, min3_y, min4_y = sort_max(y_list)
    74.     #print("min1:", min1_y, "min2:", min2_y, "min3:", min3_y, "min4:", min4_y)
    75.     min_list_y = [min1_y, min2_y, min3_y, min4_y]
    76.     b = dict(Counter(min_list_y))
    77.     same = [key for key, value in b.items() if value > 1]  # 只展示重复元素
    78.     min_list_x = []
    79.     i_1 = 1
    80.     i_2 = 1
    81.     for max in min_list_y:
    82.         if len(same)==0:
    83.             y_index = get_index(y_list, max, 1)
    84.         elif len(same)==1:
    85.             if max == same[0]:
    86.                 y_index = get_index(y_list, max, i_1)
    87.                 i_1 =i_1+1
    88.             else:
    89.                 y_index = get_index(y_list, max, 1)
    90.         elif len(same)==2:
    91.             if max == same[0]:
    92.                 y_index = get_index(y_list, max, i_1)
    93.                 i_1 =i_1+1
    94.             elif max == same[1]:
    95.                 y_index = get_index(y_list, max, i_2)
    96.                 i_2 =i_2+1
    97.             else:
    98.                 y_index = get_index(y_list, max, 1)
    99.         min_list_x.append(x_list[y_index])
    100.     #print("min_list_x", min_list_x)
    101.     top_mid = [sum(min_list_x) / len(min_list_x), sum(min_list_y) / len(min_list_y)]
    102.     #print("top_mid:", top_mid)
    103.     return top_mid
    104.  
    105. def get_side_mid(x_list,y_list,judge):#真为左，假为右
    106.     if judge ==True:
    107.         m1_x, m2_x, m3_x, m4_x = sort_min(x_list)
    108.     else:
    109.         m1_x, m2_x, m3_x, m4_x = sort_max(x_list)
    110.     #print("min1:", m1_x, "min2:", m2_x, "min3:", m3_x, "min4:", m4_x)
    111.     min_list_x = [m1_x, m2_x, m3_x, m4_x]
    112.     b = dict(Counter(min_list_x))
    113.     same = [key for key, value in b.items() if value > 1]  # 只展示重复元素
    114.     #print("same:", same, len(same))
    115.     min_list_y = []
    116.     i_1 = 1
    117.     i_2 = 1
    118.     for max in min_list_x:
    119.         if len(same)==0:
    120.             x_index = get_index(x_list, max, 1)
    121.         elif len(same) == 1:
    122.             if max == same:
    123.                 x_index = get_index(x_list, max, i_1)
    124.                 i_1 = i_1 + 1
    125.             else:
    126.                 x_index = get_index(x_list, max, 1)
    127.             #print("x_index_1:", type(x_index), x_index)
    128.         elif len(same)==2:
    129.             if max == same[0]:
    130.                 x_index = get_index(x_list, max, i_1)
    131.                 i_1 = i_1 + 1
    132.             elif max == same[1]:
    133.                 x_index = get_index(x_list, max, i_2)
    134.                 i_2 = i_2 + 1
    135.             else:
    136.                 x_index = get_index(x_list, max, 1)
    137.             #print("x_index_1:", type(x_index), x_index)
    138.         min_list_y.append(y_list[x_index])
    139.     #print("min_list_x", min_list_y)
    140.     side_mid = [sum(min_list_x) / len(min_list_x), sum(min_list_y) / len(min_list_y)]
    141.     #print("side_mid:", side_mid)
    142.     return side_mid
    143.  
    144. def HL_return(src):
    145.     img = src.copy()
    146.     # 二值化图像（Canny边缘检测）
    147.     # gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    148.     dst_img = cv2.Canny(img, 11, 16)
    149.  
    150.     cv2.imshow('Canny', dst_img)
    151.     #cv2.waitKey(0)
    152.  
    153.     lines = cv2.HoughLinesP(dst_img, 1, np.pi / 180, 20)
    154.  
    155.     x_list = []
    156.     y_list = []
    157.  
    158.     for line in lines:
    159.         for x1, y1, x2, y2 in line:
    160.             x_list.append(x1)
    161.             x_list.append(x2)
    162.             y_list.append(y1)
    163.             y_list.append(y2)
    164.             cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 3)
    165.         cv2.imshow("HoughLinesP", img)
    166.         #cv2.waitKey(0)
    167.  
    168.     top_mid = get_top_mid(x_list,y_list,True)#得到上面的中点
    169.     down_mid = get_side_mid(x_list,y_list,False)#得到下面的中点
    170.     left_side_mid = get_side_mid(x_list,y_list,True)#得到左边的中点
    171.     right_side_mid = get_side_mid(x_list,y_list,False)#得到右边的中点
    172.     print("top_mid:",top_mid,"dowm_mid:",down_mid,"left_mid:",left_side_mid,"right_mid:",right_side_mid)
    173.  
    174.     sp = src.shape
    175.     sz1 = sp[0]  # height(rows) of image
    176.     sz2 = sp[1]  # width(colums) of image
    177.     sz3 = sp[2]  # the pixels value is made up of three primary colors
    178.     if left_side_mid[1]<(sp[0]*0.5):
    179.         angle =azimuthangle (left_side_mid[0],left_side_mid[1],down_mid[0],down_mid[1])
    180.     elif right_side_mid[1]<(sp[0]*0.5):
    181.         angle = azimuthangle(right_side_mid[0], right_side_mid[1], down_mid[0], down_mid[1])
    182.     else:
    183.         angle = azimuthangle(top_mid[0], top_mid[1], down_mid[0], down_mid[1])
    184.     #print("angle:", type(angle), angle)
    185.     #cv2.waitKey(0)
    186.     return angle
    187.  
    188. if __name__ == '__main__':
    189.     src = cv2.imread(r"D:\pyCharmdata\PPLiteSeg_demo\output\2.jpg")
    190.     angle =HL_return(src)
    191.     if (angle - 90) > 0:
    192.         print("请右转:", math.fabs(angle - 90), "度")
    193.     elif (angle - 90) < 0:
    194.         print("请左转:", math.fabs(angle - 90), "度")
    195.     elif angle == 90:
    196.         print("正在保持90度直行")

     新建 demo_run_API.py  ：调用实时分割API并实时输出转向角度

    1. import cv2
    2. from predict_with_api import predict
    3. from paddleseg.models import PPLiteSeg
    4. from paddleseg.models.backbones import STDC1
    5. import paddleseg.transforms as T
    6. from seg_read import generate_img_with_choice_class
    7. from HoughLines_return import HL_return
    8. import math
    9.  
    10. backbone = STDC1()
    11.  
    12. model = PPLiteSeg(num_classes=13,
    13.                  backbone= backbone,
    14.                  arm_out_chs = [32, 64, 128],
    15.                  seg_head_inter_chs = [32, 64, 64],
    16.                  pretrained=None)
    17.  
    18. transforms = T.Compose([
    19.     T.Resize(target_size=(512, 512)),
    20.     T.RandomHorizontalFlip(),
    21.     T.Normalize()
    22. ])
    23. model_path = 'output/best_model/model.pdparams'
    24. cap=cv2.VideoCapture(0)# 0
    25.  
    26. if __name__ == '__main__':
    27.     while True:
    28.         rec,img = cap.read()
    29.         added_image,pred_mask = predict(model=model,model_path=model_path, transforms=transforms,image_list=img)
    30.         cv2.imshow('image_predict', added_image)#显示原图像与分割预测的合并图
    31.         #
    32.         choice_list = [0, 2]#只展示第2个类型的分割结果
    33.         img = generate_img_with_choice_class(pred_mask, choice_list, 3)# PIL图像输入、展示第几个类型的分割、总的分割种类
    34.         cv2.imshow('image', img)#将返回的指定分割类型的灰度图显示出来
    35.         angle = HL_return(img)
    36.         if (angle - 90) > 0:
    37.             print("请右转:", math.fabs(angle - 90), "度")
    38.         elif (angle - 90) < 0:
    39.             print("请左转:", math.fabs(angle - 90), "度")
    40.         elif angle == 90:
    41.             print("正在保持90度直行")
    42.  
    43.         if cv2.waitKey(1)==ord('q'):
    44.             break

    三、总结

    总的来说，虽然是完成的整体开发工作，但是由于使用的是数据集，且使用的数据集数量较少，训练程度较低。尚未落地进行实验，可能存在许多调试和逻辑上的问题有待发现和解决，且判断车道线的流向方向的阈值是手动自己估计的，实际的阈值的差值有待商榷。逻辑控制方面上相对大厂的算法显得不太成熟和简单。将输出角度与转向轮方向角度同步的部分，使用pyserial与下位机进行串口通讯，下位机再控制电机的转向轮到指定角度。

    再加上目标检测部分，就形成了一个简易的无人驾驶的视觉部分。

    爆改YOLOV7的detect.py制作成API接口供其他python程序调用（超低延时）_Leonard2021的博客-CSDN博客

    本人完全独立自制的小玩意，简易版本的无人驾驶的视觉部分，精度肯定不如大厂的成品算法，如果有时间的精力的话，会继续改进的更新的。

    本项目的架构，有需要可以自取：

    PPLiteSeg_AutoDrive_demo.zip-深度学习文档类资源-CSDN下载

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    本文到此结束，如果对你有帮助，欢迎一键三连！！！

  • 相关阅读:
    Appium学习日记（三）——Windows系统测试桌面应用
    Mysql整理-主从复制
    Java 基础常见知识点&面试题总结(下)，2022 最新版！
    源码分析RocketMQ之broker-文件恢复
    Java后端学习路线
    计算机毕业设计SSM电竞资讯网站【附源码数据库】
    分享一个图片转换工具XnConvert
    【CMU15-445 Part-4】DatabaseStorage ii
    联邦学习模型分类
    五、Kafka日志存储
  • 原文地址：https://blog.csdn.net/weixin_51331359/article/details/126223158