• Steger算法实现结构光光条中心提取(python版本)

    Steger算法原理

    对结构光进行光条中心提取时，Steger算法是以Hessian矩阵为基础的。它的基础步骤如下所示：

    1. 从Hessian矩阵中求出线激光条纹的法线方向
    2. 在光条纹法线方向上将其灰度分布按照泰勒多项式展开，求取的极大值即为光条在该法线方向上的亚像素坐标。对于二维离散图像I(u,v)来说，Hessian矩阵可以表示为：

    H(u,v) = \begin{bmatrix} I_{uu} &I_{uv} \\ I_{uv} & I_{vv} \end{bmatrix}

    这里面的u，v表示的就是像素的行坐标和列坐标，I_{uv}代表像素(u,v)的灰度也可以称之为灰度分布函数。而I_{uu}，I_{uv}和I_{vv}都可以通过I_{uv}与二维高斯函数G(u,v)卷积运算得到。

    G(u,v) = \frac{1}{\sigma\sqrt{2 \pi}}\cdot e^{\left ( -\frac{u^{2}+v^{2}}{2\sigma^{2}} \right )}

    I_{uu}=\frac{\partial ^{2}}{\partial u\partial u}G(u,v)\bigotimes I_{uv}

    I_{uv}=\frac{\partial ^{2}}{\partial u\partial v}G(u,v)\bigotimes I_{uv}

    I_{vv}=\frac{\partial ^{2}}{\partial v\partial v}G(u,v)\bigotimes I_{uv} 

    在这里，二维高斯函数，其主要作用是为了让光条灰度分布特性更加明显，在G(u,v)表达式中，\sigma是标准差，一般取\sigma \geq \frac{W}{\sqrt{3}}，W代表光条宽度。在像素(u,v)处的Hessian矩阵有两个特征向量，其中一个绝对值较大，为该像素处的法线方向向量，而另外一个则是切向方向向量。因此可以通过求取Hessian矩阵的特征向量来计算出法线方向。某一像素点H(u_{0},v_{0})，在二阶泰勒展开式Hessian矩阵为：

    H(u0,v0)=[IuuIuvIuvIvv]

    由该点的Hessian矩阵所求出的特征值和特征向量分别与该点的法线方向和该方向的二阶方向导数相对应。其中法线方向的单位向量为：e=[eu,ev]，并且在光条纹法线方向上的像素点(u0+t⋅eu,v0+t⋅ev)，并且在光条纹法线方向上的像素点I=(u0+t⋅eu,v0+t⋅ev)可以由像素(u0,v0)的灰度I(u0,v0)和二阶泰勒展开多项式表示为：

    I(u0+t⋅eu,v0+t⋅ev)=I(u0,v0)+t⋅e[Iu,Iv]T+t⋅e⋅H(u,v)⋅eT

    t=−eu⋅Iu+ev⋅Ive2u⋅Iuu+2⋅eu⋅ev⋅Iuv+e2v⋅Ivv

    再将t(即泰勒展开式)代入其中即可求出光条纹中心的亚像素坐标。

    Steger算法Python实现

    这一部分，我在网上找到了许多C++版本的Steger算法实现，本人参考了现有的C++版本Steger算法实现，在此基础上进行了改进，用Python重新去实现该算法。

    计算图像的一阶导数和二阶导数

    这里我采用了三种方法，分别是自定义卷积、Scharr 滤波器、Sobel 滤波器来计算图像的导数和二阶导数。

    1. import cv2
    2. import numpy as np
    3.  
    4. def _derivation_with_Filter(Gaussimg):
    5.     dx = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1], [0], [-1]]))
    6.     dy = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1, 0, -1]]))
    7.     dxx = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1], [-2], [1]]))
    8.     dyy = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1, -2, 1]]))
    9.     dxy = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1, -1], [-1, 1]]))
    10.  
    11.     return dx, dy, dxx, dyy, dxy
    12.  
    13. def _derivation_with_Scharr(Gaussimg):
    14.     dx = cv2.Scharr(Gaussimg, cv2.CV_32F, 1, 0)
    15.     dy = cv2.Scharr(Gaussimg, cv2.CV_32F, 0, 1)
    16.     dxx = cv2.Scharr(dx, cv2.CV_32F, 1, 0)
    17.     dxy = cv2.Scharr(dx, cv2.CV_32F, 0, 1)
    18.     dyy = cv2.Scharr(dy, cv2.CV_32F, 0, 1)
    19.  
    20.     return dx, dy, dxx, dyy, dxy
    21.  
    22. def _derivation_with_Sobel(Gaussimg):
    23.     dx = cv2.Sobel(Gaussimg, cv2.CV_32F, 1, 0, ksize=3)
    24.     dy = cv2.Sobel(Gaussimg, cv2.CV_32F, 0, 1, ksize=3)
    25.     dxx = cv2.Sobel(dx, cv2.CV_32F, 1, 0, ksize=3)
    26.     dxy = cv2.Sobel(dx, cv2.CV_32F, 0, 1, ksize=3)
    27.     dyy = cv2.Sobel(dy, cv2.CV_32F, 0, 1, ksize=3)
    28.  
    29.     return dx, dy, dxx, dyy, dxy
    30.  
    31. if __name__=="__main__":
    32.     from pyzjr.dlearn import Runcodes
    33.     sigmaX, sigmaY = 1.1, 1.1
    34.  
    35.     img = cv2.imread(r"D:\PythonProject\net\line\linedata\Image_1.jpg")
    36.     gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    37.     Gaussimg = cv2.GaussianBlur(gray_img, ksize=(0, 0), sigmaX=sigmaX, sigmaY=sigmaY)
    38.     with Runcodes("Filter"):
    39.         dx, dy, dxx, dyy, dxy = _derivation_with_Filter(Gaussimg)
    40.         print(type(dx[0][0]))
    41.     with Runcodes("Scharr"):
    42.         dx1, dy1, dxx1, dyy1, dxy1 = _derivation_with_Scharr(Gaussimg)
    43.         print(type(dx1[0][0]))
    44.     with Runcodes("Sobel"):
    45.         dx2, dy2, dxx2, dyy2, dxy2 = _derivation_with_Sobel(Gaussimg)
    46.         print(type(dx2[0][0]))

    在控制台中输出为：


    Filter: 0.00602 sec

    Scharr: 0.00770 sec

    Sobel: 0.01025 sec

    从运算时间上来看，自定义的Filter速度最快，scharr滤波器居中，sobel滤波器最慢；从元素类型上来看，第一种为uint8，另外两种为float32类型。

    通过选择计算方法可以去创建Hessian矩阵。

    1. def Magnitudefield(dxx, dyy):
    2.     """计算幅度和相位"""
    3.     dxx = dxx.astype(float)
    4.     dyy = dyy.astype(float)
    5.     mag = cv2.magnitude(dxx, dyy)
    6.     phase = mag*180./np.pi
    7.     return mag, phase
    8.  
    9. def derivation(gray_img, sigmaX, sigmaY, method="Scharr", nonmax=False):
    10.     """
    11.     计算图像的一阶导数 dx 和 dy，以及二阶导数 dxx、dyy 和 dxy
    12.     :param gray_img: 灰度图
    13.     :param sigmaX: 在水平方向的高斯核标准差,用于激光线提取建议取1-2
    14.     :param sigmaY: 在垂直方向上的高斯核标准差,用于激光线提取建议取1-2
    15.     :param method:"Scharr"  or  "Filter"  or  "Sobel"
    16.                   选择什么方式获取dx, dy, dxx, dyy, dxy,提供了卷积与Scharr和Sobel滤波器三种方式计算,
    17.                   Scharr滤波器通常会产生更平滑和准确的结果,所以这里默认使用"Scharr"方法,虽然
    18.                   "Sobel"运行比另外两种要慢,但在使用的时候,建议自己试试
    19.     :return: dx, dy, dxx, dyy, dxy
    20.     """
    21.     Gaussimg = cv2.GaussianBlur(gray_img, ksize=(0, 0), sigmaX=sigmaX, sigmaY=sigmaY)
    22.     dx, dy, dxx, dyy, dxy = _derivation_with_Scharr(Gaussimg)
    23.     if method == "Filter":
    24.         dx, dy, dxx, dyy, dxy = _derivation_with_Filter(Gaussimg)
    25.     elif method == "Sobel":
    26.         dx, dy, dxx, dyy, dxy =_derivation_with_Sobel(Gaussimg)
    27.     if nonmax:
    28.         normal, phase = Magnitudefield(dxx, dyy)
    29.         dxy = nonMaxSuppression(normal, phase)
    30.     return dx, dy, dxx, dyy, dxy
    31.  
    32. def nonMaxSuppression(det, phase):
    33.     """非最大值抑制"""
    34.     gmax = np.zeros(det.shape)
    35.     # thin-out evry edge for angle = [0, 45, 90, 135]
    36.     for i in range(gmax.shape[0]):
    37.         for j in range(gmax.shape[1]):
    38.             if phase[i][j] < 0:
    39.                 phase[i][j] += 360
    40.             if ((j+1) < gmax.shape[1]) and ((j-1) >= 0) and ((i+1) < gmax.shape[0]) and ((i-1) >= 0):
    41.                 # 0 degrees
    42.                 if (phase[i][j] >= 337.5 or phase[i][j] < 22.5) or (phase[i][j] >= 157.5 and phase[i][j] < 202.5):
    43.                     if det[i][j] >= det[i][j + 1] and det[i][j] >= det[i][j - 1]:
    44.                         gmax[i][j] = det[i][j]
    45.                 # 45 degrees
    46.                 if (phase[i][j] >= 22.5 and phase[i][j] < 67.5) or (phase[i][j] >= 202.5 and phase[i][j] < 247.5):
    47.                     if det[i][j] >= det[i - 1][j + 1] and det[i][j] >= det[i + 1][j - 1]:
    48.                         gmax[i][j] = det[i][j]
    49.                 # 90 degrees
    50.                 if (phase[i][j] >= 67.5 and phase[i][j] < 112.5) or (phase[i][j] >= 247.5 and phase[i][j] < 292.5):
    51.                     if det[i][j] >= det[i - 1][j] and det[i][j] >= det[i + 1][j]:
    52.                         gmax[i][j] = det[i][j]
    53.                 # 135 degrees
    54.                 if (phase[i][j] >= 112.5 and phase[i][j] < 157.5) or (phase[i][j] >= 292.5 and phase[i][j] < 337.5):
    55.                     if det[i][j] >= det[i - 1][j - 1] and det[i][j] >= det[i + 1][j + 1]:
    56.                         gmax[i][j] = det[i][j]
    57.     return gmax

    Magnitudefield(dxx, dyy)函数计算梯度的幅度和相位，使用给定的 x 和 y 导数 (dxx 和 dyy)。幅度代表梯度的强度，相位代表梯度的方向；nonMaxSuppression(det, phase)函数根据梯度的相位 (phase) 对梯度幅度 (det) 执行非最大值抑制。它有助于在梯度方向上仅保留局部最大值，从而细化检测到的边缘；然后应用于derivation函数中去调控。

    二阶泰勒展开式Hessian矩阵

    1. def HessianMatrix(self, dx, dy, dxx, dyy, dxy, threshold=0.5):
    2.     """
    3.     HessianMatrix = [dxx    dxy]
    4.                     [dxy    dyy]
    5.     compute hessian:
    6.             [dxx   dxy]         [00    01]
    7.                          ====>
    8.             [dxy   dyy]         [10    11]
    9.     """
    10.     point=[]
    11.     direction=[]
    12.     value=[]
    13.     for x in range(0, self.col):
    14.         for y in range(0, self.row):
    15.             if dxy[y,x] > 0:
    16.                 hessian = np.zeros((2,2))
    17.                 hessian[0,0] = dxx[y,x]
    18.                 hessian[0,1] = dxy[y,x]
    19.                 hessian[1,0] = dxy[y,x]
    20.                 hessian[1,1] = dyy[y,x]
    21.                 # 计算矩阵的特征值和特征向量
    22.                 _, eigenvalues, eigenvectors = cv2.eigen(hessian)
    23.                 if np.abs(eigenvalues[0,0]) >= np.abs(eigenvalues[1,0]):
    24.                     nx = eigenvectors[0,0]
    25.                     ny = eigenvectors[0,1]
    26.                 else:
    27.                     nx = eigenvectors[1,0]
    28.                     ny = eigenvectors[1,1]
    29.  
    30.                 # Taylor展开式分子分母部分,需要避免为0的情况
    31.                 Taylor_numer = (dx[y, x] * nx + dy[y, x] * ny)
    32.                 Taylor_denom = dxx[y,x]*nx*nx + dyy[y,x]*ny*ny + 2*dxy[y,x]*nx*ny
    33.                 if Taylor_denom != 0:
    34.                     T = -(Taylor_numer/Taylor_denom)
    35.                     # Hessian矩阵最大特征值对应的特征向量对应于光条的法线方向
    36.                     if np.abs(T*nx) <= threshold and np.abs(T*ny) <= threshold:
    37.                         point.append((x,y))
    38.                         direction.append((nx,ny))
    39.                         value.append(np.abs(dxy[y,x]+dxy[y,x]))
    40.     return point, direction, value

    这一部分我定义在steger类下了

    绘制中心线在背景与原图中

    1. def centerline(self,img, sigmaX, sigmaY, method="Scharr", usenonmax=True, color=(0, 0, 255)):
    2.     dx, dy, dxx, dyy, dxy = derivation(self.gray_image, sigmaX, sigmaY, method=method, nonmax=usenonmax)
    3.     point, direction, value = self.HessianMatrix(dx, dy, dxx, dyy, dxy)
    4.     for point in point:
    5.         self.newimage[point[1], point[0]] = 255
    6.         img[point[1], point[0], :] = color
    7.  
    8.     return img, self.newimage

    代码以及效果展示

    1. import cv2
    2. import numpy as np
    3.  
    4. def _derivation_with_Filter(Gaussimg):
    5.     dx = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1], [0], [-1]]))
    6.     dy = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1, 0, -1]]))
    7.     dxx = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1], [-2], [1]]))
    8.     dyy = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1, -2, 1]]))
    9.     dxy = cv2.filter2D(Gaussimg,-1, kernel=np.array([[1, -1], [-1, 1]]))
    10.  
    11.     return dx, dy, dxx, dyy, dxy
    12.  
    13. def _derivation_with_Scharr(Gaussimg):
    14.     dx = cv2.Scharr(Gaussimg, cv2.CV_32F, 1, 0)
    15.     dy = cv2.Scharr(Gaussimg, cv2.CV_32F, 0, 1)
    16.     dxx = cv2.Scharr(dx, cv2.CV_32F, 1, 0)
    17.     dxy = cv2.Scharr(dx, cv2.CV_32F, 0, 1)
    18.     dyy = cv2.Scharr(dy, cv2.CV_32F, 0, 1)
    19.  
    20.     return dx, dy, dxx, dyy, dxy
    21.  
    22. def _derivation_with_Sobel(Gaussimg):
    23.     dx = cv2.Sobel(Gaussimg, cv2.CV_32F, 1, 0, ksize=3)
    24.     dy = cv2.Sobel(Gaussimg, cv2.CV_32F, 0, 1, ksize=3)
    25.     dxx = cv2.Sobel(dx, cv2.CV_32F, 1, 0, ksize=3)
    26.     dxy = cv2.Sobel(dx, cv2.CV_32F, 0, 1, ksize=3)
    27.     dyy = cv2.Sobel(dy, cv2.CV_32F, 0, 1, ksize=3)
    28.  
    29.     return dx, dy, dxx, dyy, dxy
    30.  
    31. def Magnitudefield(dxx, dyy):
    32.     """计算幅度和相位"""
    33.     dxx = dxx.astype(float)
    34.     dyy = dyy.astype(float)
    35.     mag = cv2.magnitude(dxx, dyy)
    36.     phase = mag*180./np.pi
    37.     return mag, phase
    38.  
    39. def derivation(gray_img, sigmaX, sigmaY, method="Scharr", nonmax=False):
    40.     """
    41.     计算图像的一阶导数 dx 和 dy，以及二阶导数 dxx、dyy 和 dxy
    42.     :param gray_img: 灰度图
    43.     :param sigmaX: 在水平方向的高斯核标准差,用于激光线提取建议取1-2
    44.     :param sigmaY: 在垂直方向上的高斯核标准差,用于激光线提取建议取1-2
    45.     :param method:"Scharr"  or  "Filter"  or  "Sobel"
    46.                   选择什么方式获取dx, dy, dxx, dyy, dxy,提供了卷积与Scharr和Sobel滤波器三种方式计算,
    47.                   Scharr滤波器通常会产生更平滑和准确的结果,所以这里默认使用"Scharr"方法,虽然
    48.                   "Sobel"运行比另外两种要慢,但在使用的时候,建议自己试试
    49.     :return: dx, dy, dxx, dyy, dxy
    50.     """
    51.     Gaussimg = cv2.GaussianBlur(gray_img, ksize=(0, 0), sigmaX=sigmaX, sigmaY=sigmaY)
    52.     dx, dy, dxx, dyy, dxy = _derivation_with_Scharr(Gaussimg)
    53.     if method == "Filter":
    54.         dx, dy, dxx, dyy, dxy = _derivation_with_Filter(Gaussimg)
    55.     elif method == "Sobel":
    56.         dx, dy, dxx, dyy, dxy =_derivation_with_Sobel(Gaussimg)
    57.     if nonmax:
    58.         normal, phase = Magnitudefield(dxx, dyy)
    59.         dxy = nonMaxSuppression(normal, phase)
    60.     return dx, dy, dxx, dyy, dxy
    61.  
    62. def nonMaxSuppression(det, phase):
    63.     """非最大值抑制"""
    64.     gmax = np.zeros(det.shape)
    65.     # thin-out evry edge for angle = [0, 45, 90, 135]
    66.     for i in range(gmax.shape[0]):
    67.         for j in range(gmax.shape[1]):
    68.             if phase[i][j] < 0:
    69.                 phase[i][j] += 360
    70.             if ((j+1) < gmax.shape[1]) and ((j-1) >= 0) and ((i+1) < gmax.shape[0]) and ((i-1) >= 0):
    71.                 # 0 degrees
    72.                 if (phase[i][j] >= 337.5 or phase[i][j] < 22.5) or (phase[i][j] >= 157.5 and phase[i][j] < 202.5):
    73.                     if det[i][j] >= det[i][j + 1] and det[i][j] >= det[i][j - 1]:
    74.                         gmax[i][j] = det[i][j]
    75.                 # 45 degrees
    76.                 if (phase[i][j] >= 22.5 and phase[i][j] < 67.5) or (phase[i][j] >= 202.5 and phase[i][j] < 247.5):
    77.                     if det[i][j] >= det[i - 1][j + 1] and det[i][j] >= det[i + 1][j - 1]:
    78.                         gmax[i][j] = det[i][j]
    79.                 # 90 degrees
    80.                 if (phase[i][j] >= 67.5 and phase[i][j] < 112.5) or (phase[i][j] >= 247.5 and phase[i][j] < 292.5):
    81.                     if det[i][j] >= det[i - 1][j] and det[i][j] >= det[i + 1][j]:
    82.                         gmax[i][j] = det[i][j]
    83.                 # 135 degrees
    84.                 if (phase[i][j] >= 112.5 and phase[i][j] < 157.5) or (phase[i][j] >= 292.5 and phase[i][j] < 337.5):
    85.                     if det[i][j] >= det[i - 1][j - 1] and det[i][j] >= det[i + 1][j + 1]:
    86.                         gmax[i][j] = det[i][j]
    87.     return gmax
    88.  
    89.  
    90. class Steger():
    91.     def __init__(self, gray_image):
    92.         self.gray_image = gray_image
    93.         self.row, self.col = self.gray_image.shape[:2]
    94.         self.newimage = np.zeros((self.row, self.col), np.uint8)
    95.  
    96.     def centerline(self,img, sigmaX, sigmaY, method="Scharr", usenonmax=True, color=(0, 0, 255)):
    97.         dx, dy, dxx, dyy, dxy = derivation(self.gray_image, sigmaX, sigmaY, method=method, nonmax=usenonmax)
    98.         point, direction, value = self.HessianMatrix(dx, dy, dxx, dyy, dxy)
    99.         for point in point:
    100.             self.newimage[point[1], point[0]] = 255
    101.             img[point[1], point[0], :] = color
    102.     
    103.         return img, self.newimage
    104.  
    105.     def HessianMatrix(self, dx, dy, dxx, dyy, dxy, threshold=0.5):
    106.         """
    107.         HessianMatrix = [dxx    dxy]
    108.                         [dxy    dyy]
    109.         compute hessian:
    110.                 [dxx   dxy]         [00    01]
    111.                              ====>
    112.                 [dxy   dyy]         [10    11]
    113.         """
    114.         point=[]
    115.         direction=[]
    116.         value=[]
    117.         for x in range(0, self.col):
    118.             for y in range(0, self.row):
    119.                 if dxy[y,x] > 0:
    120.                     hessian = np.zeros((2,2))
    121.                     hessian[0,0] = dxx[y,x]
    122.                     hessian[0,1] = dxy[y,x]
    123.                     hessian[1,0] = dxy[y,x]
    124.                     hessian[1,1] = dyy[y,x]
    125.                     # 计算矩阵的特征值和特征向量
    126.                     _, eigenvalues, eigenvectors = cv2.eigen(hessian)
    127.                     if np.abs(eigenvalues[0,0]) >= np.abs(eigenvalues[1,0]):
    128.                         nx = eigenvectors[0,0]
    129.                         ny = eigenvectors[0,1]
    130.                     else:
    131.                         nx = eigenvectors[1,0]
    132.                         ny = eigenvectors[1,1]
    133.  
    134.                     # Taylor展开式分子分母部分,需要避免为0的情况
    135.                     Taylor_numer = (dx[y, x] * nx + dy[y, x] * ny)
    136.                     Taylor_denom = dxx[y,x]*nx*nx + dyy[y,x]*ny*ny + 2*dxy[y,x]*nx*ny
    137.                     if Taylor_denom != 0:
    138.                         T = -(Taylor_numer/Taylor_denom)
    139.                         # Hessian矩阵最大特征值对应的特征向量对应于光条的法线方向
    140.                         if np.abs(T*nx) <= threshold and np.abs(T*ny) <= threshold:
    141.                             point.append((x,y))
    142.                             direction.append((nx,ny))
    143.                             value.append(np.abs(dxy[y,x]+dxy[y,x]))
    144.         return point, direction, value
    145.  
    146.  
    147. def threshold(mask, std=127.5):
    148.     """阈值法"""
    149.     mask[mask > std] = 255
    150.     mask[mask < std] = 0
    151.     return mask.astype("uint8")
    152.  
    153. def Bessel(xi: list):
    154.     """贝塞尔公式"""
    155.     xi_array = np.array(xi)
    156.     x_average = np.mean(xi_array)
    157.     squared_diff = (xi_array - x_average) ** 2
    158.     variance = squared_diff / (len(xi)-1)
    159.     bessel = np.sqrt(variance)
    160.  
    161.     return bessel
    162.  
    163. def test_Steger():
    164.     img = cv2.imread(r"D:\PythonProject\net\line\data\Image_20230215160728679.jpg")
    165.  
    166.     gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    167.     gray_img = threshold(gray_img)
    168.     steger = Steger(gray_img)
    169.     img,newimage=steger.centerline(img,sigmaX=1.1,sigmaY=1.1,method="Sobel")
    170.     # point, direction, value = HessianMatrix(gray_img, 1.1, 1.1, usenonmax=True)
    171.  
    172.  
    173.     cv2.imwrite("result/main3.png", newimage)
    174.     cv2.imwrite("result/main3_img.png", img)
    175.  
    176.  
    177.  
    178. def test_derivation_methods_time():
    179.     from pyzjr.dlearn import Runcodes
    180.     img = cv2.imread(r"D:\PythonProject\net\line\data\Image_20230215160728411.jpg")
    181.     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    182.     gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    183.     with Runcodes(description="Filter"):
    184.         print(derivation(gray_img,1.1,1.1,"Filter"))
    185.         # Filter: 0.01344 sec
    186.  
    187.     with Runcodes(description="Scharr"):
    188.         print(derivation(gray_img, 1.1, 1.1))
    189.         # Scharr: 0.00959 sec
    190.  
    191.     with Runcodes(description="Sobel"):
    192.         print(derivation(gray_img, 1.1, 1.1,"Sobel"))
    193.         # Sobel: 0.01820 sec
    194.  
    195.  
    196.  
    197. if __name__=="__main__":
    198.     # test_derivation_methods_time()
    199.     test_Steger()

    我目前也没有弄明白为什么会出现三条线，似乎是中心线和轮廓，后续如果有改进会再次的更新

  • 相关阅读:
    simulink基础学习笔记
    Cadence23学习笔记（三）
    模型训练中的常见超参数解析
    【探索C语言中VS调试技巧】：提高效率和准确性
    python求多叉树任意两点之间的距离
    led台灯哪个牌子最好?2022最新的台灯牌子排名
    计算机毕业设计之java+ssm家校通网站
    角速度变化时四元数和旋转矩阵微分方程的证明
    与创新者同行！Apache Doris 首届线下峰会即将开启，最新议程公开！｜即刻预约
    ubuntu14.04改静态ip
  • 原文地址：https://blog.csdn.net/m0_62919535/article/details/133245716