9.传统的轨道画线算法（完成）

轨道画线分为以下步骤：

1.读取摄像头图片

2.图片灰度处理，截取轨道区域的图片

3.中值滤波处理，并区域取均值后做期望差的绝对值。本人通过一些轨道图片实验，用这种方法二值化得到的效果比caany算子等方法的效果好

4.二值化后再用DBSAN聚类算法对图片分类

5.对分好类的坐标在图片中画图

具体代码如下：

import numpy as np
import cv2


colors = [ (0, 0, 0), (128, 0, 0), (0, 128, 0), (128, 128, 0), (0, 0, 128), (128, 0, 128), (0, 128, 128),
                            (128, 128, 128), (64, 0, 0), (192, 0, 0), (64, 128, 0), (192, 128, 0), (64, 0, 128), (192, 0, 128),
                            (64, 128, 128), (192, 128, 128), (0, 64, 0), (128, 64, 0), (0, 192, 0), (128, 192, 0), (0, 64, 128),
                            (128, 64, 12)]

def cluster(points, radius=100):
    """
    points: pointcloud
    radius: max cluster range
    """
    print("................", len(points))
    items = []
    while len(points)>1:
        item = np.array([points[0]])
        base = points[0]
        points = np.delete(points, 0, 0)
        distance = (points[:,0]-base[0])**2+(points[:,1]-base[1])**2#获得距离
        infected_points = np.where(distance <= radius**2)#与base距离小于radius**2的点的坐标
        item = np.append(item, points[infected_points], axis=0)
        border_points = points[infected_points]
        points = np.delete(points, infected_points, 0)
        #print("................",len(points))
        #print(border_points)
        while len(border_points) > 0:
            border_base = border_points[0]
            border_points = np.delete(border_points, 0, 0)
            border_distance = (points[:,0]-border_base[0])**2+(points[:,1]-border_base[1])**2
            border_infected_points = np.where(border_distance <= radius**2)
            #print("/",border_infected_points)
            item = np.append(item, points[border_infected_points], axis=0)
            for k in border_infected_points:
                if points[k] not in border_points:
                    border_points=np.append(border_points,points[k], axis=0)
            #border_points = points[border_infected_points]
            points = np.delete(points, border_infected_points, 0)
        items.append(item)
    return items



#2.图像的灰度处理、边缘分割
def mean_img(img):
    # gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    #1.图片的灰度，截取处理
    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    imgss=img[540:743, 810:1035]
    gray_img = gray_img[540:741, 810:1030]#[540:741, 810:1080]
    img2=gray_img
    print(img2.mean())

    #中值滤波
    gray_img = cv2.medianBlur(gray_img, ksize=3)
    cv2.imshow("Dilated Image", gray_img)
    cv2.waitKey(0)

    #2.行做期望差,3个值取均值再做差
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]-2):
            ss1=gray_img[i, j:j+2].mean()
            m=abs(gray_img[i][j]-ss1)
            if m>13:
                img2[i][j] =255
            else:
                img2[i][j] =0

    img2[:,-3:]=0
    cv2.imshow("img_mean", img2)
    cv2.waitKey(0)

    # 3.腐蚀膨胀消除轨道线外的点
    kernel = np.uint8(np.ones((5, 2)))
    # 膨胀图像.....为了使得轨道线更粗，且补足轨道线缺失的地方
    dilated = cv2.dilate(img2, kernel)
    #显示膨胀后的图像
    #dilated[:, -6:] = 0
    cv2.imshow("Dilated Image", dilated)
    cv2.waitKey(0)
    ss=np.argwhere(dilated>0)
    print(ss)

    #聚类算法
    items = cluster(ss, radius=5)
    print(len(items))
    i=0
    for item in items:
        print("====>", len(item))
        if len(item)>500:
            for k in item:
                imgss[k[0]][k[1]]=colors[i]
            i+=1
    cv2.imshow("ss",imgss)
    cv2.waitKey(0)

    return ss


if __name__ == '__main__':

    img_path=r"图片路径"

    img=cv2.imread(img_path)

    ss=mean_img(img)

    ss=np.array(ss)

    items=cluster(ss, radius=25)

通过以上聚类的方法处理后的图片如下：

? ? ? ? 接下来对两类点进行处理。在这里目前想到的处理方式有两种：一是：首先对每个类取行的中值或者均值，即每个类的每行只保留一个坐标（均值或者中间值），去除掉了每行两边的坐标。但这个效果不太好，后面会附加代码和处理的图片结果；二是根据霍夫曼求直线的方法，自己重新写个获取直线。

一、取均值或者中值的代码如下：

import numpy as np
import cv2
import time


colors = [ (0, 0, 0), (128, 0, 0), (0, 128, 0), (128, 128, 0), (0, 0, 128), (128, 0, 128), (0, 128, 128),
                            (128, 128, 128), (64, 0, 0), (192, 0, 0), (64, 128, 0), (192, 128, 0), (64, 0, 128), (192, 0, 128),
                            (64, 128, 128), (192, 128, 128), (0, 64, 0), (128, 64, 0), (0, 192, 0), (128, 192, 0), (0, 64, 128),
                            (128, 64, 12)]

def cluster(points, radius=100):
    """
    points: pointcloud
    radius: max cluster range
    """
    print("................", len(points))
    items = []
    while len(points)>1:
        item = np.array([points[0]])
        base = points[0]
        points = np.delete(points, 0, 0)
        distance = (points[:,0]-base[0])**2+(points[:,1]-base[1])**2#获得距离
        infected_points = np.where(distance <= radius**2)#与base距离小于radius**2的点的坐标
        item = np.append(item, points[infected_points], axis=0)
        border_points = points[infected_points]
        points = np.delete(points, infected_points, 0)
        #print("................",len(points))
        #print(border_points)
        while len(border_points) > 0:
            border_base = border_points[0]
            border_points = np.delete(border_points, 0, 0)
            border_distance = (points[:,0]-border_base[0])**2+(points[:,1]-border_base[1])**2
            border_infected_points = np.where(border_distance <= radius**2)
            #print("/",border_infected_points)
            item = np.append(item, points[border_infected_points], axis=0)
            if len(border_infected_points)>0:
                for k in border_infected_points:
                    if points[k] not in border_points:
                        border_points=np.append(border_points,points[k], axis=0)
                #border_points = points[border_infected_points]
            points = np.delete(points, border_infected_points, 0)
        items.append(item)
    return items


def k_mean(out):
    print("........................开始计算图片的均值.....................")
    median = {}
    i = 1
    for items in out:
        median[str(i)] = []
        result = items[:, :-1]
        ss = result.shape
        result = result.reshape(ss[1], ss[0])
        result = result[0].tolist()
        result = list(set(result))  # 去掉result重复的值
        for m in result:
            #print("...............", m, "...............................")
            item = np.where(items[:, :-1] == m)[0]
            # median[str(i)].append(items[item[len(item)//2]].tolist()) #中位数,有用
            median[str(i)].append([m, int(items[item][:, -1:].mean())])  # 均值
        i += 1
    return median

#直线的拟合
def lines(median,distances):
    print("...................直线的拟合......................")
    for items in median:
        n_m=np.array(median[items])#转换为array数据
        means=n_m[:,1:]#取坐标的第二列
        lens=n_m[-1][0]+1#总共多少个坐标，即坐标个数
        #print(lens)

        #1.获取x1,x2的坐标
        if lens%4>2:
            x10=lens//4+1
        else:
            x10 = lens // 4
        x20=x10*3
        x=lens//2
        #print("x1,x2:  ",x10,x20)

        #2.获取y1,y2的坐标
        y10=means[:lens//2].mean()
        y20 = means[lens // 2-1:].mean()
        y=means.mean()
        #print("y1,y2:  ", y10, y20)

        #3.获取直线斜率k k=(y1-y2)/(x1-x2)
        k=(y10-y20)/(x10-x20)
        #print("k:  ",k)
        #print("x,y:      ",x,y)

        #4.预测某个点的y值 y-pred=k*(x_pred-x)+y  n_m[i]
        for i in range(len(n_m)):
            y_pred = k * (n_m[i][0] - x) + y
            #print("===>",y_pred,n_m[i][0],n_m[i][1])
            if abs(y_pred-n_m[i][1])>distances:
                n_m[i][1]=y_pred
                #median[items][i][1]=int(y_pred)
        median[items]=n_m.tolist()
    return median



#2.图像的灰度处理、边缘分割
def mean_img(img,x1,x2,y1,y2):

    imgs=img.copy()
    img4 = img.copy()
    #1.图片的灰度，截取处理
    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    gray_img = gray_img[x1:x2, y1:y2]#[540:741, 810:1080],截取轨道画线的区域，对该区域识别轨道
    img2=gray_img

    #2.中值滤波
    gray_img = cv2.medianBlur(gray_img, ksize=3)
    # cv2.imshow("Dilated Image", gray_img)
    # cv2.waitKey(0)
    st=time.time()
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]-2):
            ss1 = gray_img[i, j:j + 2].mean()
            m=abs(gray_img[i][j]-ss1)
            if m>9:
                img2[i][j] =255
            else:
                img2[i][j] =0
    img2[:,-3:]=0

    et = time.time()
    print("kmeans时间",et-st)

    # cv2.imshow("img_mean", img2)
    # cv2.waitKey(0)

    # 3.腐蚀膨胀消除轨道线外的点
    st1=time.time()
    kernel = np.uint8(np.ones((2, 1)))
    # 膨胀图像.....为了使得轨道线更粗，且补足轨道线缺失的地方
    dilated = cv2.dilate(img2, kernel)
    #显示膨胀后的图像
    # cv2.imshow("Dilated Image", dilated)
    # cv2.waitKey(0)
    kernel = np.ones((2, 2), np.uint8)
    dilated = cv2.erode(dilated, kernel)
    cv2.imshow("ss",dilated)
    cv2.waitKey(0)

    ss=np.argwhere(img2>0)#dilated
    #聚类算法
    items = cluster(ss, radius=3)
    print(len(items))
    i=0
    out=[]#获得大于300个坐标的类
    for item in items:
        if len(item)>300:
            out.append(item)
            print("====>", len(item))
            for k in item:
                img[k[0]+x1][k[1]+y1]=colors[i]#[540:743, 810:1035]
            i+=1
    # cv2.imshow("ss",img)
    # cv2.waitKey(0)
    et1 = time.time()
    print("聚类时间：", et1 - st1)

    #求聚类的每类每行的中位数
    median=k_mean(out)

    #根据中位数画图
    j=0
    for item in median:
        for k in median[item]:
            #print(k[0],k[1])
            imgs[k[0]+x1][k[1]+y1] = colors[j]  # [540:743, 810:1035]
        j+=1

    et3=time.time()
    print("中位数时间：", et3 - et1)
    print(".....................................","\n")
    #用直线拟合，首先用两个均值得到初始线的斜率及均值坐标，然后不断对远离的坐标点拟合

    distances=4
    while distances>0:
        median=lines(median,distances)
        distances-=1

    #画图
    j = 0
    for item in median:
        for k in median[item]:
            # print(k[0],k[1])
            img4[k[0] + x1][k[1] + y1] = colors[j]  # [540:743, 810:1035]
        j += 1

    et4=time.time()
    print("直线拟合消耗时间：",et4-et3)


    return out

if __name__ == '__main__':

    start=time.time()

    img_path=r图片路径"

    img=cv2.imread(img_path)

    out=mean_img(img,x1=650,x2=741,y1=825,y2=1025)

    end=time.time()

    print("time:",end-start)

????????上述的直线拟合没有用最小二乘法，处理后的画图结果如下：

显然，拟合的结果并不好。下面用霍夫曼求直线的方法拟合。

二、霍夫曼圆找直线

????????这种方法不用上面的代码，简单直接，并且效果更好。代码和结果如下：

代码：

import numpy as np
import time
import cv2

#2.图片处理，再通过上面的聚类函数获取轨道的类
def mean_img(img,x1,x2,y1,y2):

    #1.图片的灰度，截取处理
    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    gray_img = gray_img[x1:x2, y1:y2]#[540:741, 810:1080],截取轨道画线的区域，对该区域识别轨道


    #2.霍夫曼直线求点
    edges=cv2.Canny(gray_img, 120, 255, apertureSize=3)
    lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 30, minLineLength=50, maxLineGap=10)

    ss=[]#获取每条直线的长度的平方，以便后面根据直线的长度排序
    for line in lines:
        #   print(type(line))
        x10, y10, x20, y20 = line[0]
        distance=(y20-y10)**2+(x10-x20)**2#每条直线长度的平方
        ss.append([distance,[x10, y10, x20, y20]])
    ss=np.array(ss)

    indexs=np.lexsort([ss[:,0]])#根据长度对直线由小到大排序，获得排序的index值
    data=ss[indexs,:]#data:排序后的ss

    lines=data[:,-1:]
    index_2 =[]#从lines获取轨道两边的直线
    index_2.append(lines[-1][0])#首先获取长度最长的一条直线
    for i in range(len(lines)-1,0,-1):
        if abs(lines[i][0][0]-index_2[0][0])>25:#另一条直线的获取是从后向前遍历，两直线一端的横坐标的差大于25时，则是另外一条直线，获得后结束后面的遍历
            index_2.append(lines[i][0])
            break
    #画图
    for iten in index_2:
        x10, y10, x20, y20 = iten
        cv2.line(img, (x10 + y1, y10 + x1), (x20 + y1, y20 + x1), (0, 0, 255), 2)
    cv2.imwrite("保存文件的路径\\120.jpg", img)
    # cv2.imshow("line_detect_possible_demo", img)
    # cv2.waitKey(0)


if __name__ == '__main__':

    start=time.time()

    img_path=r"图片路径"

    img=cv2.imread(img_path)
    #x1, x2, y1, y2：表示在相机图片中截取要画线区域的轨道部分的区域（减小计算，使背景更简单）
    out = mean_img(img, x1=650, x2=741, y1=825, y2=1025)  # x1=540,x2=741,y1=810,y2=1030

    end = time.time()

    print("time:", end - start)

效果如下：

????????当然，这个是近焦相机拍的近距离的轨道，可以再用远焦相机拍远距离的轨道拟合直线，然后将两条直线融合。