智能图像分析——Hough变换

已于 2023-04-22 22:10:11 修改
阅读量493 收藏
点赞数
分类专栏： 智能图像分析 文章标签： 深度学习 人工智能 python
于 2023-04-04 19:27:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sharbbybai/article/details/129946535
版权

一、原理

引用
hough变换利用点、线对偶的思想，把提取图像空间中直线的问题转换成在参数空间/hough空间中计算点的峰值的问题。
在x − y坐标系中，假设有一条直线过点( x0 , y0 )，那么我们可以把这条直线的方程记为

y=mx+b（1）
现在，如果我们把参数和变量的身份对换一下，即（m,b）是变量，（x,y）是参数，那么公式1可以写成
b=−x0m+y0（2）
那么在b − m坐标系中，( x 0 , y 0 ) 就确定了一条直线。 回到x − y 坐标系，对直线y = m x + b ,记原点到它的距离是r,它的正切线与x轴的夹角是θ ， θ ∈ [ 0 , 180 ] ，

在这里插入图片描述

那么易得

在这里插入图片描述
，把公式3,4代入公式1，整理可得

在这里插入图片描述

r=xcosθ+ysinθ（5）
由公式5可知，如果是在θ − ρ坐标系中，( x 0 , y 0 ) 就确定了一条正弦曲线。上述的所谓x − y , m − b , θ − ρ 坐标系，我们分别称他们为图像空间、参数空间、hough空间。通过上面的分析可知，图像空间中的任何一个坐标点都对应着参数空间中的一条直线（或者hough空间中的一条正弦曲线），那么很多点就可以在参数空间中对应很多直线，这些直线间会相交，而每一个相交点( m i , b i ) 都代表着在此处相交的若干条直线 对应着的在图像空间中的哪些点应该在同一条直线上，并且这条直线的（斜率，截距）就是（m_i,b_i），此时，我们只需要计算哪些相交点有更多的直线经过，那这些相交点就更有可能是我们想要提取的原图像中的直线。 在实际操作时，我们使用θ , r，因为有些直线的斜率根本不存在或者很大，比并且( θ i , ρ i ) 也能表示图像空间中的一条直线，把公式3,4代入

在这里插入图片描述

二、语法

2.1 enumerate

引用

2.1.1 基本用法

s = [2,5,8,3,6,9]
for i in enumerate(s):
    print i

结果为：

(0, 2)
(1, 5)
(2, 8)
(3, 3)
(4, 6)
(5, 9)

按照一般的序列迭代方法，可以看出enumerate()函数的返回值是一个元组，元组构成为(index, value)，也就是序列索引和值的元组。

2.1.2 第二可选参数，解决索引从0开始输出的问题

enumerate()有两个参数序列和起始索引。
即enumerate(sequence , index)

s = [2,5,8,3,6,9]
for i in enumerate(s, 1):
    print i

结果为：

(1, 2)
(2, 5)
(3, 8)
(4, 3)
(5, 6)
(6, 9)

2.2 round

引用

2.2.1 round()是python自带的一个函数，用于数字的四舍五入。

2.2.2使用方法（环境python3）

round(number,digits)

参数：
digits>0，四舍五入到指定的小数位
digits=0, 四舍五入到最接近的整数
digits<0 ，在小数点左侧进行四舍五入
如果round()函数只有number这个参数，等同于digits=0

四舍五入规则：

  1. 要求保留位数的后一位<=4，则进位，如round(5.214,2)保留小数点后两位，结果是 5.21
  2. 要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位，如round(5.215,2)，结果为5.21
  3. 要求保留位数的后一位“=5”，且该位数后面有数字，则进位，如round(5.2151,2)，结果为5.22
  4. 要求保留位数的后一位“>=6”，则进位。如round(5.216,2)，结果为5.22

2.3 argpartition

引用
找到最大值

2.4 column_stack

引用

三、代码

3.1 调用opencv库

调用代码如下：

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取图片
img = cv2.imread('D:/house.png')
# 彩色图片灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 执行边缘检测
edges = cv2.Canny(gray, 80, 200)
# 显示原始结果

cv2.imwrite('edges.png', edges)
cv2.imshow('edge', edges)
# plt.subplot(121)
# plt.imshow(edges)

# 执行Hough直线检测
lines = cv2.HoughLines(edges, 1, np.pi/180, 130)  #cv2.HoughLines 的返回参数 line == [\rho ,\Theta ] ，
                                                  # 其中，第一个参数表示图像原点距离直线的长度，第二个参数表示沿着x轴的角度大小。
lines1 = lines[:, 0, :]
print('lines', lines)
print('lines1', lines1)

for rho,  theta in lines1:
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))  # 延长直线的长度，保证在整幅图像上绘制直线
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)

cv2.imwrite('line.png', img)
cv2.imshow('line', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

通过调整各项参数，边缘检测图和直线检测图如下图所示：
在这里插入图片描述
可以看到检测效果还不错。
通过打印我们发现cv2.HoughLines()函数返回值为弧长和弧度的数组：
在这里插入图片描述

3.2 不调用函数

（一）

在参考了这位博主和这位博主的帖子之后，我将代码改为如下形式（此处先只修改了Hough变换的部分，边缘检测依然采用库函数）：

import cv2
import numpy as np

# 读取图片
img = cv2.imread('D:/house.png')
# 彩色图片灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 执行边缘检测
edges = cv2.Canny(gray, 80, 200)
# 显示原始结果

cv2.imwrite('edges.png', edges)
# cv2.imshow('edge', edges)

# def Hough(img, origin, delta=1):
def Hough(img):
    thetas = np.deg2rad(np.arange(0.0, 181.0, 1))
    row, col = img.shape
    print('row, col =', row, col)
    rhomax = int(round(np.sqrt(row*row+col*col)))
    print('rhomax', rhomax)
    # 因为ρ会存在负值，所以要先右移，后面减去即可
    A = np.zeros((2*rhomax, len(thetas)), np.int32)

    for x in range(row):
        for y in range(col):
            if img[x, y] > 0:  # 寻找边缘点
                for i in range(len(thetas)):  # 找出过边缘点的所有直线
                    rho = int(round(x*np.cos(thetas[i])+y*np.sin(thetas[i])))  # round四舍五入至接近的整数，计算弧长
                    rho += rhomax
                    A[rho, i] += 1  # 统计参数空间中过点的曲线数目
    # 统计大于阈值的点数
    m = 0
    for x in range(len(thetas)):
        for y in range(rhomax):
            if A[y, x] >= 80:  # 设置阈值
                m += 1
    print('m=', m)

    rho_list = np.zeros(m, np.int32)  # 存每个点的弧长
    theta_list = np.zeros(m, np.int32)  # 存每个点的弧度
    print('rho_list =', rho_list)
    print('theta_list =', theta_list)
    for i in range(m):
            rho_list[i] = rho
            theta_list[i] = i
    lines = [list(t) for t in zip(rho_list, theta_list)]  # 返回弧长和弧度的数组

    return lines

lines = Hough(edges)
print('lines=', lines)

# 画线
for rho,  theta in lines:
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))  # 延长直线的长度，保证在整幅图像上绘制直线
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)

cv2.imwrite('line.png', img)
cv2.imshow('line', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

检测结果如下图所示：
在这里插入图片描述
在这里插入图片描述

由于图片灰度化和边缘检测都是调用的库函数，所以边缘检测图是没有问题的，然而直线检测显然是错的。。。。。。且用自己编写的函数明显运行速度变慢。

（二）

经过对上述程序的分析，我推测可能是在寻找过边缘点直线的过程中，将弧长四舍五入产生了较大的误差，于是对程序做了如下修改：

import cv2
import numpy as np

# 读取图片
img = cv2.imread('D:/house.png')
# 彩色图片灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 执行边缘检测
edges = cv2.Canny(gray, 80, 200)
# 显示原始结果

cv2.imwrite('edges.png', edges)
# cv2.imshow('edge', edges)

# def Hough(img, origin, delta=1):
def Hough(img):
    thetas = np.deg2rad(np.arange(0.0, 181.0, 1))
    row, col = img.shape
    print('row, col =', row, col)
    rhomax = int(round(np.sqrt(row*row+col*col)))
    print('rhomax', rhomax)
    # 因为ρ会存在负值，所以要先右移，后面减去即可
    A = np.zeros((2*rhomax, len(thetas)), np.int32)

    for x in range(row):
        for y in range(col):
            if img[x, y] > 0:  # 寻找边缘点
                for i in range(len(thetas)):  # 找出过边缘点的所有直线
                    rho = int(round((x*np.cos(thetas[i])+y*np.sin(thetas[i])), 1))  # round四舍五入至小数点后1位，计算弧长
                    rho += rhomax
                    A[rho, i] += 1  # 统计参数空间中过点的曲线数目
    # 将弧长误差为1的点近似为同一个点
    for x in range(len(thetas)):
        for y in range(rhomax):
            for i in range(rhomax-y):
                if abs(A[y, x]-A[y+i, x]) <= 1:  # 设置阈值，小于等于1判为同一个点
                    A[y + i, x] = A[y, x]
    # 统计大于阈值的点数
    m = 0
    for x in range(len(thetas)):
        for y in range(rhomax):
            if A[y, x] >= 80:  # 设置阈值
                m += 1
    print('m=', m)

    rho_list = np.zeros(m, np.int32)  # 存每个点的弧长
    theta_list = np.zeros(m, np.int32)  # 存每个点的弧度
    print('rho_list =', rho_list)
    print('theta_list =', theta_list)
    for i in range(m):
            rho_list[i] = rho
            theta_list[i] = i
    lines = [list(t) for t in zip(rho_list, theta_list)]  # 返回弧长和弧度的数组

    return lines

lines = Hough(edges)
print('lines=', lines)

# 画线
for rho,  theta in lines:
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))  # 延长直线的长度，保证在整幅图像上绘制直线
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)

cv2.imwrite('line.png', img)
cv2.imshow('line', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

运行速度又慢了许多。。。。。。检测结果如下：
在这里插入图片描述
显然没有任何改进。
此时我发现输出lines如下：
在这里插入图片描述
与直接调用函数返回的值大相径庭，根本就是错的。。。。。。

（三）

分析发现是rho_list和theta_list赋值赋错了，然后将程序改为如下形式：

    i = 0
    for x in range(len(thetas)):
        for y in range(rhomax):
            if A[y, x] >= delta:  # 设置阈值
                    rho_list[i] = y-rhomax
                    theta_list[i] = thetas[x]
                    i += 1
    print('rho_list =', rho_list)
    print('theta_list =', theta_list)
    lines = [list(t) for t in zip(rho_list, theta_list)]  # 返回弧长和弧度的数组

输出值如下图所示：
在这里插入图片描述
检测结果如是：
在这里插入图片描述
还是错的。
由于调用的canny算子阈值没有变，都是80，200，输入边缘图是一样的，我将Hough变换的阈值也变为和调用的函数一样的值130，然后发现大于阈值的只有三条线，原本应该有七条线，且这三条线都是错的。判断边缘点这一步应该不会出错，那么就是说在存入Hough空间数组A这一步就出错了。

（四）

实在写不出来，去翻了一下原函数。请见这位博主和这位博主的帖子以及他们的评论区。非常感谢大家的分享。
我仿照原函数写了一个代码如下：

import cv2
import numpy as np

# 读取图片
img = cv2.imread('D:/house.png')
# 彩色图片灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 执行边缘检测
edges = cv2.Canny(gray, 80, 200)
# 显示原始结果

cv2.imwrite('edges.png', edges)
# cv2.imshow('edge', edges)

# def Hough(img, origin, delta=1):
def Hough(img, delta = 130):
    row, col = img.shape  # 获取图片长宽
    rho = 1.0  #定义以像素为单位的距离精度为1  float型
    theta = 1*np.pi/180  #定义以弧度为单位的角度精度为1  float型

    print('rho=', rho)
    print('theta=', theta)
    # 由角度和距离的分辨率得到角度和距离的数量，即霍夫变换后角度和距离的个数
    numangle = round(np.pi / theta)
    numrho = int(((row + col) * 2 + 1) / rho)

    # thetas = np.deg2rad(np.arange(0.0, 180.0, theta))  # 弧度数组

    # 定义累加器即霍夫空间，它是用一维数组表示二维空间
    A = np.zeros(((numrho + 2), (numangle + 2)), np.int32)  # int型数组

    # 做好tabSin、tabCos数组
    angle = 0.0
    tabSin = np.zeros(numangle, np.float)
    tabCos = np.zeros(numangle, np.float)
    for n in range(numangle):
        tabSin[n] = float(np.sin((angle)/rho))
        tabCos[n] = float(np.cos((angle)/rho))
        angle += theta

    # 逐点Hough变换，将结果存入累加器数组内
    for x in range(row):
        for y in range(col):
            if img[x, y] > 0:  # 寻找边缘点
                for i in range(numangle):
                    r = int(round(x * tabCos[i] + y * tabSin[i]))  # round四舍五入至接近的整数，r表示距离
                    r = int(r+(numrho - 1) / 2)
                    A[r+1, i+1] += 1  # 在累加器内找到它们所对应的位置（即霍夫空间内的位置），其值加1

    # 找到局部极大值，即非极大值抑制, 记录个数
    m = 0
    rho_list = np.zeros(numrho, np.float)  # 存每个点的弧长
    theta_list = np.zeros(numangle, np.float)
    for x in range(numrho):
        for y in range(numangle):
            if A[x+1, y+1] >= delta:  # 设置阈值
                if A[x+1, y+1] > A[x+1, y] and A[x+1, y+1] >= A[x+1, y+2] and A[x+1, y+1] > A[x, y+1] and A[x+1, y+1] >= A[x+2, y+1]:  # 在四邻域内进行非极大值抑制
                    rho_list[m] = (x - (numrho - 1) / 2) * rho
                    theta_list[m] = y * theta
                    m += 1

    print('rho_list =', rho_list)
    print('theta_list =', theta_list)

    rho_list = rho_list[rho_list != 0]
    theta_list = theta_list[theta_list != 0]
    print('rho_list =', rho_list)
    print('theta_list =', theta_list)

    lines = [list(t) for t in zip(rho_list, theta_list)]  # 返回弧长和弧度的数组

    return lines

lines = Hough(edges)
print('lines=', lines)

# 画线
for rho,  theta in lines:
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))  # 延长直线的长度，保证在整幅图像上绘制直线
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)

cv2.imwrite('line.png', img)
cv2.imshow('line', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

检测结果如下图所示：
在这里插入图片描述
这回总算是检测出了八个点，比之前的三个点好一些，但还是不对。
在这里插入图片描述
通过与运行原函数的结果相比对，发现弧长差不多能对上，但是角度对不上，也就是说还是公式的计算出了问题。

（五）

重新分析一遍代码思路：

  1. 构建Hough空间
    （1）首先获取图片宽度和高度。
    （2）定义距离精度和角度精度。在这里我定义的都是1，距离精度是1个像素，角度精度是1°，换成弧度也就是代码中表示的那样.
    （3）定义角度的个数和距离的个数。这里角度的个数没有异议，肯定是180个。至于的个数，个人认为不用纠结为什么是（周长+1）/距离精度，前面提到的博主在帖子和评论区讲的都比较清楚，距离长度最小值肯定是图片对角线距离的最大值，只要构建的数组空间存放距离的那一栏大于对角线长度就可以，周长显然大于对角线长度，所以是可以的，而+1是为了防止“0”效应，这里到了后面Hough变换那一步就会明白。当然如果用弧度最小值来构建空间我认为也是没有任何问题的。
    （4）最后是构建sin和cos数组。
  2. 进行Hough变换
    （1）遍历边缘图，找出所有边缘点。
    （2）画出所有过边缘点的直线，判断原点到每一条直线的距离，将距离和角度存入Hough空间相应位置。问题就出在这里。这里row是指图片的高，col是指图片的宽，我的所有循环中x都是取的row（高）的范围，y取得是col（宽）的范围，也就是说我这里的横轴其实是y，纵轴是x，因此我的距离公式应该是:
r=y*cos+x*sin

而不是：

r=x*cos+y*sin

将这里改了之后就对了。。。。。。
继续记录一下我的心路历程。
在图像中每个像素代表的是一个小方格，然而我们在计算距离的时候应该是把每个小方格看成了一个像素点的。如下图所示：
在这里插入图片描述
举个例子。假设图中阴影部分为边缘点像素格。最开始我把它看成一个格子，那么我理所当然的将原点距离它的长度想成了原点与①的距离，这个格子的坐标为（3，2），但它是横着的第四个格子，竖着的第三个格子，由勾股定理显然r应该是5，即应该是：

r=np.sqrt((x+1)**2+(y+1)**2)

但如果是这样的话，那么假如（0，0）这个点是边缘点的话，它的距离显然不为0。但实际上这个点就是原点，它离原点的距离应该就是0。所以我们应该计算的是原点离②的距离。所以公式中出现的是：

r = y * tabCos[i] + x * tabSin[i]

而不是：

r = (y+1) * tabCos[i] + (x+1) * tabSin[i]

因为计算出的r可能为负值，所以我们要再加距离偏移的一半即1024，使r的值最后都能落在[0，2048]这个区间。
然后我们将这组距离、角度存入Hough数组。还是以刚才的例子为例，在存入的过程中，假设距离为5，角度为37°，那么我们应该在（6，38）这个格子+1，这是为了将hough空间的边缘空出来，方便我们进行下一步的非极大值抑制。

  1. 进行非极大值抑制
    （1）这里我们采用的是四邻域比较法。遍历Hough空间除边缘外的每一个点。这里我们表示Hough空间的数组A的范围是横轴[0 ~ 181]共182个格子，纵轴[0 ~ 2050]共2051个格子，我们需要比较y=[1 ~ 180]，x=[1 ~ 2049]这些个格子，如图阴影部分所示：
    在这里插入图片描述
    每个格子与它上下左右的四个格子相比较。
    （2）找到最大值后我们就存入新的距离、弧度数组，并将其作为返回值进行下一步的画线。
    最后放一下代码：
import cv2
import numpy as np

# 读取图片
img = cv2.imread('D:/house.png')
# 彩色图片灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 执行边缘检测
edges = cv2.Canny(gray, 80, 200)
# 显示原始结果

cv2.imwrite('edges.png', edges)
# cv2.imshow('edge', edges)

# def Hough(img, origin, delta=1):
def Hough(img, delta = 130):
    row, col = img.shape  # 获取图片长宽
    rho = 1.0  #定义以像素为单位的距离精度为1  float型
    theta = 1*np.pi/180  #定义以弧度为单位的角度精度为1  float型

    print('rho=', rho)
    print('theta=', theta)
    # 由角度和距离的分辨率得到角度和距离的数量，即霍夫变换后角度和距离的个数
    numangle = round(np.pi / theta)
    numrho = int(((row + col) * 2 + 1) / rho)

    # thetas = np.deg2rad(np.arange(0.0, 180.0, theta))  # 弧度数组

    # 定义累加器即霍夫空间，它是用一维数组表示二维空间
    A = np.zeros(((numrho + 2), (numangle + 2)), np.int32)  # int型数组

    # 做好tabSin、tabCos数组
    angle = 0.0
    tabSin = np.zeros(numangle, np.float)
    tabCos = np.zeros(numangle, np.float)
    for n in range(numangle):
        tabSin[n] = float(np.sin((angle)/rho))
        tabCos[n] = float(np.cos((angle)/rho))
        angle += theta

    # 逐点Hough变换，将结果存入累加器数组内
    for x in range(row):
        for y in range(col):
            if img[x, y] > 0:  # 寻找边缘点
                for i in range(numangle):
                    r = int(round(y * tabCos[i] + x * tabSin[i]))  # round四舍五入至小数点后1位，r表示距离
                    r += int((numrho - 1) / 2)
                    A[r+1, i+1] += 1  # 在累加器内找到它们所对应的位置（即霍夫空间内的位置），其值加1，实际距离r就是r

    # 找到局部极大值，即非极大值抑制, 记录个数
    m = 0
    rho_list = np.zeros(numrho, np.float)  # 存每个点的弧长
    theta_list = np.zeros(numangle, np.float)
    for x in range(numrho):  # 0~2048
        for y in range(numangle):  # 0~179
            if A[x+1, y+1] >= delta:  # 设置阈值  x+1=[1,2049], y+1=[1,180]
                if A[x+1, y+1] > A[x+1, y] and A[x+1, y+1] >= A[x+1, y+2] and A[x+1, y+1] > A[x, y+1] and A[x+1, y+1] >= A[x+2, y+1]:  # 在四邻域内进行非极大值抑制
                    rho_list[m] = (x - (numrho - 1) / 2) * rho
                    theta_list[m] = y * theta
                    m += 1
    print('m=', m)

    rho_list = rho_list[rho_list != 0]
    theta_list = theta_list[theta_list != 0]
    print('rho_list =', rho_list)
    print('theta_list =', theta_list)


    lines = [list(t) for t in zip(rho_list, theta_list)]  # 返回弧长和弧度的数组

    return lines

lines = Hough(edges)
print('lines=', lines)

# 画线
for rho,  theta in lines:
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a*rho
    y0 = b*rho
    x1 = int(x0 + 1000*(-b))  # 延长直线的长度，保证在整幅图像上绘制直线
    y1 = int(y0 + 1000*(a))
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*(a))
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)

cv2.imwrite('line.png', img)
cv2.imshow('line', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

检测结果如图所示：
在这里插入图片描述
在这里插入图片描述

（六）

将图片灰度化以及canny等所有程序都换成自己编写的之后，程序运行很慢，效果如下图所示：
在这里插入图片描述
通过更改阈值能得到不同的检测效果。

四、错误

在调试代码的过程中，遇到了许多问题，在这里记录一下。

（一）、数据类型与数组类型不匹配

这个问题出现了许多次，错误如下：

IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices

分析发现应该是说数组的索引必须是整数，不能是浮点数、字符串等其他类型。
分步运行时发现r是一个浮点数，如下图所示：
在这里插入图片描述
但我的程序是这样写的：

r = int(round(x * tabCos[i] + y * tabSin[i]))  # round四舍五入至小数点后1位，r表示距离
r += （numrho - 1) / 2

然后我发现第二行的

r += （numrho - 1) / 2

输出为浮点数。但是如果改成如下形式输出就为整数：

r += （numrho - 1) * 2

也就是除法的结果会变成一个浮点数。所以我将第二行也进行了一个int转换：

r = int(round(x * tabCos[i] + y * tabSin[i]))  # round四舍五入至接近的整数，r表示距离
 r = int(r+(numrho - 1) / 2)

这回总算是对了。

（二）opencv中的cvRound与c++中的round

c++中的round为四舍五入，而opencv中的cvRound为五舍六入。请见这位博主的帖子。
此处应该不用在意这些微小的差别。

一个没有本领的人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像处理课程设计——Hough变换提取直线.docx
06-18
数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx数字图像处理课程设计——Hough变换提取直线.docx
一种改进快速Hough变换的车道线检测算法* (2014年)
04-27
目的研究智能交通系统中车道线快速检测算法。方法 首先将车道线图像灰度化，采用中值滤波去除图像噪声；然后用索贝尔算子将灰度图像二值化处理；再次，根据车道线图像的特点并且结合霍夫变换的需求，设置感兴趣区域；最后，在感兴趣区域内用霍夫变换提取车道线，用最小二乘法进行直线拟合，舍弃干扰虚假线，并对多段车道线图像进行检测。结果与结论 相对于经典霍夫变换算法，基于改进快速霍夫变换的车道线检测算法运算时间更短，而且使算法的鲁棒性得到了很大提高。
opencv26:霍夫直线变换
uncle_ll的博客
11-04 792
目标 在这一章当中，将学习 了解霍夫变换的概念 使用它来检测图像中的线条 函数：cv2.HoughLines()，cv2.HoughLinesP() 理论 如果可以用数学形式表示形状，则霍夫变换是检测任何形状的一种比较流行的技术。即使形状有些破损或变形，也可以检测出形状。本文将讲解如何将它何作用于一条线。 一条线可以表示为y=mx+cy = mx+cy=mx+c或以参数形式表示为ρ=xcosθ+ysinθρ = xcosθ+ysinθρ=xcosθ+ysinθ $，其中ρ是从原点到该线的垂直距离，而θ是
【图像处理】（2.1）霍夫直线变换
mjiansun的专栏
02-23 4481
转自：hough变换算法 - 啊哈彭 - 博客园 1、算法思想 边缘检测比如canny算子可以识别出图像的边缘，但是实际中由于噪声和光照不均匀等因素，很多情况下获得的边缘点是不连续的，必须通过边缘连接将他们转换为有意义的边缘。Hough变化是一个重要的检测间断点边界形状的方法，它通过将图像坐标空间变化到参数空间来实现直线和曲线的拟合。 霍夫变换于1962年由Paul Hough 首次提出，后于1972年由Richard Duda和Peter Hart推广使用，经典霍夫变换用来检测图像中的直线，后来霍夫
【OpenCV-Python】教程：3-13 Hough直线变换
12-02 1159
在Hough变换中，尽管一条直线只有两个参数，但是还需要很多计算量，概率 Hough 变换是其中的一种优化，它不会将所有的点都考虑进去，相反，它会考虑一些能够充分进行直线检测的随机点集。Hough 变换是一个非常有用的技术，可以检测任何形状，只要那个形状可以通过数学方程表示出来，即使检测的形状断裂或者轻微变形。因此，以一个像素的精度计算，行数可以是图像的对角线长度。数组的大小取决于精度，假设角度的精度为1度，则需要180列。的图像，在图像中间有一个水平线，取这条线的第一个点。是原点到直线的垂直距离，
图像处理（二）：hough变换（Python实现）
qq_42233962的博客
04-29 8585
图像处理（二）：hough变换Python实现1、hough变换的用途2、简述hough变换的原理（3句话）3、实现步骤4、python实现5、运行结果 1、hough变换的用途 hough变换（也叫作霍夫变换），一开始用于直线检测，后来也用于矩阵、圆或者椭圆等其它形状的检测。 2、简述hough变换的原理（3句话） 以直线检测为例： （1）把点的直角坐标系换成极坐标系，根据两点或以上确定一条直线...
机器视觉：霍夫变换-理论与python实现
m0_50294896的博客
10-31 3573
目录前言霍夫变换—直线原理实现方法python实现 前言 这学期在学习机器视觉，课上讲到了霍夫变换，霍夫变换在图像处理和CV中很常用，借此十一假期仔细了解一下。 霍夫变换用来检测给定形状的曲线，其最开始是用来检测图像中的直线的，但经发展也可检测到圆等曲线。在目标检测中，如果不知图像中目标的位置而知道其轮廓的曲线方程，则可用霍夫变换进行检测。 霍夫变换—直线原理 在平面O-xy中，直线方程的基本形式为：y=ux+v。其中，u和v分别是直线的斜率和截距。对于一条确定的直线y=ux+v，它唯一地对应于平面O-uv
python实现霍夫变换检测矩形ROI
最新发布
保持分享欲
06-29 1791
基于霍夫变换的ROI检测实现
小白学习图像处理8——使用matlab的hough变换函数
我有两颗糖
05-02 8852
文章目录一、hough 函数1、语法2、举个栗子二、houghpeaks函数1、语法2、举个栗子三、houghlines函数1、语法2、举个栗子四、绘制线段 一、hough 函数 1、语法 [H,theta,rho] = hough(BW) [H,theta,rho] = hough(BW,Name,Value,...) 详细说明： [H,theta,rho] = hough(BW) 计算二值...
数字图像处理（实践篇）六 利用hough变换进行直线检测
静谧、淡雅
06-20 8253
数字图像处理（实践篇）六 利用hough变换进行直线检测
数字图像处理课程设计——Hough变换提取直线.pdf
06-18
数字图像处理课程设计——Hough变换提取直线.pdf数字图像处理课程设计——Hough变换提取直线.pdf数字图像处理课程设计——Hough变换提取直线.pdf数字图像处理课程设计——Hough变换提取直线.pdf数字图像处理课程设计...
数字图像处理课程设计——Hough变换提取直线 (2).docx
06-18
数字图像处理课程设计——Hough变换提取直线 (2).docx数字图像处理课程设计——Hough变换提取直线 (2).docx数字图像处理课程设计——Hough变换提取直线 (2).docx数字图像处理课程设计——Hough变换提取直线 (2).docx...
数字图像处理课程设计——Hough变换提取直线 (2).pdf
06-18
数字图像处理课程设计——Hough变换提取直线 (2).pdf数字图像处理课程设计——Hough变换提取直线 (2).pdf数字图像处理课程设计——Hough变换提取直线 (2).pdf数字图像处理课程设计——Hough变换提取直线 (2).pdf数字...
Hough变换.pptx
06-07
关于霍夫变换的介绍，含MATLAB程序Hough(霍夫）变换的基本思想是将图像空间X-Y变换到参数空间P-Q，利用图像空间X-Y与参数空间P-Q的点——线对偶性，通过把原始图像中给定形状的直线或曲线变换成参数空间的一个点，即...
hough变换 python+OpenCV的简单实现
再走一步
04-09 780
直线的hough变换 import cv2 import numpy as np # 1.加载 # 图片，转为二值图 img = cv2.imread('lines.jpg') drawing = np.zeros(img.shape[:], dtype=np.uint8) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) edges = cv2.Can...
Python下opencv hough变换
Arthur_Holmes的博客
03-31 618
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net...
霍夫变换的python原理讲解
xifenglie123321的博客
05-21 657
在霍夫变换中，直线的参数表示为极坐标系下的两个参数：ρ（rho）和θ（theta）。ρ表示直线到原点的距离，θ表示直线与x轴的夹角。对于每个图像中的边缘点，我们可以计算出它们到所有可能直线的ρ和θ值，然后在参数空间中进行累加。最终，参数空间中的峰值对应的ρ和θ值就是图像中的直线参数。它的基本思想是将图像中的每个像素点转换为参数空间中的一个点，然后在参数空间中寻找形状对应的峰值，从而得到形状的参数。函数的参数包括图像、ρ和θ的取值范围以及阈值。最后，我们在原图上绘制检测到的直线。
Python，OpenCV中的霍夫圆变换——cv2.HoughCircles()
qq_40985985的博客
07-26 6250
Python，OpenCV中的霍夫圆变换1. 效果图2. 源码参考 这篇博客将学习如何使用霍夫圆变换在图像中找到圆圈，OpenCV使用cv2.HoughCircles()实现霍夫圆变换。 circles = cv2.HoughCircles(img, cv2.HOUGH_GRADIENT, 1, 20, param1=50, param2=40, minRadius=25, maxRadius=0) img: 待检测的灰度图 cv2.HOUGH_GRADIENT：检测的方法，霍夫梯度 1：检测的圆与原始图
霍夫变换理论知识及其python代码实例
babyai996的博客
05-21 754
霍夫变换是一种用来检测图像中给定形状的曲线的方法，最初是用来检测直线的，后来也扩展到圆等曲线。它的基本原理是将图像空间中的点映射到极坐标空间中的曲线，然后在极坐标空间中寻找曲线的交点，从而得到图像空间中的直线方程。
图像滤波与Hough变换
04-04
图像滤波和Hough变换是数字图像处理中常见的两种技术。 图像滤波是一种图像处理技术，通过对图像像素进行加权平均或卷积运算，去除图像中的噪声和不想要的细节，使图像更加清晰和易于分析。常见的图像滤波方法包括高斯滤波、中值滤波、均值滤波等。 Hough变换是一种图像处理技术，用于检测图像中的直线、圆等特定形状。Hough变换首先将图像中的每个像素点转换为参数空间中的一个点，并在参数空间中寻找具有相同参数的点的集合。这些点的集合对应于图像中的特定形状。通过对参数空间进行分析和处理，可以检测出图像中的特定形状，并对其进行分割和识别。 图像滤波和Hough变换常常结合使用，例如在图像中检测直线时，通常需要先对图像进行滤波以去除干扰和噪声，然后使用Hough变换来检测直线。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值