wangjin0928
/
AIlib2
보기 1
좋아요 0
포크 0
코드 이슈 0 풀 리퀘스트 0 릴리즈 0 위키 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
44 커밋
6 브랜치
트리: 25aecfbce7
브랜치 태그
${ item.name }
Create branch ${ searchTerm }
from '25aecfbce7'
${ noResults }
AIlib2/utilsK/noParkingUtils.py

684 lines
56KB
Raw Blame 히스토리 

  1. import numpy as np

  2. import cv2,time,math

  3. 

  4. def get_ms(time2, time1):

  5.     return (time2-time1)*1000.0

  6. 

  7. 

  8. # 根据两点坐标，求过这两点的直线解析方程： a*x+b*y+c = 0  (a >= 0)

  9. def getLinearEquation(p1x, p1y, p2x, p2y):

  10.     sign = 1

  11.     a = p2y - p1y

  12.     if a < 0:

  13.         sign = -1

  14.         a = sign * a

  15.     b = sign * (p1x - p2x)

  16.     c = sign * (p1y * p2x - p1x * p2y)

  17.     # y=kx+bb

  18.     k = -a/(b+0.0000000001)

  19.     bb = -c/(b+0.000000000001)

  20.     return k, bb

  21. 

  22. 

  23. # 根据多点坐标拟合直线

  24. def best_fit(X, Y):

  25.     xbar = sum(X) / len(X)

  26.     ybar = sum(Y) / len(Y)

  27.     n = len(X)  # or len(Y)

  28.     numer = sum([xi * yi for xi, yi in zip(X, Y)]) - n * xbar * ybar

  29.     denum = sum([xi ** 2 for xi in X]) - n * xbar ** 2

  30.     k = numer / denum

  31.     b = ybar - k * xbar

  32.     # print('best fit line:\ny = {:.2f}x + {:.2f}'.format(k, b))

  33.     return k, b

  34. 

  35. 

  36. # 对于左侧车道线，返回两车道线中心点连线确定的角度，radian2表示弧度

  37. def calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber):

  38.     radian2 = math.atan2(abs(allLaneContent[leftLaneSerialNumber[-1]][4][1] - allLaneContent[leftLaneSerialNumber[0]][4][1]), abs(allLaneContent[leftLaneSerialNumber[-1]][4][0] - allLaneContent[leftLaneSerialNumber[0]][4][0]))

  39.     lanesCenterAngle1 = 180 - int(radian2 * 180 / math.pi)

  40.     lanesCenterAngle2 = int(radian2 * 180 / math.pi)

  41.     return lanesCenterAngle1, lanesCenterAngle2

  42. 

  43. 

  44. # 对于右侧车道线，返回两车道线中心点连线确定的角度，radian2表示弧度

  45. def calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber):

  46.     radian2 = math.atan2(abs(allLaneContent[rightLaneSerialNumber[-1]][4][1] - allLaneContent[rightLaneSerialNumber[0]][4][1]), abs(allLaneContent[rightLaneSerialNumber[-1]][4][0] - allLaneContent[rightLaneSerialNumber[0]][4][0]))

  47.     lanesCenterAngle3 = 180 - int(radian2 * 180 / math.pi)

  48.     lanesCenterAngle4 = int(radian2 * 180 / math.pi)

  49.     return lanesCenterAngle3, lanesCenterAngle4

  50. 

  51. 

  52. # 从所有车道线中确定位于最左侧的车道线簇，并将各车道线对应的序号存储在leftLaneSerialNumber中

  53. def findLeftLanes(allLaneContent, laneXCoordinateMin2MaxSort, leftLaneSerialNumber, pars):

  54.     for i in range(len(laneXCoordinateMin2MaxSort)):  # 求最左侧车道线

  55.         if (allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0] > allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0] and allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1] < allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]) or (allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0] < allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0] and allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1] > allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]):  # allLaneContent[0][4][0]:中心点x坐标。 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  56.             radian1 = math.atan2(abs(allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1] - allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1]), abs(allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0] - allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0]))

  57.             lanesCenterAngle1 = 180 - int(radian1 * 180 / math.pi)

  58.             if len(leftLaneSerialNumber) == 0:  # 刚开始判断

  59.                 if abs(allLaneContent[laneXCoordinateMin2MaxSort[i][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  60.                     if laneXCoordinateMin2MaxSort[i][1] not in leftLaneSerialNumber:

  61.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i][1])

  62.                     if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  63.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  64.                 else:

  65.                     break

  66.             else:

  67.                 if (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  68.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  69.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  70.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  71.                     else:

  72.                         break

  73.                 elif (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  74.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  75.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  76.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  77.                     else:

  78.                         break

  79.                 elif allLaneContent[leftLaneSerialNumber[0]][4][0] == allLaneContent[leftLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  80.                     lanesCenterAngle2 = 90

  81.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  82.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  83.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  84.                     else:

  85.                         break

  86.                 elif allLaneContent[leftLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]:  # 两车道线的y坐标相同

  87.                     lanesCenterAngle2 = 0

  88.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  89.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  90.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  91.                     else:

  92.                         break

  93.         elif (allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0] < allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0] and allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1] < allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]) or (allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0] > allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0] and allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1] > allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]):  # 这种情况对应左上角和右下角的车道线，计算角度

  94.             radian1 = math.atan2(abs(allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1] - allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1]), abs(allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0] - allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0]))

  95.             lanesCenterAngle1 = int(radian1 * 180 / math.pi)

  96.             if len(leftLaneSerialNumber) == 0:  # 刚开始判断

  97.                 if abs(allLaneContent[laneXCoordinateMin2MaxSort[i][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  98.                     if laneXCoordinateMin2MaxSort[i][1] not in leftLaneSerialNumber:

  99.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i][1])

  100.                     if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  101.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  102.                 else:

  103.                     break

  104.             else:

  105.                 if (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  106.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  107.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  108.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  109.                     else:

  110.                         break

  111.                 elif (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or ( allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  112.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  113.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  114.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  115.                     else:

  116.                         break

  117.                 elif allLaneContent[leftLaneSerialNumber[0]][4][0] == allLaneContent[leftLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  118.                     lanesCenterAngle2 = 90

  119.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  120.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  121.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  122.                     else:

  123.                         break

  124.                 elif allLaneContent[leftLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]:  # 两车道线的y坐标相同

  125.                     lanesCenterAngle2 = 0

  126.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  127.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  128.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  129.                     else:

  130.                         break

  131.         elif allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][0] == allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][0]:  # 两车道线的最小x坐标相同

  132.             lanesCenterAngle1 = 90

  133.             if len(leftLaneSerialNumber) == 0:  # 刚开始判断

  134.                 if abs(allLaneContent[laneXCoordinateMin2MaxSort[i][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  135.                     if laneXCoordinateMin2MaxSort[i][1] not in leftLaneSerialNumber:

  136.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i][1])

  137.                     if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  138.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  139.                 else:

  140.                     break

  141.             else:

  142.                 if (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  143.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  144.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  145.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  146.                     else:

  147.                         break

  148.                 elif (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  149.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  150.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  151.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  152.                     else:

  153.                         break

  154.                 elif allLaneContent[leftLaneSerialNumber[0]][4][0] == allLaneContent[leftLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  155.                     lanesCenterAngle2 = 90

  156.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  157.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  158.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  159.                     else:

  160.                         break

  161.                 elif allLaneContent[leftLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]:  # 两车道线的y坐标相同

  162.                     lanesCenterAngle2 = 0

  163.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  164.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  165.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  166.                     else:

  167.                         break

  168.         elif allLaneContent[laneXCoordinateMin2MaxSort[i][1]][4][1] == allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]:  # 两车道线的y坐标相同

  169.             lanesCenterAngle1 = 0

  170.             if len(leftLaneSerialNumber) == 0:  # 刚开始判断

  171.                 if abs(allLaneContent[laneXCoordinateMin2MaxSort[i][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  172.                     if laneXCoordinateMin2MaxSort[i][1] not in leftLaneSerialNumber:

  173.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i][1])

  174.                     if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  175.                         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  176.                 else:

  177.                     break

  178.             else:

  179.                 if (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  180.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  181.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  182.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  183.                     else:

  184.                         break

  185.                 elif (allLaneContent[leftLaneSerialNumber[0]][4][0] < allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] < allLaneContent[leftLaneSerialNumber[-1]][4][1]) or (allLaneContent[leftLaneSerialNumber[0]][4][0] > allLaneContent[leftLaneSerialNumber[-1]][4][0] and allLaneContent[leftLaneSerialNumber[0]][4][1] > allLaneContent[leftLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  186.                     if abs(lanesCenterAngle1 - calculateLeftLanesAngle(allLaneContent, leftLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  187.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  188.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  189.                     else:

  190.                         break

  191.                 elif allLaneContent[leftLaneSerialNumber[0]][4][0] == allLaneContent[leftLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  192.                     lanesCenterAngle2 = 90

  193.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  194.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  195.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  196.                     else:

  197.                         break

  198.                 elif allLaneContent[leftLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMin2MaxSort[i + 1][1]][4][1]:  # 两车道线的y坐标相同

  199.                     lanesCenterAngle2 = 0

  200.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  201.                         if laneXCoordinateMin2MaxSort[i + 1][1] not in leftLaneSerialNumber:

  202.                             leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[i + 1][1])

  203.                     else:

  204.                         break

  205.     return leftLaneSerialNumber

  206. 

  207. 

  208. # 从所有车道线中确定位于最右侧的车道线簇，并将各车道线对应的序号存储在rightLaneSerialNumber中

  209. def findRightLanes(allLaneContent, laneXCoordinateMax2MinSort, rightLaneSerialNumber, pars):

  210.     for r in range(len(laneXCoordinateMax2MinSort)):  # 求最右侧车道线

  211.         if (allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0] > allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0] and allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1] < allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]) or (allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0] < allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0] and allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1] > allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]):  # allLaneContent[0][4][0]:中心点x坐标。 车辆的相对位置不同，计算角度方法也不同。

  212.             radian1 = math.atan2(abs(allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1] - allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1]), abs(allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0] - allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0]))

  213.             lanesCenterAngle1 = 180 - int(radian1 * 180 / math.pi)

  214.             if len(rightLaneSerialNumber) == 0:  # 刚开始判断

  215.                 if abs(allLaneContent[laneXCoordinateMax2MinSort[r][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  216.                     if laneXCoordinateMax2MinSort[r][1] not in rightLaneSerialNumber:

  217.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r][1])

  218.                     if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  219.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  220.                 else:

  221.                     break

  222.             else:

  223.                 if (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  224.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  225.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  226.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  227.                     else:

  228.                         break

  229.                 elif (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  230.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  231.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  232.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  233.                     else:

  234.                         break

  235.                 elif allLaneContent[rightLaneSerialNumber[0]][4][0] == allLaneContent[rightLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  236.                     lanesCenterAngle2 = 90

  237.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  238.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  239.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  240.                     else:

  241.                         break

  242.                 elif allLaneContent[rightLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]:  # 两车道线的y坐标相同

  243.                     lanesCenterAngle2 = 0

  244.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  245.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  246.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  247.                     else:

  248.                         break

  249.         elif (allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0] < allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0] and allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1] < allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]) or (allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0] > allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0] and allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1] > allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]):

  250.             radian1 = math.atan2(abs(allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1] - allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1]), abs(allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0] - allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0]))

  251.             lanesCenterAngle1 = int(radian1 * 180 / math.pi)

  252.             if len(rightLaneSerialNumber) == 0:  # 刚开始判断

  253.                 if abs(allLaneContent[laneXCoordinateMax2MinSort[r][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  254.                     if laneXCoordinateMax2MinSort[r][1] not in rightLaneSerialNumber:

  255.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r][1])

  256.                     if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  257.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  258.                 else:

  259.                     break

  260.             else:

  261.                 if (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  262.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  263.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  264.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  265.                     else:

  266.                         break

  267.                 elif (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  268.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  269.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  270.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  271.                     else:

  272.                         break

  273.                 elif allLaneContent[rightLaneSerialNumber[0]][4][0] == allLaneContent[rightLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  274.                     lanesCenterAngle2 = 90

  275.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  276.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  277.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  278.                     else:

  279.                         break

  280.                 elif allLaneContent[rightLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]:  # 两车道线的y坐标相同

  281.                     lanesCenterAngle2 = 0

  282.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  283.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  284.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  285.                     else:

  286.                         break

  287.         elif allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][0] == allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][0]:

  288.             lanesCenterAngle1 = 90

  289.             if len(rightLaneSerialNumber) == 0:  # 刚开始判断

  290.                 if abs(allLaneContent[laneXCoordinateMax2MinSort[r][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  291.                     if laneXCoordinateMax2MinSort[r][1] not in rightLaneSerialNumber:

  292.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r][1])

  293.                     if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  294.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  295.                 else:

  296.                     break

  297.             else:

  298.                 if (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  299.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  300.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  301.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  302.                     else:

  303.                         break

  304.                 elif (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  305.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  306.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  307.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  308.                     else:

  309.                         break

  310.                 elif allLaneContent[rightLaneSerialNumber[0]][4][0] == allLaneContent[rightLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  311.                     lanesCenterAngle2 = 90

  312.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  313.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  314.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  315.                     else:

  316.                         break

  317.                 elif allLaneContent[rightLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]:  # 两车道线的y坐标相同

  318.                     lanesCenterAngle2 = 0

  319.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  320.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  321.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  322.                     else:

  323.                         break

  324.         elif allLaneContent[laneXCoordinateMax2MinSort[r][1]][4][1] == allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]:

  325.             lanesCenterAngle1 = 0

  326.             if len(rightLaneSerialNumber) == 0:  # 刚开始判断

  327.                 if abs(allLaneContent[laneXCoordinateMax2MinSort[r][1]][6] - lanesCenterAngle1) <= pars['laneAngleCha']:

  328.                     if laneXCoordinateMax2MinSort[r][1] not in rightLaneSerialNumber:

  329.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r][1])

  330.                     if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  331.                         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  332.                 else:

  333.                     break

  334.             else:

  335.                 if (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  336.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[0]) <= pars['laneAngleCha']:

  337.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  338.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  339.                     else:

  340.                         break

  341.                 elif (allLaneContent[rightLaneSerialNumber[0]][4][0] < allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] < allLaneContent[rightLaneSerialNumber[-1]][4][1]) or (allLaneContent[rightLaneSerialNumber[0]][4][0] > allLaneContent[rightLaneSerialNumber[-1]][4][0] and allLaneContent[rightLaneSerialNumber[0]][4][1] > allLaneContent[rightLaneSerialNumber[-1]][4][1]):  # 车辆的相对位置不同，计算角度方法也不同。这种情况对应右上角和左下角的车道线，计算角度

  342.                     if abs(lanesCenterAngle1 - calculateRightLanesAngle(allLaneContent, rightLaneSerialNumber)[1]) <= pars['laneAngleCha']:

  343.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  344.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  345.                     else:

  346.                         break

  347.                 elif allLaneContent[rightLaneSerialNumber[0]][4][0] == allLaneContent[rightLaneSerialNumber[-1]][4][0]:  # 两车道线的最小x坐标相同

  348.                     lanesCenterAngle2 = 90

  349.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  350.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  351.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  352.                     else:

  353.                         break

  354.                 elif allLaneContent[rightLaneSerialNumber[0]][4][1] == allLaneContent[laneXCoordinateMax2MinSort[r + 1][1]][4][1]:  # 两车道线的y坐标相同

  355.                     lanesCenterAngle2 = 0

  356.                     if abs(lanesCenterAngle1 - lanesCenterAngle2) <= pars['laneAngleCha']:

  357.                         if laneXCoordinateMax2MinSort[r + 1][1] not in rightLaneSerialNumber:

  358.                             rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[r + 1][1])

  359.                     else:

  360.                         break

  361.     return rightLaneSerialNumber

  362. 

  363. 

  364. # 返回最左侧车道线簇所确定的直线的k和b值,将其存储在leftLaneKB中

  365. def calculateLeftLane_k_b(allLaneContent, laneXCoordinateMin2MaxSort, leftLaneSerialNumber, leftLaneBox, leftLaneAbovePoint, leftLaneKB, leftLaneCenterX, leftLaneCenterY, pars):

  366.     leftLaneSerialNumber = findLeftLanes(allLaneContent, laneXCoordinateMin2MaxSort, leftLaneSerialNumber, pars)

  367.     if len(leftLaneSerialNumber) == 0:

  368.         leftLaneSerialNumber.append(laneXCoordinateMin2MaxSort[0][1])  # leftLaneSerialNumber中存放的是最左侧的车道线簇中的各车道线的序号

  369.     if len(leftLaneSerialNumber) == 1:

  370.         centerCoordinate = allLaneContent[leftLaneSerialNumber[0]][4]  # 最小外接矩形的中心点坐标

  371.         box = allLaneContent[leftLaneSerialNumber[0]][5]

  372.         leftLaneBox.append([box[0][0], box[0][1]])

  373.         leftLaneBox.append([box[1][0], box[1][1]])

  374.         leftLaneBox.append([box[2][0], box[2][1]])

  375.         leftLaneBox.append([box[3][0], box[3][1]])

  376.         for i in range(len(leftLaneBox)):

  377.             if leftLaneBox[i][1] < centerCoordinate[1]:

  378.                 leftLaneAbovePoint.append(leftLaneBox[i])

  379.         point1_l = [(leftLaneAbovePoint[0][0] + leftLaneAbovePoint[1][0]) / 2, (leftLaneAbovePoint[0][1] + leftLaneAbovePoint[1][1]) / 2]

  380.         point2_l = [centerCoordinate[0], centerCoordinate[1]]

  381.         k_l, b_l = getLinearEquation(point1_l[0], point1_l[1], point2_l[0], point2_l[1])

  382.         leftLaneKB.append(k_l)

  383.         leftLaneKB.append(b_l)

  384.     else:

  385.         for i in range(len(leftLaneSerialNumber)):

  386.             leftLaneCenterX.append(allLaneContent[leftLaneSerialNumber[i]][4][0])  # leftLaneCenterX中存储的是各车道线中心点的x坐标

  387.             leftLaneCenterY.append(allLaneContent[leftLaneSerialNumber[i]][4][1])  # leftLaneCenterY中存储的是各车道线中心点的y坐标

  388.         k_l, b_l = best_fit(leftLaneCenterX, leftLaneCenterY)

  389.         leftLaneKB.append(k_l)

  390.         leftLaneKB.append(b_l)

  391.     return leftLaneKB

  392. 

  393. 

  394. # 返回最右侧车道线簇所确定的直线的k和b值,将其存储在rightLaneKB中

  395. def calculateRightLane_k_b(allLaneContent, laneXCoordinateMax2MinSort, rightLaneSerialNumber, rightLaneBox, rightLaneAbovePoint, rightLaneKB, rightLaneCenterX, rightLaneCenterY, pars):

  396.     rightLaneSerialNumber = findRightLanes(allLaneContent, laneXCoordinateMax2MinSort, rightLaneSerialNumber, pars)

  397.     if len(rightLaneSerialNumber) == 0:

  398.         rightLaneSerialNumber.append(laneXCoordinateMax2MinSort[0][1])  # rightLaneSerialNumber中存放的是最右侧的车道线簇中的各车道线的序号

  399.     if len(rightLaneSerialNumber) == 1:

  400.         centerCoordinate = allLaneContent[rightLaneSerialNumber[0]][4]  # 最小外接矩形的中心点坐标

  401.         box = allLaneContent[rightLaneSerialNumber[0]][5]

  402.         rightLaneBox.append([box[0][0], box[0][1]])

  403.         rightLaneBox.append([box[1][0], box[1][1]])

  404.         rightLaneBox.append([box[2][0], box[2][1]])

  405.         rightLaneBox.append([box[3][0], box[3][1]])

  406.         for i in range(len(rightLaneBox)):

  407.             if rightLaneBox[i][1] < centerCoordinate[1]:

  408.                 rightLaneAbovePoint.append(rightLaneBox[i])

  409.         point1_r = [(rightLaneAbovePoint[0][0] + rightLaneAbovePoint[1][0]) / 2, (rightLaneAbovePoint[0][1] + rightLaneAbovePoint[1][1]) / 2]

  410.         point2_r = [centerCoordinate[0], centerCoordinate[1]]

  411.         k_r, b_r = getLinearEquation(point1_r[0], point1_r[1], point2_r[0], point2_r[1])

  412.         rightLaneKB.append(k_r)

  413.         rightLaneKB.append(b_r)

  414.     else:

  415.         for i in range(len(rightLaneSerialNumber)):

  416.             rightLaneCenterX.append(allLaneContent[rightLaneSerialNumber[i]][4][0])  # rightLaneCenterX中存储的是各车道线中心点的x坐标

  417.             rightLaneCenterY.append(allLaneContent[rightLaneSerialNumber[i]][4][1])  # rightLaneCenterY中存储的是各车道线中心点的y坐标

  418.         k_r, b_r = best_fit(rightLaneCenterX, rightLaneCenterY)

  419.         rightLaneKB.append(k_r)

  420.         rightLaneKB.append(b_r)

  421.     return rightLaneKB

  422. 

  423. 

  424. def mixNoParking_road_postprocess(dets, mask, pars):

  425.     """

  426.     对于字典traffic_dict中的各个键，说明如下：

  427.     speedRoadArea：speedRoad的最小外接矩形的面积

  428.     vehicleCoordinate：是一个列表，用于存储被检测出的vehicle的坐标（vehicle检测模型）

  429.     roundness：圆度 ,lane的长与宽的比率，作为判定是否为车道线的标准之一

  430.     'cls':类别号

  431.     vehicleArea：vehicle的最小外接矩形的面积

  432.     laneLineArea：车道线的最小外接矩形的面积

  433.     laneAngleCha：车道线的角度差值阈值

  434.     contoursNum：counters中的顶点个数

  435.     ZoomFactor：图像在H和W方向上的缩放因子，其值小于1

  436.     最终输出格式：[[cls, x0, y0, x1, y1, 车辆得分, 违章停车得分, 违章类别], ...]

  437.     违章类别：0表示正常车辆，1表示违章车辆

  438.     """

  439.     det_cors = []

  440.     for bb in dets:

  441.         det_cors.append((int(bb[1]), int(bb[2])))

  442.         det_cors.append((int(bb[3]), int(bb[4])))

  443.     pars['vehicleCoordinate'] = det_cors

  444. 

  445.     H, W = mask.shape[0:2]

  446.     scaleH = pars['modelSize'][1] / H  # 自适应调整缩放比例

  447.     scaleW = pars['modelSize'][0] / W

  448.     pars['ZoomFactor'] = {'x': scaleH, 'y': scaleW}

  449.     new_hw = [int(H * scaleH), int(W * scaleW)]

  450.     mask = cv2.resize(mask, (new_hw[1], new_hw[0]))

  451.     if len(mask.shape) == 3:

  452.         mask = mask[:, :, 0]

  453. 

  454.     t3 = time.time()

  455.     vehicleContours = []  # 存储一副图像中vehicles的contours

  456.     image_speedRoad = mask.copy()

  457.     image_vehicle = mask.copy()

  458.     lane_line = mask.copy()

  459.     image_speedRoad[image_speedRoad == 2] = 0  # 将vehicle过滤掉，只包含背景和speedRoad

  460.     image_vehicle[image_vehicle == 1] = 0  # 将speedRoad过滤掉，只包含背景和vehicle

  461.     lane_line[lane_line < 3] = 0

  462.     image_speedRoad = cv2.cvtColor(np.uint8(image_speedRoad), cv2.COLOR_RGB2BGR)  # 道路

  463.     image_vehicle = cv2.cvtColor(np.uint8(image_vehicle), cv2.COLOR_RGB2BGR)  # 车辆

  464.     lane_line = cv2.cvtColor(np.uint8(lane_line), cv2.COLOR_RGB2BGR)  #

  465. 

  466.     t4 = time.time()

  467.     img1 = cv2.cvtColor(image_speedRoad, cv2.COLOR_BGR2GRAY)

  468.     contours, hierarchy = cv2.findContours(img1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

  469.     t5 = time.time()

  470. 

  471.     # 创建列表

  472.     singleSpeedRoadContent, allSpeedRoadContent, complianceVehicle, NonComplianceVehicle, singleLaneContent, allLaneContent, laneMinXCoordinate, laneMaxXCoordinate, leftLaneSerialNumber, leftLaneBox, leftLaneAbovePoint, leftLaneKB, leftLaneCenterX, leftLaneCenterY, rightLaneSerialNumber, rightLaneBox, rightLaneAbovePoint, rightLaneKB, rightLaneCenterX, rightLaneCenterY = ([] for t in range(20))

  473. 

  474.     """

  475.     列表说明如下：

  476.         singleSpeedRoadContent = []    # 过渡使用

  477.         allSpeedRoadContent = []       # 存放speedRoad坐标(Xmin,Xmax,Ymin,Ymax)、speedRoadAngle和speedRoad的宽高

  478.         complianceVehicle = []         # 将符合标准的vehicle信息存储在complianceVehicle中

  479.         NonComplianceVehicle = []      # 将不符合标准的vehicle信息存储在NonComplianceVehicle中

  480.         singleLaneContent = []         # 存储单个车道线的相关信息

  481.         allLaneContent = []            # 将singleLaneContent中的车道线存储在allLaneContent中

  482.         laneMinXCoordinate = []        # 存储车道线的最小x坐标

  483.         laneMaxXCoordinate = []        # 存储车道线的最大x坐标

  484.         leftLaneSerialNumber = []      # 左侧车道线簇中的车道线序号

  485.         leftLaneBox = []               # 当左侧车道线簇中只有一个车道线时，该车道线的最小外接矩形对应的box

  486.         leftLaneAbovePoint = []        # 当左侧车道线簇中只有一个车道线时，该车道线的最小外接矩形最上方的两个顶点坐标

  487.         leftLaneKB = []                # 存储最左侧车道线簇所确定的直线的k和b值

  488.         leftLaneCenterX = []           # 左侧车道线簇中各车道线中心点的x坐标

  489.         leftLaneCenterY = []           # 左侧车道线簇中各车道线中心点的y坐标

  490.         rightLaneSerialNumber = []     # 右侧车道线簇中的车道线序号

  491.         rightLaneBox = []              # 当右侧车道线簇中只有一个车道线时，该车道线的最小外接矩形对应的box

  492.         rightLaneAbovePoint = []       # 当右侧车道线簇中只有一个车道线时，该车道线的最小外接矩形最上方的两个顶点坐标

  493.         rightLaneKB = []               # 存储最左侧车道线簇所确定的直线的k和b值

  494.         rightLaneCenterX = []          # 右侧车道线簇中各车道线中心点的x坐标

  495.         rightLaneCenterY = []          # 右侧车道线簇中各车道线中心点的y坐标

  496.     """

  497. 

  498.     """ 将speedRoad最小外接矩形的四个顶点（Xmin,Xmax,Ymin,Ymax）、其最小外接矩形与水平方向的夹角、其最小外接矩形的宽高存储在singleSpeedRoadContent中 """

  499.     for cnt in contours:  # 道路

  500.         if len(cnt) >= 6:

  501.             rect = cv2.minAreaRect(cnt)

  502.             if rect[1][0] * rect[1][1] > pars['speedRoadArea']:  # 过滤掉面积小于阈值的speedRoad

  503.                 box = cv2.boxPoints(rect).astype(np.int32)

  504.                 speedRoadXmin = min(box[0][0], box[1][0], box[2][0], box[3][0])

  505.                 speedRoadXmax = max(box[0][0], box[1][0], box[2][0], box[3][0])

  506.                 speedRoadYmin = min(box[0][1], box[1][1], box[2][1], box[3][1])

  507.                 speedRoadYmax = max(box[0][1], box[1][1], box[2][1], box[3][1])

  508.                 singleSpeedRoadContent.append(speedRoadXmin)

  509.                 singleSpeedRoadContent.append(speedRoadXmax)

  510.                 singleSpeedRoadContent.append(speedRoadYmin)

  511.                 singleSpeedRoadContent.append(speedRoadYmax)

  512.                 if rect[1][0] <= rect[1][1]:

  513.                     if rect[2] >= 0 and rect[2] < 90:

  514.                         speedRoadAngle = rect[2] + 90

  515.                     elif rect[2] == 90:

  516.                         speedRoadAngle = 0

  517.                 else:

  518.                     if rect[2] >= 0 and rect[2] <= 90:

  519.                         speedRoadAngle = rect[2]

  520.                 singleSpeedRoadContent.append(speedRoadAngle)

  521.                 singleSpeedRoadContent.append(rect[1])

  522.                 allSpeedRoadContent.append(singleSpeedRoadContent)

  523.             singleSpeedRoadContent = []

  524. 

  525.     img3 = cv2.cvtColor(lane_line, cv2.COLOR_BGR2GRAY)

  526.     contours, hierarchy = cv2.findContours(img3, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

  527. 

  528.     """ 将车道线最小外接矩形四个顶点（Xmin,Xmax,Ymin,Ymax）、车道线最小外接矩形的中心点坐标，车道线矩形框与水平方向的夹角，存储在singleLaneContent中 """

  529.     for cnt in contours:  # 车道线

  530.         if len(cnt) >= 6:

  531.             if rect[1][0] * rect[1][1] > pars['laneLineArea'] and min(rect[1]) / max(rect[1]) <= pars['roundness']:

  532.                 rect = cv2.minAreaRect(cnt)

  533.                 box = cv2.boxPoints(rect).astype(np.int32)

  534.                 box = np.array(box)

  535.                 laneXmin,  laneXmax = np.min( box[:,0] ),np.max( box[:,0] )

  536.                 laneYmin,  laneYmax = np.min( box[:,1] ),np.max( box[:,1] )

  537.                 

  538.                 #laneXmin = min(box[0][0], box[1][0], box[2][0], box[3][0])

  539.                 #laneXmax = max(box[0][0], box[1][0], box[2][0], box[3][0])

  540.                 #laneYmin = min(box[0][1], box[1][1], box[2][1], box[3][1])

  541.                 #laneYmax = max(box[0][1], box[1][1], box[2][1], box[3][1])

  542.                 singleLaneContent.append(laneXmin)  # 将车道线矩形框四个顶点的Xmin,Xmax,Ymin,Ymax存储在singleLaneContent中

  543.                 singleLaneContent.append(laneXmax)

  544.                 singleLaneContent.append(laneYmin)

  545.                 singleLaneContent.append(laneYmax)

  546.                 if rect[1][0] <= rect[1][1]:

  547.                     if rect[2] >= 0 and rect[2] < 90:

  548.                         laneLineAngle = rect[2] + 90

  549.                     elif rect[2] == 90:

  550.                         laneLineAngle = 0

  551.                 else:

  552.                     if rect[2] >= 0 and rect[2] <= 90:

  553.                         laneLineAngle = rect[2]

  554.                 singleLaneContent.append(rect[0])  # 将车道线的中心点坐标存储在singleLaneContent中

  555.                 singleLaneContent.append(box)  # 将车道线的最小外接矩形的顶点坐标存储在singleLaneContent中

  556.                 singleLaneContent.append(laneLineAngle)  # 将车道线矩形框与水平方向的夹角存储在singleLaneContent中

  557.                 allLaneContent.append(singleLaneContent)  # 将车道线存储在allLaneContent中

  558.             singleLaneContent = []

  559. 

  560.     if len(allSpeedRoadContent) != 0 and len(allLaneContent) >= 2:  # 图像中存在speedRoad且车道线的个数大于等于2

  561.         for i in range(len(allLaneContent)):

  562.             laneMinXCoordinate.append([allLaneContent[i][0], i])  # 存储车道线的最小x坐标

  563.             laneMaxXCoordinate.append([allLaneContent[i][1], i])  # 存储车道线的最大x坐标

  564.         laneXCoordinateMin2MaxSort = sorted(laneMinXCoordinate, key=(lambda x: x[0]))  # laneXCoordinateMin2MaxSort中存储的是各车道线的x的最小值从小到大排列，后面跟车道线的序号

  565.         laneXCoordinateMax2MinSort = sorted(laneMaxXCoordinate, key=(lambda x: x[0]), reverse=True)  # laneXCoordinateMax2MinSort中存储的是各车道线的x的最大值从大到小排列，后面跟车道线的序号

  566. 

  567.         # 计算最左侧车道线簇所确定的直线的k和b值,将其存储在leftLaneKB中

  568.         leftLaneKB = calculateLeftLane_k_b(allLaneContent, laneXCoordinateMin2MaxSort, leftLaneSerialNumber, leftLaneBox, leftLaneAbovePoint, leftLaneKB, leftLaneCenterX, leftLaneCenterY, pars)

  569.         # 计算最右侧车道线簇所确定的直线的k和b值,将其存储在rightLaneKB中

  570.         rightLaneKB = calculateRightLane_k_b(allLaneContent, laneXCoordinateMax2MinSort, rightLaneSerialNumber, rightLaneBox, rightLaneAbovePoint, rightLaneKB, rightLaneCenterX, rightLaneCenterY, pars)

  571. 

  572.     count = 0

  573.     for i in range(0, len(pars['vehicleCoordinate']), 2):

  574.         vehicleAreaList = []

  575.         mask = np.zeros(image_vehicle.shape[:2], dtype="uint8")

  576.         x0 = int(pars['vehicleCoordinate'][i][0] * pars['ZoomFactor']['x'])

  577.         y0 = int(pars['vehicleCoordinate'][i][1] * pars['ZoomFactor']['y'])

  578.         x1 = int(pars['vehicleCoordinate'][i + 1][0] * pars['ZoomFactor']['x'])

  579.         y1 = int(pars['vehicleCoordinate'][i + 1][1] * pars['ZoomFactor']['y'])

  580.         cv2.rectangle(mask, (x0, y0), (x1, y1), 255, -1, lineType=cv2.LINE_AA)

  581.         image_vehicle_masked = cv2.bitwise_and(image_vehicle, image_vehicle, mask=mask)

  582.         img2 = cv2.cvtColor(image_vehicle_masked, cv2.COLOR_BGR2GRAY)

  583.         contours2, hierarchy2 = cv2.findContours(img2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

  584. 

  585.         """ 将符合标准的vehicle信息存储在complianceVehicle中，将不符合标准的vehicle信息存储在NonComplianceVehicle中 """

  586.         ##主要做面积的过滤。

  587.         if len(contours2) != 0:

  588.             if len(contours2) > 1:  # 这里我通过比较同一检测框内各个contours对应的最小外接矩形的面积，来剔除那些存在干扰的contours，最终只保留一个contours

  589.                 for j in range(len(contours2)):

  590.                     contours_j = contours2[j]

  591.                     rect = cv2.minAreaRect(contours_j)

  592.                     vehicleAreaList.append(rect[1][0] * rect[1][1])

  593.                 if max(vehicleAreaList) >= pars['vehicleArea']:

  594.                     maxAreaIndex = vehicleAreaList.index(max(vehicleAreaList))

  595.                     maxAreacontours = contours2[maxAreaIndex]

  596.                     if len(maxAreacontours) >= 6:

  597.                         vehicleContours.append(maxAreacontours)

  598.                         complianceVehicle.append(dets[count])

  599.                     else:

  600.                         dets[int(i / 2)].append(0)

  601.                         dets[int(i / 2)].append(0)

  602.                         NonComplianceVehicle.append(dets[int(i / 2)])

  603.                 else:

  604.                     dets[int(i / 2)].append(0)

  605.                     dets[int(i / 2)].append(0)

  606.                     NonComplianceVehicle.append(dets[int(i / 2)])

  607.             elif len(contours2) == 1:

  608.                 contours_j = contours2[0]

  609.                 rect = cv2.minAreaRect(contours_j)

  610.                 if rect[1][0] * rect[1][1] >= pars['vehicleArea']:

  611.                     if len(contours_j) >= 6:

  612.                         vehicleContours.append(contours_j)

  613.                         complianceVehicle.append(dets[count])

  614.                     else:

  615.                         dets[int(i / 2)].append(0)

  616.                         dets[int(i / 2)].append(0)

  617.                         NonComplianceVehicle.append(dets[int(i / 2)])

  618.                 else:

  619.                     dets[int(i / 2)].append(0)

  620.                     dets[int(i / 2)].append(0)

  621.                     NonComplianceVehicle.append(dets[int(i / 2)])

  622.         else:

  623.             dets[int(i/2)].append(0)

  624.             dets[int(i/2)].append(0)

  625.             NonComplianceVehicle.append(dets[int(i/2)])

  626.         count += 1

  627.     dets = complianceVehicle

  628. 

  629.     """ 对vehicle是否在speedRoad上进行判断，并计算违章得分 """

  630.     if len(vehicleContours) != 0:

  631.         for i in range(len(vehicleContours)):

  632.             rect = cv2.minAreaRect(vehicleContours[i])

  633.             if len(allSpeedRoadContent) != 0:

  634.                 for j in range(len(allSpeedRoadContent)):

  635.                     # 判断车辆矩形框的中心点坐标是否在道路矩形框Xmin,Xmax,Ymin和Ymax的范围内；

  636.                     if (rect[0][0] > allSpeedRoadContent[j][0] and rect[0][0] < allSpeedRoadContent[j][1]) and (rect[0][1] > allSpeedRoadContent[j][2] and rect[0][1] < allSpeedRoadContent[j][3]):

  637.                         # 将Box2D结构作为输入并返回4个角点。

  638.                         box = cv2.boxPoints(rect).astype(np.int32)

  639.                         # 比较车辆矩形框四个顶点的坐标是否都在道路矩形框Xmin,Xmax,Ymin和Ymax的范围内，若都在，则说明该车辆在这条道路上。

  640.                         if (box[0][0] >= allSpeedRoadContent[j][0] and box[0][0] <= allSpeedRoadContent[j][1] and box[0][1] >= allSpeedRoadContent[j][2] and box[0][1] <= allSpeedRoadContent[j][3]) and (box[1][0] >= allSpeedRoadContent[j][0] and box[1][0] <= allSpeedRoadContent[j][1] and box[1][1] >= allSpeedRoadContent[j][2] and box[1][1] <= allSpeedRoadContent[j][3]) and (box[2][0] >= allSpeedRoadContent[j][0] and box[2][0] <= allSpeedRoadContent[j][1] and box[2][1] >= allSpeedRoadContent[j][2] and box[2][1] <= allSpeedRoadContent[j][3]) and (box[3][0] >= allSpeedRoadContent[j][0] and box[3][0] <= allSpeedRoadContent[j][1] and box[3][1] >= allSpeedRoadContent[j][2] and box[3][1] <= allSpeedRoadContent[j][3]):

  641.                             dets[i].append(0)  # 给违章得分占位

  642.                             dets[i].append(0)  # 给违章类别占位

  643.                             # 当车道线个数至少有两条时，才计算违章得分

  644.                             if len(allLaneContent) >= 2:

  645.                                 if rect[0][1] < leftLaneKB[0] * rect[0][0] + leftLaneKB[1]:

  646.                                     distanceCenterToLine = abs(leftLaneKB[0] * rect[0][0] - rect[0][1] + leftLaneKB[1]) / math.sqrt(leftLaneKB[0] * leftLaneKB[0] + 1)

  647.                                     if distanceCenterToLine >= min(rect[1]) / 2:

  648.                                         dets[i][6] = 1

  649.                                         dets[i][7] = 1

  650.                                     else:

  651.                                         score4 = distanceCenterToLine / (min(rect[1]) / 2)

  652.                                         dets[i][6] = score4

  653.                                         dets[i][7] = 1

  654.                                 elif rect[0][1] < rightLaneKB[0] * rect[0][0] + rightLaneKB[1]:

  655.                                     distanceCenterToLine = abs(rightLaneKB[0] * rect[0][0] - rect[0][1] + rightLaneKB[1]) / math.sqrt(rightLaneKB[0] * rightLaneKB[0] + 1)

  656.                                     if distanceCenterToLine >= min(rect[1]) / 2:

  657.                                         dets[i][6] = 1

  658.                                         dets[i][7] = 1

  659.                                     else:

  660.                                         score4 = distanceCenterToLine / (min(rect[1]) / 2)

  661.                                         dets[i][6] = score4

  662.                                         dets[i][7] = 1

  663.                             break

  664.             # 如果分割图像中不存在speedRoad，则无法进行违章判定，将所有车辆的违章类别设为0，即没有违章

  665.             if len(dets[i]) < 8:

  666.                 dets[i].append(0)  # 违章得分为0

  667.                 dets[i].append(0)  # 0表示没有违章

  668.         targetList = dets

  669.         for i in range(len(NonComplianceVehicle)):

  670.             targetList.append(NonComplianceVehicle[i])  # 将所有车辆的信息合并到一起

  671.             # 目标对象, [[cls, x0, y0, x1, y1, score, 违章得分, 违章类别], ...]

  672.     else:

  673.         targetList = NonComplianceVehicle

  674. 

  675.     t6 = time.time()

  676.     time_infos = 'postTime:%.2f (分割时间：%.2f, findContours:%.2f  ruleJudge:%.2f)' % (

  677.     get_ms(t6, t3), get_ms(t4, t3), get_ms(t5, t4), get_ms(t6, t5))

  678. 

  679.     targetList = [ [ b[7]  ,*b[1:5],b[6] if b[6]>0 else b[5]] for b in targetList ]

  680.     #最终输出格式：[[cls, x0, y0, x1, y1, 车辆得分, 违章停车得分, 违章类别], ...]

  681.     

  682. 

  683.     return targetList, time_infos