【Android—OpenCV实战】实现霍夫圆检测针对沙盘交通灯信号检测

Android OpenCV实战：霍夫圆检测实现沙盘交通灯智能识别

🌟 引言：当计算机视觉遇见智慧交通

在智能交通沙盘系统中，交通信号灯的精准识别是实现车辆智能调度的关键。传统图像处理方法中，霍夫圆检测因其对规则几何形状的出色识别能力，成为圆形交通灯检测的首选方案。本文将手把手教你如何在Android平台基于OpenCV实现这一经典算法，并赋予其"看懂"红绿灯颜色的能力！

🔍 霍夫圆检测原理剖析

🔍 数学之美：参数空间转换

霍夫圆检测的核心思想是将图像空间中的圆映射到三维参数空间$(x,y,r)$，其参数方程可表示为：
$$(x-a{)}^2+(y-b{)}^2=r^2$$
其中$(a,b)$为圆心坐标，$r$为半径。OpenCV采用霍夫梯度法进行优化：

🔍 关键参数解析

🛠 Android实现全流程

🛠 环境准备

1. 添加OpenCV Android SDK依赖
2. 配置NDK支持（建议使用最新稳定版）

🛠 核心代码解析

// 霍夫圆检测核心代码
Imgproc.HoughCircles(
    grayImage,     // 灰度输入
    circles,       // 输出矩阵
    Imgproc.HOUGH_GRADIENT, 
    2,             // dp=2 
    100,           // minDist=100px
    20, 100,       // param1=20, param2=100
    20, 35         // 半径范围20-35px
);

🛠 颜色识别策略

采用BGR色彩空间均值判断：

if(meanColor.val[0] > 180 && ...) // 红色通道主导
else if(...)                      // 双高通道为黄色
else                              // 绿色通道主导

🎯 性能优化技巧

1. 图像预处理：高斯模糊降噪（代码示例）

   img = cv.medianBlur(img,5)  # Python示例
   Imgproc.GaussianBlur(...);  // Java实现
   

2. ROI区域裁剪：仅处理图像上半部分交通灯区域

3. 多尺度检测：结合不同dp值进行分层检测

📊 实验结果对比

🚀 完整实现流程图

🚀Python实现霍夫圆检测

import numpy as np
import cv2 as cv
img = cv.imread('opencv-logo-white.png',0)
img = cv.medianBlur(img,5)
cimg = cv.cvtColor(img,cv.COLOR_GRAY2BGR)
circles = cv.HoughCircles(img,cv.HOUGH_GRADIENT,1,20,
                            param1=50,param2=30,minRadius=0,maxRadius=0)
circles = np.uint16(np.around(circles))
for i in circles[0,:]:
    # draw the outer circle
    cv.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)
    # draw the center of the circle
    cv.circle(cimg,(i[0],i[1]),2,(0,0,255),3)
cv.imshow('detected circles',cimg)
cv.waitKey(0)
cv.destroyAllWindows()

🚀Android实现霍夫圆检测

public class TrafficUtils {

    // 霍夫圆检测
    public static void HoughCircleCheck(Bitmap bitmap, Context context,int id, TextView textView, ImageView imageView) {
        int red = 0,yellow = 0, green = 0;
        // 进行霍夫圆检测
        Mat grayImage = new Mat();
        Mat mat = new Mat();
        Utils.bitmapToMat(bitmap, mat);
        // 将图片转换为单通道GRAY
        Imgproc.cvtColor(mat, grayImage, Imgproc.COLOR_BGR2GRAY);
        Mat circles = new Mat();
        /* 霍夫圆检测 Imgproc.HoughCircles()
        * grayImage：输入图像，必须是单通道的灰度图像。
        * circles：输出参数，用于存储检测到的圆的结果。它是一个Mat类型的变量，每一行包含了一个检测到的圆的信息，包括圆心的坐标和半径。
        * method：霍夫圆检测的方法。在OpenCV中，只提供了一种方法，即Imgproc.CV_HOUGH_GRADIENT。它基于梯度信息来进行圆检测。
        * dp：累加器分辨率与图像分辨率的比值。默认值为1，表示两者相等。较小的值可以提高检测的精度，但会增加计算量。
        * minDist：检测到的圆之间的最小距离。如果设置为太小的值，可能会导致检测到重复的圆。如果设置为太大的值，可能会错过一些圆。
        * param1：边缘检测阈值。边缘像素的梯度值高于该阈值才会被认为是有效的边缘。较大的值可以过滤掉较弱的边缘，较小的值可以检测到更多的圆。
        * param2：圆心累加器阈值。检测到的圆心区域的累加器值高于该阈值才会被认为是有效的圆心。较大的值可以过滤掉较弱的圆，较小的值可以检测到更多的圆。
        * minRadius：圆的最小半径。如果设置为0，则没有最小半径限制。
        * maxRadius：圆的最大半径。如果设置为0，则没有最大半径限制。
        */
        Imgproc.HoughCircles(grayImage, circles, Imgproc.CV_HOUGH_GRADIENT, 2, 100, 20, 100, 20, 35);
        // 创建掩膜图像
        Mat mask = Mat.zeros(mat.size(), CvType.CV_8U);
        // 绘制检测到的圆形区域到掩膜图像上
        for (int i = 0; i < circles.cols(); i++) {
            double[] circleData = circles.get(0, i);
            Point center = new Point(circleData[0], circleData[1]);
            int radius = (int) circleData[2];
            Imgproc.circle(mask, center, radius, new Scalar(255), -1);
            // 提取圆形区域的颜色
            Rect roi = new Rect((int)(center.x - radius), (int)(center.y - radius), radius * 2, radius * 2);
            Mat roiImage = new Mat(mat, roi);
            Scalar meanColor = Core.mean(roiImage);
            if (meanColor.val[0] > 180 && meanColor.val[1] < 180 && meanColor.val[2] < 180 ){
                red++;
            } else if (meanColor.val[0] > 180 && meanColor.val[1] > 180 && meanColor.val[2] < 180 ) {
                yellow++;
            } else if (meanColor.val[0] < 180 && meanColor.val[1] > 180 && meanColor.val[2] > 180 ) {
               green++;
            }
            Log.d("color", meanColor.val[0]+" "+meanColor.val[1]+" "+meanColor.val[2]);
            // 在圆的中心位置绘制颜色标记
            Imgproc.circle(mat, center, 50, meanColor, -1);
        }
        String circleColor;
        if (red > yellow && red > green){
            circleColor = "交通信号灯识别结果：红色";
        }else if(yellow > red && yellow > green){
            circleColor = "交通信号灯识别结果：黄色";
        }else if(green > red && green > yellow) {
            circleColor = "交通信号灯识别结果：绿色";
        }else {
            circleColor = "未识别到交通灯";
        }
        // 将原始图像与掩膜图像进行按位与运算，只保留圆形区域
        Mat result = new Mat();
        Core.bitwise_and(mat, mat, result, mask);
        // 显示结果
        Bitmap bitmapResult = Bitmap.createBitmap(result.cols(), result.rows(), Bitmap.Config.ARGB_8888);
        Utils.matToBitmap(result, bitmapResult);
        if (textView != null) {
            textView.append(circleColor);
            imageView.setImageBitmap(bitmapResult);
        } else {
            RecDialog.createLoadingDialog(context, bitmapResult, "交通灯识别", circleColor);
            if (circleColor.contains("交通信号灯识别结果：红色")) {
                ConnectTransport.yanchi(500);
                FirstActivity.Connect_Transport.traffic_control(id, 0x02, 0x01);
                ConnectTransport.yanchi(500);
                FirstActivity.Connect_Transport.traffic_control(id, 0x02, 0x01);
                ToastUtil.ShowToast(context,"红色");
            } else if (circleColor.contains("交通信号灯识别结果：黄色")) {
                ConnectTransport.yanchi(500);
                FirstActivity.Connect_Transport.traffic_control(id, 0x02, 0x02);
                ConnectTransport.yanchi(500);
                FirstActivity.Connect_Transport.traffic_control(id, 0x02, 0x02);
                ToastUtil.ShowToast(context,"黄色");
            } else if (circleColor.contains("交通信号灯识别结果：绿色")) {
                ConnectTransport.yanchi(500);
                FirstActivity.Connect_Transport.traffic_control(id, 0x02, 0x03);
                ConnectTransport.yanchi(500);
                FirstActivity.Connect_Transport.traffic_control(id, 0x02, 0x03);
                ToastUtil.ShowToast(context,"绿色");
            }
        }
    }
}

🚀Android实现霍夫圆检测（精简版本）

使用API实现灰度图像圆检测：

private void houghCircleDemo(Mat src, Mat dst) {
　　Mat gray = new Mat();
　　Imgproc.pyrMeanShiftFiltering(src, gray, 15, 80);
　　Imgproc.cvtColor(gray, gray, Imgproc.COLOR_BGR2GRAY);
　　Imgproc.GaussianBlur(gray, gray, new Size(3, 3),　0);
　　// detect circles
　　Mat circles = new Mat();
　　dst.create(src.size(), src.type());
　　Imgproc.HoughCircles(gray, circles, Imgproc.HOUGH_GRADIENT, 1, 20, 100, 30, 10, 200);
　　for(int i=0; i<circles.cols(); i++) {
　　　　float[] info = new float[3];
　　　　circles.get(0, i, info);
　　　　Imgproc.circle(dst, new Point((int)info[0], (int)info[1]), (int)info[2],
　　　　　　　　new Scalar(0, 255, 0), 2, 8, 0);
　　}
　　circles.release();
　　gray.release();
}

💡 扩展方向以及建议

1. 结合深度学习进行形状验证
2. 多目标跟踪实现状态切换检测
3. 建议使用深度学习抗干扰能力是最强的。

📚 参考文献

作者：我的青春不太冷
链接：https://blog.csdn.net/2503_90221393?type=blog
来源：CSDN
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。