精华内容
下载资源
问答
  • C++ 图像处理中多种直线检测方法!C++ 图像处理中多种直线检测方法
  • 数字图像处理 Hough 变换直线检测 ,matlab 实现 实验八 Hough 变换直线检测 一实验目的 理解Hough变换的原理了解其应用掌握利用Hough变换进行直线检测的处 理过程 及编程方法 二实验内容 利用Hough变换检测直线通常...
  • 1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是...
  • 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。 python实现 import cv2 import numpy as np...

    霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。

    python实现

    import cv2
    import numpy as np
    # 使用霍夫直线变换做直线检测,前提条件:边缘检测已经完成
    
    __author__ = "boboa"
    
    
    # 标准霍夫线变换
    def line_detection_demo(image):
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 50, 150, apertureSize=3)
        lines = cv2.HoughLines(edges, 1, np.pi/180, 200)  # 函数将通过步长为1的半径和步长为π/180的角来搜索所有可能的直线
        for line in lines:
            rho, theta = line[0]  # line[0]存储的是点到直线的极径和极角,其中极角是弧度表示的
            a = np.cos(theta)   # 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(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
        cv2.imshow("image_lines", image)
    
    
    # 统计概率霍夫线变换
    def line_detect_possible_demo(image):
        gray = cv2.cvtColor(image, cv2.COLOR_BGRA2GRAY)
        edges = cv2.Canny(gray, 50, 150, apertureSize=3)
        # 函数将通过步长为1的半径和步长为π/180的角来搜索所有可能的直线
        lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, minLineLength=50, maxLineGap=10)
        for line in lines:
            x1, y1, x2, y2 = line[0]
            cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
        cv2.imshow("line_detect_possible_demo", image)
    
    
    if __name__ == "__main__":
        img = cv2.imread("image/lines.jpg")
        cv2.namedWindow("input image", cv2.WINDOW_AUTOSIZE)
        cv2.imshow("input image", img)
        line_detect_possible_demo(img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

    标准霍夫线变换运行结果

    统计概率霍夫线变换运行结果

    标准霍夫线变换cv2.HoughLines(image, rho, theta, threshold[, lines[, srn[, stn[, min_theta[, max_theta]]]]]) -> lines

    参数:image-边缘检测的输出图像,8位,单通道二进制源图像

        rho-距离步长

        theta-角度步长

        threshold-阈值,只有大于该值的点才有可能被当作极大值,即至少有多少条正弦曲线交于一点才被认为是直线

    统计概率霍夫线变换cv2.HoughLinesP(image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]) -> lines

    参数:image-边缘检测的输出图像,该图像为单通道8位二进制图像

         rho-参数极径 r 以像素值为单位的分辨率,这里一般使用 1 像素

         theta-参数极角 \theta 以弧度为单位的分辨率,这里使用 1度

         threshold-检测一条直线所需最少的曲线交点

         minLineLength-线的最短长度,比这个线短的都会被忽略

         maxLineGap-两条线之间的最大间隔,如果小于此值,这两条线就会被看成一条线。

    HoughLinesP,效果更好,检测图像中分段的直线(而不是贯穿整个图像的直线)



    转载于:https://www.cnblogs.com/qianxia/p/11101758.html

    展开全文
  • 霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是从...

    简介:

    1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是从黑白图像中检测直线(线段)。

    2.Hough变换的原理是将特定图形上的点变换到一组参数空间上,根据参数空间点的累计结果找到一个极大值对应的解,那么这个解就对应着要寻找的几何形状的参数(比如说直线,那么就会得到直线的斜率k与常熟b,圆就会得到圆心与半径等等)

    3.霍夫线变换是一种用来寻找直线的方法。用霍夫线变换之前, 首先需要对图像进行边缘检测的处理,也即霍夫线变换的直接输入只能是边缘二值图像。

    4.霍夫直线检测的具体原理参见:

    代码如下:

    #直线检测

    #使用霍夫直线变换做直线检测,前提条件:边缘检测已经完成

    import cv2 as cv

    import numpy as np

    #标准霍夫线变换

    def line_detection(image):

    gray = cv.cvtColor(image, cv.COLOR_RGB2GRAY)

    edges = cv.Canny(gray, 50, 150, apertureSize=3) #apertureSize参数默认其实就是3

    cv.imshow("edges", edges)

    lines = cv.HoughLines(edges, 1, np.pi/180, 80)

    for line in lines:

    rho, theta = line[0] #line[0]存储的是点到直线的极径和极角,其中极角是弧度表示的。

    a = np.cos(theta) #theta是弧度

    b = np.sin(theta)

    x0 = a * rho #代表x = r * cos(theta)

    y0 = b * rho #代表y = r * sin(theta)

    x1 = int(x0 + 1000 * (-b)) #计算直线起点横坐标

    y1 = int(y0 + 1000 * a) #计算起始起点纵坐标

    x2 = int(x0 - 1000 * (-b)) #计算直线终点横坐标

    y2 = int(y0 - 1000 * a) #计算直线终点纵坐标 注:这里的数值1000给出了画出的线段长度范围大小,数值越小,画出的线段越短,数值越大,画出的线段越长

    cv.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2) #点的坐标必须是元组,不能是列表。

    cv.imshow("image-lines", image)

    #统计概率霍夫线变换

    def line_detect_possible_demo(image):

    gray = cv.cvtColor(image, cv.COLOR_RGB2GRAY)

    edges = cv.Canny(gray, 50, 150, apertureSize=3) # apertureSize参数默认其实就是3

    lines = cv.HoughLinesP(edges, 1, np.pi / 180, 60, minLineLength=60, maxLineGap=5)

    for line in lines:

    x1, y1, x2, y2 = line[0]

    cv.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)

    cv.imshow("line_detect_possible_demo",image)

    src = cv.imread('E:/imageload/louti.jpg')

    print(src.shape)

    cv.namedWindow('input_image', cv.WINDOW_AUTOSIZE)

    cv.imshow('input_image', src)

    line_detection(src)

    src = cv.imread('E:/imageload/louti.jpg') #调用上一个函数后,会把传入的src数组改变,所以调用下一个函数时,要重新读取图片

    line_detect_possible_demo(src)

    cv.waitKey(0)

    cv.destroyAllWindows()

    运行结果:

    注意:

    1.opencv的HoughLines函数是标准霍夫线变换函数,该函数的功能是通过一组参数对

     的集合来表示检测到的直线,其函数原型为:HoughLines(image, rho, theta, threshold[, lines[, srn[, stn[, min_theta[, max_theta]]]]]) -> lines

    时间: 2020-10-21

    展开全文
  • 1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是...

     

    简介:

    1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是从黑白图像中检测直线(线段)。

    2.Hough变换的原理是将特定图形上的点变换到一组参数空间上,根据参数空间点的累计结果找到一个极大值对应的解,那么这个解就对应着要寻找的几何形状的参数(比如说直线,那么就会得到直线的斜率k与常熟b,圆就会得到圆心与半径等等)

    3.霍夫线变换是一种用来寻找直线的方法。用霍夫线变换之前, 首先需要对图像进行边缘检测的处理,也即霍夫线变换的直接输入只能是边缘二值图像。

    4.霍夫直线检测的具体原理参见:

    https://blog.csdn.net/ycj9090900/article/details/52944708

    http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/imgproc/imgtrans/hough_lines/hough_lines.html

    http://lib.csdn.net/article/opencv/24201

    代码如下:

    复制代码

    #直线检测
    #使用霍夫直线变换做直线检测,前提条件:边缘检测已经完成
    import cv2 as cv
    import numpy as np
    
    #标准霍夫线变换
    def line_detection(image):
        gray = cv.cvtColor(image, cv.COLOR_RGB2GRAY)
        edges = cv.Canny(gray, 50, 150, apertureSize=3)  #apertureSize参数默认其实就是3
        cv.imshow("edges", edges)
        lines = cv.HoughLines(edges, 1, np.pi/180, 80)
        for line in lines:
            rho, theta = line[0]  #line[0]存储的是点到直线的极径和极角,其中极角是弧度表示的。
            a = np.cos(theta)   #theta是弧度
            b = np.sin(theta)
            x0 = a * rho    #代表x = r * cos(theta)
            y0 = b * rho    #代表y = r * sin(theta)
            x1 = int(x0 + 1000 * (-b)) #计算直线起点横坐标
            y1 = int(y0 + 1000 * a)    #计算起始起点纵坐标
            x2 = int(x0 - 1000 * (-b)) #计算直线终点横坐标
            y2 = int(y0 - 1000 * a)    #计算直线终点纵坐标    注:这里的数值1000给出了画出的线段长度范围大小,数值越小,画出的线段越短,数值越大,画出的线段越长
            cv.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)    #点的坐标必须是元组,不能是列表。
        cv.imshow("image-lines", image)
    
    #统计概率霍夫线变换
    def line_detect_possible_demo(image):
        gray = cv.cvtColor(image, cv.COLOR_RGB2GRAY)
        edges = cv.Canny(gray, 50, 150, apertureSize=3)  # apertureSize参数默认其实就是3
        lines = cv.HoughLinesP(edges, 1, np.pi / 180, 60, minLineLength=60, maxLineGap=5)
        for line in lines:
            x1, y1, x2, y2 = line[0]
            cv.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
        cv.imshow("line_detect_possible_demo",image)
    
    src = cv.imread('E:/imageload/louti.jpg')
    print(src.shape)
    cv.namedWindow('input_image', cv.WINDOW_AUTOSIZE) 
    cv.imshow('input_image', src)
    line_detection(src)
    src = cv.imread('E:/imageload/louti.jpg') #调用上一个函数后,会把传入的src数组改变,所以调用下一个函数时,要重新读取图片
    line_detect_possible_demo(src)
    cv.waitKey(0)
    cv.destroyAllWindows()

    复制代码

    运行结果:

    注意:

    1.opencv的HoughLines函数是标准霍夫线变换函数,该函数的功能是通过一组参数对 (\theta, r_{\theta}) 的集合来表示检测到的直线,其函数原型为:HoughLines(image, rho, theta, threshold[, lines[, srn[, stn[, min_theta[, max_theta]]]]]) -> lines

    image参数表示边缘检测的输出图像,该图像为单通道8位二进制图像。

    rho参数表示参数极径 r 以像素值为单位的分辨率,这里一般使用1像素。

    theta参数表示参数极角 \theta 以弧度为单位的分辨率,这里使用1度。

    threshold参数表示检测一条直线所需最少的曲线交点。

    lines参数表示储存着检测到的直线的参数对 (r,\theta) 的容器 。

    srn参数、stn参数默认都为0。如果srn = 0且stn = 0,则使用经典的Hough变换。

    min_theta参数表示对于标准和多尺度Hough变换,检查线条的最小角度。

    max_theta参数表示对于标准和多尺度Hough变换,检查线条的最大角度。

    2.opencv的HoughLinesP函数是统计概率霍夫线变换函数,该函数能输出检测到的直线的端点 (x_{0}, y_{0}, x_{1}, y_{1}),其函数原型为:HoughLinesP(image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]) -> lines

    image参数表示边缘检测的输出图像,该图像为单通道8位二进制图像。

    rho参数表示参数极径 r 以像素值为单位的分辨率,这里一般使用 1 像素。

    theta参数表示参数极角 \theta 以弧度为单位的分辨率,这里使用 1度。

    threshold参数表示检测一条直线所需最少的曲线交点。

    lines参数表示储存着检测到的直线的参数对 (x_{start}, y_{start}, x_{end}, y_{end}) 的容器,也就是线段两个端点的坐标。

    minLineLength参数表示能组成一条直线的最少点的数量,点数量不足的直线将被抛弃。

    maxLineGap参数表示能被认为在一条直线上的亮点的最大距离。

    展开全文
  • 图像处理之霍夫变换(直线检测算法)

    万次阅读 多人点赞 2012-07-07 14:42:21
    图像处理之霍夫变换(直线检测算法) 霍夫变换是图像变换中的经典手段之一,主要用来从图像中分离出具有某种相同特征的几何 形状(如,直线,圆等)。霍夫变换寻找直线与圆的方法相比与其它方法可以更好的减少噪 声...

    图像处理之霍夫变换(直线检测算法)

    霍夫变换是图像变换中的经典手段之一,主要用来从图像中分离出具有某种相同特征的几何

    形状(如,直线,圆等)。霍夫变换寻找直线与圆的方法相比与其它方法可以更好的减少噪

    声干扰。经典的霍夫变换常用来检测直线,圆,椭圆等。

     

    霍夫变换算法思想:

    以直线检测为例,每个像素坐标点经过变换都变成都直线特质有贡献的统一度量,一个简单

    的例子如下:一条直线在图像中是一系列离散点的集合,通过一个直线的离散极坐标公式,

    可以表达出直线的离散点几何等式如下:

    X *cos(theta) + y * sin(theta)  = r 其中角度theta指r与X轴之间的夹角,r为到直线几何垂

    直距离。任何在直线上点,x, y都可以表达,其中 r, theta是常量。该公式图形表示如下:

    然而在实现的图像处理领域,图像的像素坐标P(x, y)是已知的,而r, theta则是我们要寻找

    的变量。如果我们能绘制每个(r, theta)值根据像素点坐标P(x, y)值的话,那么就从图像笛卡

    尔坐标系统转换到极坐标霍夫空间系统,这种从点到曲线的变换称为直线的霍夫变换。变换

    通过量化霍夫参数空间为有限个值间隔等分或者累加格子。当霍夫变换算法开始,每个像素

    坐标点P(x, y)被转换到(r, theta)的曲线点上面,累加到对应的格子数据点,当一个波峰出现

    时候,说明有直线存在。同样的原理,我们可以用来检测圆,只是对于圆的参数方程变为如

    下等式:

    (x –a ) ^2 + (y-b) ^ 2 = r^2其中(a, b)为圆的中心点坐标,r圆的半径。这样霍夫的参数空间就

    变成一个三维参数空间。给定圆半径转为二维霍夫参数空间,变换相对简单,也比较常用。

     

    编程思路解析:

    1.      读取一幅带处理二值图像,最好背景为黑色。

    2.      取得源像素数据

    3.      根据直线的霍夫变换公式完成霍夫变换,预览霍夫空间结果

    4.       寻找最大霍夫值,设置阈值,反变换到图像RGB值空间(程序难点之一)

    5.      越界处理,显示霍夫变换处理以后的图像

     

    关键代码解析:

    直线的变换角度为[0 ~ PI]之间,设置等份为500为PI/500,同时根据参数直线参数方程的取值

    范围为[-r, r]有如下霍夫参数定义:

     // prepare for hough transform
     int centerX = width / 2;
     int centerY = height / 2;
     double hough_interval = PI_VALUE/(double)hough_space;
    	    
     int max = Math.max(width, height);
     int max_length = (int)(Math.sqrt(2.0D) * max);
     hough_1d = new int[2 * hough_space * max_length];

    实现从像素RGB空间到霍夫空间变换的代码为:

    // start hough transform now....
    int[][] image_2d = convert1Dto2D(inPixels);
    for (int row = 0; row < height; row++) {
    	for (int col = 0; col < width; col++) {
        	int p = image_2d[row][col] & 0xff;
        	if(p == 0) continue; // which means background color
        	
        	// since we does not know the theta angle and r value, 
        	// we have to calculate all hough space for each pixel point
        	// then we got the max possible theta and r pair.
        	// r = x * cos(theta) + y * sin(theta)
        	for(int cell=0; cell < hough_space; cell++ ) {
        		max = (int)((col - centerX) * Math.cos(cell * hough_interval) + (row - centerY) * Math.sin(cell * hough_interval));
        		max += max_length; // start from zero, not (-max_length)
        		if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght]
                    continue;
                }
        		hough_2d[cell][max] +=1;
        	}
        }
    }

    寻找最大霍夫值计算霍夫阈值的代码如下:

    // find the max hough value
    int max_hough = 0;
    for(int i=0; i<hough_space; i++) {
    	for(int j=0; j<2*max_length; j++) {
    		hough_1d[(i + j * hough_space)] = hough_2d[i][j];
    		if(hough_2d[i][j] > max_hough) {
    			max_hough = hough_2d[i][j];
    		}
    	}
    }
    System.out.println("MAX HOUGH VALUE = " + max_hough);
    
    // transfer back to image pixels space from hough parameter space
    int hough_threshold = (int)(threshold * max_hough);

    从霍夫空间反变换回像素数据空间代码如下:

    	    // transfer back to image pixels space from hough parameter space
    	    int hough_threshold = (int)(threshold * max_hough);
    	    for(int row = 0; row < hough_space; row++) {
    	    	for(int col = 0; col < 2*max_length; col++) {
    	    		if(hough_2d[row][col] < hough_threshold) // discard it
    	    			continue;
    	    		int hough_value = hough_2d[row][col];
    	    		boolean isLine = true;
    	    		for(int i=-1; i<2; i++) {
    	    			for(int j=-1; j<2; j++) {
    	    				if(i != 0 || j != 0) {
        		              int yf = row + i;
        		              int xf = col + j;
        		              if(xf < 0) continue;
        		              if(xf < 2*max_length) {
        		            	  if (yf < 0) {
        		            		  yf += hough_space;
        		            	  }
        		                  if (yf >= hough_space) {
        		                	  yf -= hough_space;
        		                  }
        		                  if(hough_2d[yf][xf] <= hough_value) {
        		                	  continue;
        		                  }
        		                  isLine = false;
        		                  break;
        		              }
    	    				}
    	    			}
    	    		}
    	    		if(!isLine) continue;
    	    		
    	    		// transform back to pixel data now...
    	            double dy = Math.sin(row * hough_interval);
    	            double dx = Math.cos(row * hough_interval);
    	            if ((row <= hough_space / 4) || (row >= 3 * hough_space / 4)) {
    	                for (int subrow = 0; subrow < height; ++subrow) {
    	                  int subcol = (int)((col - max_length - ((subrow - centerY) * dy)) / dx) + centerX;
    	                  if ((subcol < width) && (subcol >= 0)) {
    	                	  image_2d[subrow][subcol] = -16776961;
    	                  }
    	                }
    	              } else {
    	                for (int subcol = 0; subcol < width; ++subcol) {
    	                  int subrow = (int)((col - max_length - ((subcol - centerX) * dx)) / dy) + centerY;
    	                  if ((subrow < height) && (subrow >= 0)) {
    	                	  image_2d[subrow][subcol] = -16776961;
    	                  }
    	                }
    	              }
    	    	}
    	    }
    霍夫变换源图如下:

    霍夫变换以后,在霍夫空间显示如下:(白色表示已经找到直线信号)


    最终反变换回到像素空间效果如下:


    一个更好的运行监测直线的结果(输入为二值图像):


    完整的霍夫变换源代码如下:

    package com.gloomyfish.image.transform;
    
    import java.awt.image.BufferedImage;
    
    import com.process.blur.study.AbstractBufferedImageOp;
    
    public class HoughLineFilter extends AbstractBufferedImageOp {
    	public final static double PI_VALUE = Math.PI;
    	private int hough_space = 500;
    	private int[] hough_1d;
    	private int[][] hough_2d;
    	private int width;
    	private int height;
    	
    	private float threshold;
    	private float scale;
    	private float offset;
    	
    	public HoughLineFilter() {
    		// default hough transform parameters
    		//	scale = 1.0f;
    		//	offset = 0.0f;
    		threshold = 0.5f;
    		scale = 1.0f;
    		offset = 0.0f;
    	}
    	
    	public void setHoughSpace(int space) {
    		this.hough_space = space;
    	}
    	
    	public float getThreshold() {
    		return threshold;
    	}
    
    	public void setThreshold(float threshold) {
    		this.threshold = threshold;
    	}
    
    	public float getScale() {
    		return scale;
    	}
    
    	public void setScale(float scale) {
    		this.scale = scale;
    	}
    
    	public float getOffset() {
    		return offset;
    	}
    
    	public void setOffset(float offset) {
    		this.offset = offset;
    	}
    
    	@Override
    	public BufferedImage filter(BufferedImage src, BufferedImage dest) {
    		width = src.getWidth();
            height = src.getHeight();
    
            if ( dest == null )
                dest = createCompatibleDestImage( src, null );
    
            int[] inPixels = new int[width*height];
            int[] outPixels = new int[width*height];
            getRGB( src, 0, 0, width, height, inPixels );
            houghTransform(inPixels, outPixels);
            setRGB( dest, 0, 0, width, height, outPixels );
            return dest;
    	}
    
    	private void houghTransform(int[] inPixels, int[] outPixels) {
            // prepare for hough transform
    	    int centerX = width / 2;
    	    int centerY = height / 2;
    	    double hough_interval = PI_VALUE/(double)hough_space;
    	    
    	    int max = Math.max(width, height);
    	    int max_length = (int)(Math.sqrt(2.0D) * max);
    	    hough_1d = new int[2 * hough_space * max_length];
    	    
    	    // define temp hough 2D array and initialize the hough 2D
    	    hough_2d = new int[hough_space][2*max_length];
    	    for(int i=0; i<hough_space; i++) {
    	    	for(int j=0; j<2*max_length; j++) {
    	    		hough_2d[i][j] = 0;
    	    	}
    	    }
    	    
    	    // start hough transform now....
    	    int[][] image_2d = convert1Dto2D(inPixels);
    	    for (int row = 0; row < height; row++) {
    	    	for (int col = 0; col < width; col++) {
    	        	int p = image_2d[row][col] & 0xff;
    	        	if(p == 0) continue; // which means background color
    	        	
    	        	// since we does not know the theta angle and r value, 
    	        	// we have to calculate all hough space for each pixel point
    	        	// then we got the max possible theta and r pair.
    	        	// r = x * cos(theta) + y * sin(theta)
    	        	for(int cell=0; cell < hough_space; cell++ ) {
    	        		max = (int)((col - centerX) * Math.cos(cell * hough_interval) + (row - centerY) * Math.sin(cell * hough_interval));
    	        		max += max_length; // start from zero, not (-max_length)
    	        		if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght]
    	                    continue;
    	                }
    	        		hough_2d[cell][max] +=1;
    	        	}
    	        }
    	    }
    	    
    		// find the max hough value
    		int max_hough = 0;
    		for(int i=0; i<hough_space; i++) {
    			for(int j=0; j<2*max_length; j++) {
    				hough_1d[(i + j * hough_space)] = hough_2d[i][j];
    				if(hough_2d[i][j] > max_hough) {
    					max_hough = hough_2d[i][j];
    				}
    			}
    		}
    		System.out.println("MAX HOUGH VALUE = " + max_hough);
    		
    		// transfer back to image pixels space from hough parameter space
    		int hough_threshold = (int)(threshold * max_hough);
    	    for(int row = 0; row < hough_space; row++) {
    	    	for(int col = 0; col < 2*max_length; col++) {
    	    		if(hough_2d[row][col] < hough_threshold) // discard it
    	    			continue;
    	    		int hough_value = hough_2d[row][col];
    	    		boolean isLine = true;
    	    		for(int i=-1; i<2; i++) {
    	    			for(int j=-1; j<2; j++) {
    	    				if(i != 0 || j != 0) {
        		              int yf = row + i;
        		              int xf = col + j;
        		              if(xf < 0) continue;
        		              if(xf < 2*max_length) {
        		            	  if (yf < 0) {
        		            		  yf += hough_space;
        		            	  }
        		                  if (yf >= hough_space) {
        		                	  yf -= hough_space;
        		                  }
        		                  if(hough_2d[yf][xf] <= hough_value) {
        		                	  continue;
        		                  }
        		                  isLine = false;
        		                  break;
        		              }
    	    				}
    	    			}
    	    		}
    	    		if(!isLine) continue;
    	    		
    	    		// transform back to pixel data now...
    	            double dy = Math.sin(row * hough_interval);
    	            double dx = Math.cos(row * hough_interval);
    	            if ((row <= hough_space / 4) || (row >= 3 * hough_space / 4)) {
    	                for (int subrow = 0; subrow < height; ++subrow) {
    	                  int subcol = (int)((col - max_length - ((subrow - centerY) * dy)) / dx) + centerX;
    	                  if ((subcol < width) && (subcol >= 0)) {
    	                	  image_2d[subrow][subcol] = -16776961;
    	                  }
    	                }
    	              } else {
    	                for (int subcol = 0; subcol < width; ++subcol) {
    	                  int subrow = (int)((col - max_length - ((subcol - centerX) * dx)) / dy) + centerY;
    	                  if ((subrow < height) && (subrow >= 0)) {
    	                	  image_2d[subrow][subcol] = -16776961;
    	                  }
    	                }
    	              }
    	    	}
    	    }
    	    
    	    // convert to hough 1D and return result
    	    for (int i = 0; i < this.hough_1d.length; i++)
    	    {
    	      int value = clamp((int)(scale * this.hough_1d[i] + offset)); // scale always equals 1
    	      this.hough_1d[i] = (0xFF000000 | value + (value << 16) + (value << 8));
    	    }
    	    
    	    // convert to image 1D and return
    	    for (int row = 0; row < height; row++) {
    	    	for (int col = 0; col < width; col++) {
    	        	outPixels[(col + row * width)] = image_2d[row][col];
    	        }
    	    }
    	}
    	
    	public BufferedImage getHoughImage() {
    		BufferedImage houghImage = new BufferedImage(hough_2d[0].length, hough_space, BufferedImage.TYPE_4BYTE_ABGR);
    		setRGB(houghImage, 0, 0, hough_2d[0].length, hough_space, hough_1d);
    		return houghImage;
    	}
    	
    	public static int clamp(int value) {
    	      if (value < 0)
    	    	  value = 0;
    	      else if (value > 255) {
    	    	  value = 255;
    	      }
    	      return value;
    	}
    	
    	private int[][] convert1Dto2D(int[] pixels) {
    		int[][] image_2d = new int[height][width];
    		int index = 0;
    		for(int row = 0; row < height; row++) {
    			for(int col = 0; col < width; col++) {
    				index = row * width + col;
    				image_2d[row][col] = pixels[index];
    			}
    		}
    		return image_2d;
    	}
    
    }
    
    转载文章请务必注明出自本博客!!

    学习图像处理,点击视频教程《数字图像处理-基础入门》




    展开全文
  • 霍夫变换是图像处理必然接触到的一个算法,它通过一种投票算法检测具有特定形状的物体,该过程在一个参数空间中通过计算累计结果的局部最大值得到一个符合该特定形状的集合作为霍夫变换结果,该方法可以进行圆,直线...
  • 工业图像处理实战-直线检测

    千次阅读 2018-12-25 13:42:02
    请听题,请检测如下线段长度,已知dx=0.0215; 第一种方法,CvBoundingRect /* *函数名:cvBoundingRect *输入参数:points:可以是数组,也可以是cvSeq *返回值:CvRect :轮廓的最小包围矩形 */ CvRect ...
  • P.V.C.Hough[1]第一次提出用霍夫变换(Hough Transform) 检测二值图中的直线和曲线, R.D.Duda和P.E.Hart[2]根据霍夫变换提出了一种更有效的直线检测方法, 这就是通常所称的标准霍夫直线检测。 下面详细介绍它的...
  • 霍夫变换(Hough Transform)是图像处理中的一种特征提取技术,它将图像空间中的特征点映射到参数空间进行投票,通过检测累计结果的局部极值点得到一个符合某特定形状的点的集合。经典霍夫变换用来检测图像中的直线,...
  • import cv2 import numpy as np from matplotlib import pyplot as plt __author__ = "zxsuperstar" ...1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一, ...
  • 本专栏主要介绍如果通过OpenCv-Python进行图像处理,通过原理理解OpenCv-Python的函数处理原型,在具体情况中,针对不同的图像进行不同等级的、不同方法的处理,以达到对图像进行去噪、锐化等一系列的操作。...
  • 1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是...
  • 霍夫变换(Hough Transfrom)是图像处理中的一种特征提取技术,它通过一种投票算法检测具有特定形状的物体,该过程在一个参数空间中通过计算累计结果的局部最大值得到一个符合该特定形状的集合作为霍夫变换的结果。...
  •  Hough变换是数字图像处理中一种常用的几何形状识别方法,它可以识别直线,圆,椭圆,弧线等 等几何形状,其基本原理是利用图像二维空间和Hough参数空间的点-线对偶性,把图像空间中的形 状检测问题转换到
  • 1.霍夫变换(Hough Transform) 霍夫变换是图像处理中从图像中识别几何形状的基本方法之一,应用很广泛,也有很多改进算法。主要用来从图像中分离出具有某种相同特征的几何形状(如,直线,圆等)。最基本的霍夫变换是...
  • 霍夫变换是一种特征检测(feature extraction),被广泛应用在图像分析(image analysis)、计算机视觉(computer vision)以及数位影像处理(digital image processing)。霍夫变换是用来辨别找出物件中的特征,例如:...
  • 图像处理中,霍夫变换用来检测任意能够用数学公式表达的形状,即使这个形状被破坏或者有点扭曲。下面我们将看到利用HoughLine算法来阐述霍夫变化进行直线检测的原理,把此算法应用到特点图像的边缘检测是可取的。...
  • 这节课能容不多,基本上是遵循规律编写代码即可     import cv2 as cv ...方法一""" gray=cv.cvtColor(img,cv.COLOR_RGB2GRAY) edges=cv.Canny(gray,50,150,apertureSize=3)...
  • 直线检测方法3. 区域生长算法 简介 这篇博客想写的东西非常杂,到现在我还不知道应该怎么组织或者说怎么把想写的东西贯穿起来。 最开始,我是想看一些矩形检测的算法,比较传统的肯定是基于HOUGH变换,基于角点,...
  • 图像直线检测——Hough变换原理

    万次阅读 2016-10-31 16:31:38
    Hough变换是图像处理中从图像中识别几何形状的基本方法之一。Hough变换的基本原理在于利用点与线的对偶性,将原始图像空间的给定的曲线通过曲线表达形式变为参数空间的一个点。这样就把原始图像中给定曲线的检测问题...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 315
精华内容 126
关键字:

图像处理直线检测方法