霍夫变换

霍夫变换(hough transform)霍夫变换(Hough Transform)霍夫变换是一种图像处理技术，用于在图像中检测直线、圆形等几何形状。

它最早由Paul Hough在1962年提出。

霍夫变换在计算机视觉和模式识别领域得到广泛应用，特别在边缘检测和形状分析中表现出色。

一、霍夫变换原理1. 直线检测霍夫变换的直线检测基于极坐标下的直线方程：ρ = xcosθ + ysinθ。

其中，ρ表示直线与原点的距离，θ为直线与x轴的夹角。

霍夫变换通过在ρ-θ空间中进行投票，找到出现频率最高的ρ和θ组合，即可以确定一条直线。

2. 圆形检测霍夫变换的圆形检测考虑到圆心坐标和半径。

以圆心坐标(xc, yc)和半径r为变量，对每个像素点进行投票。

根据累加器中出现频率最高的圆心和半径组合，即可确定一个圆。

二、霍夫变换的步骤1. 边缘检测霍夫变换需要基于边缘图像进行处理，因此首先需要对原始图像进行边缘检测。

常用的边缘检测算法有Canny边缘检测和Sobel算子等。

2. 构建累加器对于直线检测，构建一个二维累加器数组，用于记录直线参数的出现频率。

对于圆形检测，构建一个三维累加器数组，用于记录圆心和半径的出现频率。

3. 参数空间搜索遍历边缘图像上的每个像素点，对于每个边缘像素，计算对应的ρ和θ(直线检测)或圆心坐标和半径(圆形检测)。

在累加器中相应位置加1。

4. 参数估计根据累加器中出现频率最高的位置，估计出最佳直线或圆形的参数。

可以设定一个阈值，只接受出现频率高于该阈值的参数。

5. 绘制检测结果根据参数估计的结果，在原始图像上绘制检测出的直线或圆形。

三、霍夫变换的应用1. 直线检测霍夫变换的直线检测广泛应用于计算机视觉领域。

例如，道路标线检测、物体边缘检测、图像中的几何形状检测等。

通过直线检测，可以提取出图像中的重要几何特征，为后续的图像处理和分析提供基础。

2. 圆形检测霍夫变换的圆形检测可以应用于许多领域，例如医学图像处理、目标跟踪、光学字符识别等。

一、概述霍夫变换是一种常用的图像处理技术，它可以用于检测图像中的直线、圆或者其他形状。

它具有很好的鲁棒性，可以应对图像中存在的噪声和其他干扰。

霍夫变换在计算机视觉、图像处理和模式识别领域有着广泛的应用，成为了处理图像中几何形状的重要工具。

二、霍夫变换的原理霍夫变换最初是由美国科学家保罗·霍夫在1962年提出的，用于检测图像中的直线。

后来，霍夫变换被扩展到检测圆或者其他形状。

霍夫变换的基本原理是将空间域中的坐标转换到参数域中，在参数域中对应的曲线经过的点在空间域中具有共线的特点。

通过累加空间域中的点的参数，可以找到曲线或者形状的参数方程，从而实现对图像中形状的检测。

具体来说，对于检测直线来说，可以通过霍夫变换将直线表示为参数空间中的斜率和截距，从而可以在参数空间中进行累加，最终找到直线的参数方程。

三、霍夫变换在直线检测中的应用1. 边缘检测在使用霍夫变换检测直线之前，通常需要对图像进行边缘检测。

边缘检测可以帮助找到图像中明显的过渡区域，这些过渡区域通常对应着直线的轮廓。

常用的边缘检测算法包括Sobel算子、Canny算子等。

2. 参数空间的设置为了使用霍夫变换来检测直线，需要设定参数空间的范围。

对于直线检测来说，一般可以设定直线的斜率和截距的取值范围。

3. 累加过程在设定好参数空间后，需要对图像中的边缘点进行霍夫变换的累加过程。

对于每一个边缘点，都可以在参数空间中找到对应的直线，通过对参数空间的累加，可以找到参数空间中的峰值，这些峰值对应着图像中的直线。

4. 直线检测可以根据参数空间中的峰值来确定图像中的直线。

通常可以设定一个阈值来筛选参数空间中的峰值，从而得到最终的直线检测结果。

四、霍夫变换在圆检测中的应用除了直线检测，霍夫变换也可以用于检测图像中的圆。

与直线检测类似，圆检测也需要进行边缘检测和参数空间的设定。

不同的是，在圆检测中，需要设定圆心和半径的参数空间范围。

五、霍夫变换的改进和应用1. 累加数组的优化在传统的霍夫变换中，需要对参数空间进行离散化，这会导致计算量较大。

霍夫变换直线检测原理
霍夫变换（Hough Transform）是一种用来检测图像中的直线的算法，它在图像处理领域非常重要，它可以用来检测图像中的线条，圆和椭圆。

霍夫变换的基本原理是，将输入图像中的每个像素点看作是坐标系中的一个点，然后通过一些函数来确定是否存在直线，圆或椭圆，并将这些函数称为霍夫变换函数。

霍夫变换的直线检测是一个非常重要的过程，它的基本原理是将输入图像中的每个像素点看作是坐标系中的一个点，然后用霍夫变换函数来检测输入图像中是否存在直线。

霍夫变换函数有两种，一种是极坐标函数，另一种是直角坐标函数。

在极坐标函数中，霍夫变换函数的形式是：r=xcosθ+ysinθ，在直角坐标函数中，霍夫变换函数的形式是：y=mx+b。

霍夫变换直线检测的过程大致分为以下几步：首先，将输入图像转换为灰度图像，然后使用适当的滤波算法去除噪声；其次，使用边缘检测算法检测图像的边缘，并获得边缘的像素点坐标；然后，使用霍夫变换函数对边缘的像素点进行拟合，获得直线的参数；最后，使用拟合后的参数对直线进行绘制，完成图像中直线检测的任务。

总而言之，霍夫变换是一种用来检测图像中的直线的算法，它是一种极其重要的算法，它可以有效地检测图像中的线条，圆和椭圆，而其直线检测的原理是，将输入图像中的每个像素点看作是坐标系
中的一个点，然后使用霍夫变换函数拟合像素点，获得直线的参数，最后使用参数对直线进行绘制。

霍夫变换原理霍夫变换是一种用于检测图像中特定形状的技术，它在计算机视觉和图像处理领域有着广泛的应用。

霍夫变换最初是由保罗·霍夫在1962年提出的，用于检测物体在图像中的位置和形状。

霍夫变换的原理是基于数学算法，通过将图像中的像素点映射到参数空间中，并在参数空间中进行累加来实现对特定形状的检测。

本文将介绍霍夫变换的原理及其在图像处理中的应用。

首先，我们来了解一下霍夫变换的基本原理。

在霍夫变换中，我们通常以直角坐标系中的一条直线为例进行说明。

对于直线上的每个点(x, y)，我们可以通过以下公式将其映射到霍夫空间中的一条曲线，ρ = xcos(θ) + ysin(θ)。

其中，ρ表示直线到原点的距离，θ表示直线与x轴的夹角。

在霍夫空间中，每条直线都对应一条曲线，而交于同一点(ρ, θ)的曲线则表示一组共线的点，也就是在图像中共线的直线在霍夫空间中交于一点。

通过对霍夫空间中的曲线进行累加，我们可以找到交于同一点最多的曲线，从而确定图像中的直线。

除了检测直线外，霍夫变换也可以用于检测圆和其他形状。

对于圆，我们可以使用三个参数(ρ, α, β)来表示，其中ρ表示圆心到原点的距离，(α, β)表示圆心的坐标。

同样地，我们可以将图像中的圆映射到霍夫空间中的曲线，并通过累加找到交于同一点最多的曲线，从而确定图像中的圆。

在实际应用中，霍夫变换可以用于图像中的边缘检测、形状匹配、目标检测等领域。

例如，在边缘检测中，我们可以先通过Canny边缘检测算法找到图像中的边缘，然后利用霍夫变换来检测直线或圆。

在形状匹配中，我们可以将待匹配的形状映射到霍夫空间中，并通过对霍夫空间中的曲线进行匹配来实现形状的检测和识别。

在目标检测中，我们可以利用霍夫变换来检测图像中的特定形状，如车牌、圆形物体等。

总之，霍夫变换是一种强大的图像处理技术，它通过将图像中的特定形状映射到参数空间中，并在参数空间中进行累加来实现对特定形状的检测。

霍夫变换直线检测 c语言霍夫变换是一种常用的图像处理方法，可以用于直线检测。

在计算机视觉和模式识别领域，霍夫变换被广泛应用于直线检测、圆检测和形状检测等任务中。

霍夫变换最早由霍夫于1962年提出，用于检测图像中的直线。

它的基本思想是将直线表示为参数空间中的一个点，然后通过统计参数空间中的投票数来确定图像中的直线。

在霍夫变换中，我们需要定义两个参数：极坐标中的角度和距离。

对于图像中的每个像素点，我们可以遍历所有可能的角度和距离值，并在参数空间中进行投票。

当某个参数组合得到足够多的票数时，我们认为这个参数组合对应的直线在图像中存在。

通过这种方式，我们可以找到图像中的所有直线。

在具体实现中，我们通常使用二维数组来表示参数空间。

数组的行数表示角度的离散值，列数表示距离的离散值。

对于每个像素点，我们遍历所有可能的参数组合，并在相应的数组位置上进行投票。

最后，我们在参数空间中找到投票数最多的位置，即为图像中的直线。

霍夫变换的优点是能够检测出任意角度和长度的直线，对噪声和局部变形具有一定的鲁棒性。

然而，它也存在一些缺点。

首先，计算复杂度较高，特别是对于大尺寸的图像。

其次，参数空间的离散化可能导致检测到的直线不够精确。

因此，在实际应用中，我们需要根据具体情况选择合适的参数值，以达到较好的检测效果。

除了直线检测，霍夫变换还可以用于圆检测和形状检测。

对于圆检测，我们需要定义三个参数：圆心的横坐标、纵坐标和半径。

对于形状检测，我们可以根据需要定义更多的参数。

总结来说，霍夫变换是一种常用的图像处理方法，可以用于直线检测、圆检测和形状检测等任务。

它的基本思想是通过统计参数空间中的投票数来确定图像中的目标。

尽管霍夫变换存在一些缺点，但在实际应用中，我们可以通过选择合适的参数值和优化算法来克服这些问题。

希望通过本文的介绍，读者能够对霍夫变换有一个初步的了解，进一步探索其在图像处理中的应用。

霍夫变换（Hough Transform）是一种在图像处理中用于检测形状的技术。

它被广泛应用于边缘检测、线条检测和圆检测等领域。

在正弦曲线检测中，霍夫变换可以用来检测图像中的正弦曲线。

基本原理：
霍夫变换的基本原理是将原始图像空间中的形状转换为参数空间中的累加器，通过找到累加器峰值的位置来确定形状的参数。

对于正弦曲线检测，我们可以将正弦曲线的振幅、周期和相位作为参数，使用霍夫变换来检测图像中的正弦曲线。

实现步骤：
1.边缘检测：首先需要对图像进行边缘检测，提取出图像中的边缘像素点。

常用的边缘检测算法包括Sobel、Canny等。

2.参数空间转换：将边缘像素点的坐标转换为参数空间中的形式。

对于正弦曲线，可以将振幅、周期和相位作为参数，将边缘像素点的坐标转换为这些参数的形式。

3.累加器计算：在参数空间中，对于每个可能的参数组合，计算累加器的值。

累加器的值可以通过投票的方式计算，即将相同参数组合的边缘像素点计数加一。

4.峰值检测：在累加器中寻找峰值，峰值的位置对应于正弦曲线
的参数。

通过峰值的位置可以确定正弦曲线的参数，从而检测出正弦曲线。

应用场景：
霍夫变换在图像处理中有着广泛的应用，例如在医学图像处理中用于检测心电图信号、在机器视觉中用于检测物体轮廓和线条等。

在正弦曲线检测中，霍夫变换可以用于检测图像中的振动信号、波形等，具有重要的实际意义和应用价值。

霍夫变换曲线1. 介绍霍夫变换是一种用于检测图像中特定形状的算法，其中之一就是霍夫变换曲线。

霍夫变换曲线（Hough Transform Curve）是由霍夫变换（Hough Transform）演化而来的一种方法，用于检测图像中的曲线。

在图像处理领域，霍夫变换是一种常用的技术，它可以用来检测直线、圆和其他形状。

它的原理是将图像空间中的点映射到参数空间中，并在参数空间中进行计数。

通过寻找参数空间中的峰值，我们可以确定图像中存在的特定形状。

2. 霍夫变换曲线原理霍夫变换曲线是通过对图像进行边缘检测并应用霍夫变换得到的。

下面是霍夫变换曲线的原理步骤：1.对输入图像进行边缘检测，例如使用Canny边缘检测算法。

2.初始化一个参数空间，该空间用于存储曲线的参数。

3.对每个边缘点，在参数空间中进行计数。

4.寻找参数空间中的峰值，这些峰值对应于曲线在图像中的位置。

5.根据参数空间中的峰值，生成霍夫变换曲线。

3. 实现步骤以下是使用Python和OpenCV库实现霍夫变换曲线的基本步骤：import cv2import numpy as np# 1. 读取图像并进行边缘检测image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)edges = cv2.Canny(image, 50, 150)# 2. 初始化参数空间theta_resolution = 0.01rho_resolution = 1theta_range = np.arange(-np.pi / 2, np.pi / 2, theta_resolution)rho_range = np.arange(-np.sqrt(image.shape[0]**2 + image.shape[1]**2),np.sqrt(image.shape[0]**2 + image.shape[1]**2),rho_resolution)accumulator = np.zeros((len(rho_range), len(theta_range)))# 3. 对每个边缘点，在参数空间中进行计数for y in range(edges.shape[0]):for x in range(edges.shape[1]):if edges[y, x] != 0:for t_idx in range(len(theta_range)):theta = theta_range[t_idx]rho = x * np.cos(theta) + y * np.sin(theta)r_idx = int(np.argmin(np.abs(rho - rho_range)))accumulator[r_idx, t_idx] += 1# 4. 寻找参数空间中的峰值peaks = []threshold = 100for r_idx in range(accumulator.shape[0]):for t_idx in range(accumulator.shape[1]):if accumulator[r_idx, t_idx] > threshold:peaks.append((r_idx, t_idx))# 5. 根据参数空间中的峰值，生成霍夫变换曲线for peak in peaks:r_idx, t_idx = peakrho = rho_range[r_idx]theta = theta_range[t_idx]a = np.cos(theta)b = np.sin(theta)x0 = a * rhoy0 = b * rhox1 = 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), (255, 255, 255), 2)# 显示结果图像cv2.imshow('Hough Transform Curve', image)cv2.waitKey(0)cv2.destroyAllWindows()4. 结果与讨论使用上述代码对输入图像进行霍夫变换曲线检测后，我们可以得到一个显示了检测到的曲线的结果图像。

霍夫直线变换原理《霍夫直线变换原理》霍夫直线变换是图像分析与处理中常用的方法，它是一种用于检测图像中直线的方法，可以快速、准确的检测出图像中所有的直线。

本文将对霍夫直线变换的原理作一个简要的介绍。

霍夫直线变换也被称为霍夫变换，它是一种基于空间变换的算法，它将一张二维图像转换为一维坐标空间，从而解决图像处理问题。

霍夫直线变换是基于空间变换的，因此要实现它，首先要构建一个空间变换矩阵。

这个空间变换矩阵由以下两个步骤构成：（1）灰度变换灰度变换是一种基于图像数字值进行变换的方法，它利用一个给定的映射关系，把原始图像数字值 data_in 映射到边缘强度data_out，这样就能够把原始图像点数据转换成边缘强度图像矩阵。

（2）边缘强度计算边缘强度计算是指以某种指定函数实际计算出边缘强度图像矩阵点数据 data_out，这个函数可以是 Sobel 算子、Prewitt 算子等，也可以是用户自定义函数。

经过上述两步，我们就得到了空间变换矩阵，也就是使用霍夫直线变换进行直线检测所需的数据。

霍夫直线变换本质上是一种极坐标变换，它将二维坐标系(x,y)转换为极坐标系(r,q)，其中 r 代表直线离原点的距离，q 代表直线与 x 轴的夹角。

在极坐标系中，任意直线都可以用一个参数表示，即极轴的斜率 q，r 就是由 q 决定的，也就是说，任意直线都可以用一对(q,r)来表示，如果一条直线上有 n 个点，就可以用(q,r)表示为 n 对参数。

霍夫直线变换的核心部分是利用极坐标系中的参数来计算图像中的直线，霍夫变换算法使用极坐标系将数据分成不同的参数组，然后从中找出同一条直线的点，从而计算出该条直线的参数。

通过以上变换，就能够检测出该直线的参数，也就是可以确定该直线的斜率。

总结：霍夫直线变换是一种图像处理中非常常见的方法，它使用空间变换将图像转换成极坐标系，分析不同参数组，计算图像中直线的参数，从而实现对图像中所有直线的快速、准确检测。

图像处理之霍夫变换（直线检测算法）_java图像处理之霍夫变换（直线检测算法）霍夫变换是图像变换中的经典手段之一，主要用来从图像中分离出具有某种相同特征的几何形状（如，直线，圆等）。

霍夫变换寻找直线与圆的方法相比与其它方法可以更好的减少噪声干扰。

经典的霍夫变换常用来检测直线，圆，椭圆等。

霍夫变换算法思想：以直线检测为例，每个像素坐标点经过变换都变成都直线特质有贡献的统一度量，一个简单的例子如下：一条直线在图像中是一系列离散点的集合，通过一个直线的离散极坐标公式，可以表达出直线的离散点几何等式如下：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]有如下霍夫参数定义：[java]view plaincopy1.// prepare for hough transform2.int centerX = width / 2;3.int centerY = height / 2;4.double hough_interval = PI_VALUE/(double)hough_space;5.6.int max = Math.max(width, height);7.int max_length = (int)(Math.sqrt(2.0D) * max);8.hough_1d = new int[2 * hough_space * max_length];实现从像素RGB空间到霍夫空间变换的代码为：[java]view plaincopy1.// start hough transform now....2.int[][] image_2d = convert1Dto2D(inPixels);3.for (int row = 0; row < height; row++) {4.for (int col = 0; col < width; col++) {5.int p = image_2d[row][col] & 0xff;6.if(p == 0) continue; // which means background color7.8.// since we does not know the theta angle and r value,9.// we have to calculate all hough space for each pixel poi nt10.// then we got the max possible theta and r pair.11.// r = x * cos(theta) + y * sin(theta)12.for(int cell=0; cell < hough_space; cell++ ) {13.max = (int)((col - centerX) * Math.cos(cell * hough_int erval) + (row - centerY) * Math.sin(cell * hough_interval));14.max += max_length; // start from zero, not (-max_length)15.if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght]16.continue;17.}18.hough_2d[cell][max] +=1;19.}20.}21.}寻找最大霍夫值计算霍夫阈值的代码如下：[java]view plaincopy1.// find the max hough value2.int max_hough = 0;3.for(int i=0; i<hough_space; i++) {4.for(int j=0; j<2*max_length; j++) {5.hough_1d[(i + j * hough_space)] = hough_2d[i][j];6.if(hough_2d[i][j] > max_hough) {7.max_hough = hough_2d[i][j];8.}9.}10.}11.System.out.println("MAX HOUGH VALUE = " + max_h ough);12.13.// transfer back to image pixels space from hough par ameter space14.int hough_threshold = (int)(threshold * max_hough);从霍夫空间反变换回像素数据空间代码如下：[java]view plaincopy1.// transfer back to image pixels space from hough param eter space2.int hough_threshold = (int)(threshold * max_hough);3.for(int row = 0; row < hough_space; row++) {4.for(int col = 0; col < 2*max_length; col++) {5.if(hough_2d[row][col] < hough_threshold) // discard it6.continue;7.int hough_value = hough_2d[row][col];8.boolean isLine = true;9.for(int i=-1; i<2; i++) {10.for(int j=-1; j<2; j++) {11.if(i != 0 || j != 0) {12.int yf = row + i;13.int xf = col + j;14.if(xf < 0) continue;15.if(xf < 2*max_length) {16.if (yf < 0) {17.yf += hough_space;18.}19.if (yf >= hough_space) {20.yf -= hough_space;21.}22.if(hough_2d[yf][xf] <= hough_value) {23.continue;24.}25.isLine = false;26.break;27.}28.}29.}30.}31.if(!isLine) continue;32.33.// transform back to pixel data now...34.double dy = Math.sin(row * hough_interval);35.double dx = Math.cos(row * hough_interval);36.if ((row <= hough_space / 4) || (row >= 3 * hough_spa ce / 4)) {37.for (int subrow = 0; subrow < height; ++subrow) {38.int subcol = (int)((col - max_length - ((subrow - center Y) * dy)) / dx) + centerX;39.if ((subcol < width) && (subcol >= 0)) {40.image_2d[subrow][subcol] = -16776961;41.}42.}43.} else {44.for (int subcol = 0; subcol < width; ++subcol) {45.int subrow = (int)((col - max_length - ((subcol - center X) * dx)) / dy) + centerY;46.if ((subrow < height) && (subrow >= 0)) {47.image_2d[subrow][subcol] = -16776961;48.}49.}50.}51.}52.}霍夫变换源图如下：霍夫变换以后，在霍夫空间显示如下：（白色表示已经找到直线信号）最终反变换回到像素空间效果如下：一个更好的运行监测直线的结果(输入为二值图像)：完整的霍夫变换源代码如下：[java]view plaincopy1.package com.gloomyfish.image.transform;2.3.import java.awt.image.BufferedImage;4.5.import com.process.blur.study.AbstractBufferedImageOp;6.7.public class HoughLineFilter extends AbstractBufferedIma geOp {8.public final static double PI_VALUE = Math.PI;9.private int hough_space = 500;10.private int[] hough_1d;11.private int[][] hough_2d;12.private int width;13.private int height;14.15.private float threshold;16.private float scale;17.private float offset;18.19.public HoughLineFilter() {20.// default hough transform parameters21.// scale = 1.0f;22.// offset = 0.0f;23.threshold = 0.5f;24.scale = 1.0f;25.offset = 0.0f;26.}27.28.public void setHoughSpace(int space) {29.this.hough_space = space;30.}31.32.public float getThreshold() {33.return threshold;34.}35.36.public void setThreshold(float threshold) {37.this.threshold = threshold;38.}39.40.public float getScale() {41.return scale;42.}43.44.public void setScale(float scale) {45.this.scale = scale;46.}47.48.public float getOffset() {49.return offset;50.}51.52.public void setOffset(float offset) {53.this.offset = offset;54.}55.56.@Override57.public BufferedImage filter(BufferedImage src, BufferedImage dest) {58.width = src.getWidth();59.height = src.getHeight();60.61.if ( dest == null )62.dest = createCompatibleDestImage( src, null );63.64.int[] inPixels = new int[width*height];65.int[] outPixels = new int[width*height];66.getRGB( src, 0, 0, width, height, inPixels );67.houghTransform(inPixels, outPixels);68.setRGB( dest, 0, 0, width, height, outPixels );69.return dest;70.}71.72.private void houghTransform(int[] inPixels, int[] outPix els) {73.// prepare for hough transform74.int centerX = width / 2;75.int centerY = height / 2;76.double hough_interval = PI_VALUE/(double)hough_sp ace;77.78.int max = Math.max(width, height);79.int max_length = (int)(Math.sqrt(2.0D) * max);80.hough_1d = new int[2 * hough_space * max_length];81.82.// define temp hough 2D array and initialize the hough 2D83.hough_2d = new int[hough_space][2*max_length];84.for(int i=0; i<hough_space; i++) {85.for(int j=0; j<2*max_length; j++) {86.hough_2d[i][j] = 0;87.}88.}89.90.// start hough transform now....91.int[][] image_2d = convert1Dto2D(inPixels);92.for (int row = 0; row < height; row++) {93.for (int col = 0; col < width; col++) {94.int p = image_2d[row][col] & 0xff;95.if(p == 0) continue; // which means background color96.97.// since we does not know the theta angle and r value,98.// we have to calculate all hough space for each pixel point99.// then we got the max possible theta and r pair.100.// r = x * cos(theta) + y * sin(theta)101.for(int cell=0; cell < hough_space; cell++ ) {102.max = (int)((col - centerX) * Math.cos(cell * hough_int erval) + (row - centerY) * Math.sin(cell * hough_interval));103.max += max_length; // start from zero, not (-max_length)104.if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght]105.continue;106.}107.hough_2d[cell][max] +=1;108.}109.}110.}111.112.// find the max hough value113.int max_hough = 0;114.for(int i=0; i<hough_space; i++) {115.for(int j=0; j<2*max_length; j++) {116.hough_1d[(i + j * hough_space)] = hough_2d[i][j];117.if(hough_2d[i][j] > max_hough) {118.max_hough = hough_2d[i][j];119.}120.}121.}122.System.out.println("MAX HOUGH VALUE = " + max_h ough);123.124.// transfer back to image pixels space from hough par ameter space125.int hough_threshold = (int)(threshold * max_hough);126.for(int row = 0; row < hough_space; row++) {127.for(int col = 0; col < 2*max_length; col++) {128.if(hough_2d[row][col] < hough_threshold) // discard it129.continue;130.int hough_value = hough_2d[row][col];131.boolean isLine = true;132.for(int i=-1; i<2; i++) {133.for(int j=-1; j<2; j++) {134.if(i != 0 || j != 0) {135.int yf = row + i;136.int xf = col + j;137.if(xf < 0) continue;138.if(xf < 2*max_length) {139.if (yf < 0) {140.yf += hough_space;141.}142.if (yf >= hough_space) {143.yf -= hough_space;144.}145.if(hough_2d[yf][xf] <= hough_value) {146.continue;147.}148.isLine = false;149.break;150.}151.}152.}153.}154.if(!isLine) continue;155.156.// transform back to pixel data now...157.double dy = Math.sin(row * hough_interval);158.double dx = Math.cos(row * hough_interval);159.if ((row <= hough_space / 4) || (row >= 3 * hough_spa ce / 4)) {160.for (int subrow = 0; subrow < height; ++subrow) { 161.int subcol = (int)((col - max_length - ((subrow - center Y) * dy)) / dx) + centerX;162.if ((subcol < width) && (subcol >= 0)) {163.image_2d[subrow][subcol] = -16776961;164.}165.}166.} else {167.for (int subcol = 0; subcol < width; ++subcol) {168.int subrow = (int)((col - max_length - ((subcol - center X) * dx)) / dy) + centerY;169.if ((subrow < height) && (subrow >= 0)) {170.image_2d[subrow][subcol] = -16776961;171.}172.}173.}174.}175.}176.177.// convert to hough 1D and return result178.for (int i = 0; i < this.hough_1d.length; i++)179.{180.int value = clamp((int)(scale * this.hough_1d[i] + offset )); // scale always equals 1181.this.hough_1d[i] = (0xFF000000 | value + (value << 16 ) + (value << 8));182.}183.184.// convert to image 1D and return185.for (int row = 0; row < height; row++) {186.for (int col = 0; col < width; col++) {187.outPixels[(col + row * width)] = image_2d[row][col];188.}189.}191.192.public BufferedImage getHoughImage() {193.BufferedImage houghImage = new BufferedImage(ho ugh_2d[0].length, hough_space, BufferedImage.TYPE_4BYTE_AB GR);194.setRGB(houghImage, 0, 0, hough_2d[0].length, hough _space, hough_1d);195.return houghImage;196.}197.198.public static int clamp(int value) {199.if (value < 0)200.value = 0;201.else if (value > 255) {202.value = 255;203.}204.return value;205.}206.207.private int[][] convert1Dto2D(int[] pixels) {208.int[][] image_2d = new int[height][width];209.int index = 0;210.for(int row = 0; row < height; row++) {211.for(int col = 0; col < width; col++) {212.index = row * width + col;213.image_2d[row][col] = pixels[index];214.}215.}216.return image_2d;218.219.}转载文章请务必注明出自本博客！！。