图像处理之图像边缘检测算法

news/2025/2/27 7:47:00

目录

1 图像边缘检测算法简介

2 Sobel边缘检测

3 经典的Canny边缘检测算法

4 演示Demo

4.1 开发环境

4.2 功能介绍

4.3 下载地址

参考

1 图像边缘检测算法简介

        图像边缘检测是计算机视觉和图像处理中的基本问题，主要目的是提取图像中明暗变化明显的边缘细节信息。

        图像边缘检测算法有很多，包括传统的模板算子（Sobel、Roberts、Prewitt、Laplace）、形态学边缘检测、经典的Canny边缘检测及基于深度学习的边缘检测算法等。

        本文主要介绍Sobel模板算子和经典的Canny边缘检测算法。

2 Sobel边缘检测

        Sobel模板算子是 Irwin Sobel 在1968年发表的论文 An Isotropic 3x3 Image Gradient Operator 中提出的一种一阶导数模板算子，用于计算图像灰度函数的近似梯度。

        Sobel模板算子如下：

G_x = \begin{pmatrix} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \end{pmatrix} G_y = \begin{pmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ 1 & 2 & 1 \end{pmatrix}

        其中G_x表示水平方向的卷积模板，G_y表示垂直方向的卷积模板。

        对于图像中任何一点的像素P(i,j)，使用水平和垂直卷积模板分别对图像进行卷积操作，得到水平梯度GX和垂直梯度GY，则梯度幅度计算如下：

G=\sqrt{(GX)^2 + (GY)^2}

        完整梯度幅度计算公式如下：

        Sobel边缘检测结果计算如下

Edge(i,j) = \begin{cases} 255 &\text{if } G(i,j)>Threshold \\ 0 &\text{if } others \end{cases}

其中，255白色表示边缘，0黑色表示背景。

        C语言实现Sobel边缘检测算法代码如下：

/*************************************************
功    能：图像Sobel边缘检测
参    数：srcData     -   [输入/输出] 原始图像，格式为32位BGRA格式，执行后修为结果图像
          width       -   [输入] 原始图像宽度
          height      -   [输入] 原始图像高度
          stride      -   [输入] 原始图像的Stride（也就是行字节数width*4）
          threshold   -   [输入] 阈值
返    回： 0-成功,其他-失败.
*************************************************/
int sobel(unsigned char *srcData, int width, int height, int stride, int threshold)
{
        int ret = 0;
        unsigned char *dstData = (unsigned char*)malloc(sizeof(unsigned char) * height * stride);
        memset(dstData, 255, sizeof(unsigned char) * height * stride);
        int x, y, i, k, pos;
        int hValue, vValue, value;
        unsigned char *pSrcL0;
        unsigned char *pSrcL1;
        unsigned char *pSrcL2;
        unsigned char *pDstL;
        unsigned char SqrtValue[65026];
        pSrcL0 = srcData;
        pSrcL1 = srcData + stride;
        pSrcL2 = srcData + stride * 2;
        pDstL = dstData + stride;
        for (i = 0; i < 65026; i++)
        {
                SqrtValue[i] = (unsigned char)(sqrt((float)i) < threshold ? 0 : 255);
        }
        for (y = 1; y < height - 1; y++)
        {
                for (x = 1; x < width - 1; x++)
                {
                        pos = x * 4;
                        hValue = (-pSrcL0[pos - 4] + pSrcL0[pos + 4] - 2 * pSrcL1[pos - 4] + 2 * pSrcL1[pos + 4] - pSrcL2[pos - 4] + pSrcL2[pos + 4]);
                        vValue = (pSrcL0[pos - 4] + 2 * pSrcL0[pos] + pSrcL0[pos + 4] - pSrcL2[pos - 4] - 2 * pSrcL2[pos] - pSrcL2[pos + 4]);
                        k = hValue * hValue + vValue * vValue;
                        k = MIN2(k, 65025);
                        pDstL[pos] = SqrtValue[k];
                        pos++;
                        hValue = (-pSrcL0[pos - 4] + pSrcL0[pos + 4] - 2 * pSrcL1[pos - 4] + 2 * pSrcL1[pos + 4] - pSrcL2[pos - 4] + pSrcL2[pos + 4]);
                        vValue = (pSrcL0[pos - 4] + 2 * pSrcL0[pos] + pSrcL0[pos + 4] - pSrcL2[pos - 4] - 2 * pSrcL2[pos] - pSrcL2[pos + 4]);
                        k = hValue * hValue + vValue * vValue;
                        k = MIN2(k, 65025);
                        pDstL[pos] = SqrtValue[k];
                        pos++;
                        hValue = (-pSrcL0[pos - 4] + pSrcL0[pos + 4] - 2 * pSrcL1[pos - 4] + 2 * pSrcL1[pos + 4] - pSrcL2[pos - 4] + pSrcL2[pos + 4]);
                        vValue = (pSrcL0[pos - 4] + 2 * pSrcL0[pos] + pSrcL0[pos + 4] - pSrcL2[pos - 4] - 2 * pSrcL2[pos] - pSrcL2[pos + 4]);
                        k = hValue * hValue + vValue * vValue;
                        k = MIN2(k, 65025);
                        pDstL[pos] = SqrtValue[k];
                }
                pSrcL0 += stride;
                pSrcL1 += stride;
                pSrcL2 += stride;
                pDstL += stride;
        }
        memcpy(srcData, dstData, sizeof(unsigned char) * height * stride);
        free(dstData);
        return ret;
}

3 经典的Canny边缘检测算法

        Canny边缘检测是 John Canny 在1986年首次提出的一种改进的边缘检测方法。该方法主要通过图像信号函数的极大值来判断图像的边缘像素点，与基本的Sobel模板算子等相比，其具有低错误率、高定位性等优点，因此被广泛应用。

        （1）高斯滤波平滑处理

        由于图像中经常包含一些高斯噪声，因此，在边缘检测前，要先用高斯滤波器对其进行滤波。为了方便，这里使用如下高斯滤波器模板

\frac{1}{16}\begin{pmatrix} 1 & 2 & 1 \\ 2 & 4 & 2 \\ 1 & 2 & 1 \end{pmatrix}

        （2）梯度计算

        使用一阶导数算子（一般用Sobel模板算子）计算灰度图像中每个像素点在水平和垂直方向上的导数GX、GY，得出梯度向量（GX，GY），最后得到该像素点的梯度幅度G和相位角D

        （3）非极大值抑制

        对于上面计算得到的梯度值，其实是一个粗边缘信息，可以通过非极大值抑制去掉一些非边缘信息。这里将当前像素的梯度值与其在梯度方向上的邻域像素的梯度值做对比，如果当前像素的梯度值为最大值，则保留该点的梯度信息，否则将该点删除或将像素值置为9。

        （4）双阈值边缘检测和边缘连接

        由非极大值抑制得到的边缘信息中包含较多伪边缘信息，可通过设置高低双阈值的方法去除它们。

        首先，设定两个阈值，一个高阈值，一个低阈值，阈值大小根据实际情况设置，一般高阈值为低阈值的2.5倍。

        然后判断：梯度值大于高阈值的像素点一定是边缘点，将该点像素值置为255；梯度值小于低阈值的像素点一定不是边缘点，将该点像素值置为0；介于高低阈值之间的像素点为准边缘点，对于这些点，如果其像素点周围8邻域的梯度值都小于高阈值，则认为其不是边缘点，将该点像素值置为0，否则置为255。

        C语言实现Cannyl边缘检测算法代码如下：

/*************************************************
功    能：图像Canny边缘检测
参    数：srcData         -  [输入/输出] 原始图像，格式为32位BGRA格式，执行后修为结果图像
          width          -  [输入] 原始图像宽度
          height         -  [输入] 原始图像高度
          stride         -  [输入] 原始图像的Stride（也就是行字节数width*4）
          highThreshold  -  [输入] 高阈值，范围为[0,255]
          lowThreshold   -  [输入] 低阈值，范围为[0,255]，默认值为0.4*highThreshold
返    回： 0-成功,其他-失败.
*************************************************/

//单通道灰度化
static int grayOneChannel(unsigned char* srcData, unsigned char* grayData, int width, int height, int stride)
{
        int ret = 0;
        int i, j, gray, offset;
        offset = stride - (width * 4);
        unsigned char* pSrc = srcData;
        unsigned char* pGray = grayData;
        for (j = 0; j < height; j++)
        {
                for (i = 0; i < width; i++)
                {
                        gray = (pSrc[2] + pSrc[1] + pSrc[0]) / 3;
                        *pGray = gray;
                        pSrc += 4;
                        pGray++;
                }
                pSrc += offset;
        }
        return ret;
};

//梯度相位角获取  
static void GetGradientDegree(unsigned char* srcBytes, int width, int height, float gradient[], unsigned char degree[], float* GradientMax)
{
        float gx, gy;
        int temp, pos;
        float div;
        float PI = 3.1415926f;
        float t = 180.0f / PI;
        for (int j = 1; j < height - 1; j++)
        {
                for (int i = 1; i < width - 1; i++)
                {
                        pos = i + j * width;
                        gx = srcBytes[pos + 1 - width] + srcBytes[pos + 1] + srcBytes[pos + 1] + srcBytes[pos + 1 + width] - srcBytes[pos - 1 - width] - (srcBytes[pos - 1] + srcBytes[pos - 1]) - srcBytes[pos - 1 + width];
                        gy = srcBytes[pos - 1 - width] + srcBytes[pos - width] + srcBytes[pos - width] + srcBytes[pos + 1 - width] - srcBytes[pos - 1 + width] - (srcBytes[pos + width] + srcBytes[pos + width]) - srcBytes[pos + 1 + width];
                        gradient[pos] = (float)sqrt((float)(gx * gx + gy * gy));
                        if (*GradientMax < gradient[pos])
                        {
                                *GradientMax = gradient[pos];
                        }
                        if (gx == 0)
                        {
                                temp = (gy == 0) ? 0 : 90;
                        }
                        else
                        {
                                div = gy / gx;
                                if (div < 0)
                                {
                                        temp = (int)(180 - atan(-div) * t);
                                }
                                else
                                {
                                        temp = (int)(atan(div) * t);
                                }
                                if (temp < 22.5f)
                                {
                                        temp = 0;
                                }
                                else if (temp < 67.5f)
                                {
                                        temp = 45;
                                }
                                else if (temp < 112.5f)
                                {
                                        temp = 90;
                                }
                                else if (temp < 157.5f)
                                {
                                        temp = 135;
                                }
                                else
                                        temp = 0;
                        }
                        degree[pos] = temp;
                }
        }
};

//非极大值抑制  
static void NonMaxMini(unsigned char* srcBytes, int width, int height, float gradient[], float GradientMax, unsigned char degree[])
{
        float leftPixel = 0, rightPixel = 0;
        int pos;
        for (int j = 1; j < height - 1; j++)
        {
                for (int i = 1; i < width - 1; i++)
                {
                        pos = i + j * width;
                        switch (degree[pos])
                        {
                        case 0:
                                leftPixel = gradient[pos - 1];
                                rightPixel = gradient[pos + 1];
                                break;
                        case 45:
                                leftPixel = gradient[pos - 1 + width];
                                rightPixel = gradient[pos + 1 - width];
                                break;
                        case 90:
                                leftPixel = gradient[pos + width];
                                rightPixel = gradient[pos - width];
                                break;
                        case 135:
                                leftPixel = gradient[pos + 1 + width];
                                rightPixel = gradient[pos - 1 - width];
                                break;
                        default:
                                break;
                        }
                        if ((gradient[pos] < leftPixel) || (gradient[pos] < rightPixel))
                        {
                                srcBytes[pos] = 0;
                        }
                        else
                        {
                                srcBytes[pos] = (int)(255.0f * gradient[pos] / GradientMax);
                        }
                }
        }
};

//双阈值边缘判断  
static void TwoThreshouldJudge(unsigned char* srcBytes, int width, int height, int highThreshold, int lowThreshould)
{
        int pos = 0;
        for (int j = 1; j < height - 1; j++)
        {
                for (int i = 1; i < width - 1; i++)
                {
                        pos = i + j * width;
                        if (srcBytes[pos] > highThreshold)
                        {
                                srcBytes[pos] = 255;
                        }
                        else if (srcBytes[pos] < lowThreshould)
                        {
                                srcBytes[pos] = 0;
                        }
                        else
                        {
                                if (srcBytes[pos - 1 - width] < highThreshold && srcBytes[pos - width] < highThreshold && srcBytes[pos + 1 - width] < highThreshold && srcBytes[pos - 1] < highThreshold
                                        && srcBytes[pos + 1] < highThreshold && srcBytes[pos - 1 + width] < highThreshold && srcBytes[pos + width] < highThreshold && srcBytes[pos + 1 + width] < highThreshold)
                                {
                                        srcBytes[pos] = 0;
                                }
                                else
                                        srcBytes[pos] = 255;
                        }
                }
        }
};

int cannyEdgedetection(unsigned char* srcData, int width, int height, int stride, int highThreshold, int lowThreshold)
{
        int ret = 0;
        int i, j, offset, pos, temp, size;
        unsigned char* pSrc = srcData;
        size = width * height;
        unsigned char* grayData = (unsigned char*)malloc(sizeof(unsigned char) * size);
        memset(grayData, 0, sizeof(unsigned char) * size);
        offset = stride - width * 4;
        //gray
        grayOneChannel(srcData, grayData, width, height, stride);
        //gauss fiter
        for (j = 0; j < height; j++)
        {
                for (i = 0; i < width; i++)
                {
                        pos = i + j * width;
                        if (i == 0 || j == 0 || i == width - 1 || j == height - 1)
                        {
                                grayData[pos] = 0;
                        }
                        else
                        {
                                temp = ((grayData[pos] << 2) + grayData[pos - width - 1] + grayData[pos + 1 - width] + grayData[pos - 1 + width] + grayData[pos + 1 + width] + grayData[pos - width] + grayData[pos - width] + grayData[pos - 1] + grayData[pos - 1] + grayData[pos + width] + grayData[pos + width] + grayData[pos + 1] + grayData[pos + 1]) >> 4;
                                grayData[pos] = temp;
                        }
                }
        }
        //gradient
        float* gradient = (float*)malloc(sizeof(float) * size);
        memset(gradient, 0, sizeof(float) * size);
        unsigned char* degree = (unsigned char*)malloc(sizeof(unsigned char) * size);
        memset(degree, 0, sizeof(unsigned char) * size);
        float GradientMax = 0;
        GetGradientDegree(grayData, width, height, gradient, degree, &GradientMax);
        //none max value 
        NonMaxMini(grayData, width, height, gradient, GradientMax, degree);
        //two threshold judgement
        TwoThreshouldJudge(grayData, width, height, highThreshold, lowThreshold);
        //recovery
        for (j = 0; j < height; j++)
        {
                for (i = 0; i < width; i++)
                {
                        pSrc[0] = pSrc[1] = pSrc[2] = grayData[i + j * width];
                        pSrc += 4;
                }
                pSrc += offset;
        }
        free(grayData);
        free(gradient);
        free(degree);
        return ret;
};

4 演示Demo

4.1 开发环境

  • Windows 10 Pro x64

  • Visual Studio 2015

4.2 功能介绍

        演示程序主界面如下图所示，具有图像读取、显示、保存、显示RGBA值、HSV调整、提取YUV分量、灰度化、二值化、直方图、亮度/对比度调整、饱和度调整、均值滤波、高斯滤波、拉普拉斯锐化、USM锐化、Sobel边缘检测、Canny边缘检测等功能。

原图

Sobel边缘检测（阈值为80 ）效果图

Canny边缘检测（阈值为 8）效果图

4.3 下载地址

        开发环境：

  • Windows 10 pro x64

  • Visual Studio 2015

        下载地址：图像处理之图像边缘检测算法Demo

参考

        图像视频滤镜与人像美颜美妆算法详解. 胡耀武、谭娟、李云夕. 电子工业出版社、2020-07


http://www.niftyadmin.cn/n/5869746.html

相关文章

微服务架构与传统的单体架构有什么区别?微服务架构（Spring Cloud + Maven）强在哪?

微服务架构与传统的单体架构有什么区别?微服务架构（Spring Cloud + Maven）强在哪?

微服务架构与传统的单体架构&#xff08;Spring Boot Maven 项目&#xff09;在设计和实现上有显著差异&#xff0c;主要体现在系统拆分方式、部署模式、技术栈选择、维护成本等方面。以下是具体对比&#xff1a; 1. 架构设计 维度单体架构微服务架构系统拆分所有功能模块集…
阅读更多...
千峰React:案例一

千峰React:案例一

做这个案例捏 因为需要用到样式&#xff0c;所以创建一个样式文件&#xff1a; //29_实战.module.css .active{text-decoration:line-through } 然后创建jsx文件&#xff0c;修改main文件&#xff1a;导入Todos&#xff0c;写入Todos组件 import { StrictMode } from react …
阅读更多...
【前端基础】Day 2 CSS层叠样式表

【前端基础】Day 2 CSS层叠样式表

目录 1.CSS简历 2.CSS 基础选择器 2.1标签选择器 2.2类选择器 2.3 id选择器 2.4通配符选择器 2.5总结 3.CSS字体属性 字体属性总结 4.CSS文本属性 4.1颜色 4.2对齐文本 4.3装饰文本 4.4文本缩进 4.5行间距 4.6文本属性总结 5.CSS的引入方式 5.1内部样式表 …
阅读更多...
36. Spring Boot 2.1.3.RELEASE 中实现监控信息可视化并添加邮件报警功能

36. Spring Boot 2.1.3.RELEASE 中实现监控信息可视化并添加邮件报警功能

1. 创建 Spring Boot Admin Server 项目 1.1 添加依赖 在 pom.xml 中添加 Spring Boot Admin Server 和邮件相关依赖&#xff1a; <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-w…
阅读更多...
用 DeepSeek 打样！KubeSphere LuBan 用 3 天/3 分钟“干掉”大模型部署焦虑

用 DeepSeek 打样！KubeSphere LuBan 用 3 天/3 分钟“干掉”大模型部署焦虑

用 DeepSeek 打样&#xff01;KubeSphere LuBan 用 3 天/3 分钟“干掉”大模型部署焦虑 大模型落地&#xff0c;如何告别“部署焦虑”&#xff1f; DeepSeek-R1 的惊艳表现无需赘述&#xff0c;但企业落地时的高门槛却让许多开发者望而却步——复杂的部署流程、资源调度难题、…
阅读更多...
通过返回的key值匹配字典中的value值

通过返回的key值匹配字典中的value值

需求 页面中上面搜索项有获取字典枚举接口&#xff0c;table表格中也有根据key匹配字典中的value 方案一 需要做到的要求 这里上面下拉列表是一个组件获取的字典&#xff0c;下面也是通过字典匹配&#xff0c;所以尽量统一封装一个函数&#xff0c;每个组件保证最少变动tabl…
阅读更多...
Spring Data JPA vs MyBatis：ORM框架如何选择？

Spring Data JPA vs MyBatis：ORM框架如何选择？

在选择ORM框架时&#xff0c;Spring Data JPA和MyBatis是两个常见的选择&#xff0c;它们各有优缺点&#xff0c;适用于不同的场景。以下是两者的对比&#xff0c;帮助你做出选择&#xff1a; 1. Spring Data JPA 优点&#xff1a; 开发效率高&#xff1a;通过简单的接口定义和…
阅读更多...
【TCAD】Sentaurus 中的“陷阱trap”仿真设置

【TCAD】Sentaurus 中的“陷阱trap”仿真设置

13.1 陷阱类型 13.2 定义陷阱 13.3 陷阱态密度的类型 13.4 陷阱空间分布 13.5 陷阱占据 13.6 陷阱横截面 13.7 陷阱作为掺杂 13.8 陷阱填充控制 13.9 陷阱可视化 目标 演示如何使用 Sentaurus 设备在模拟中使用陷阱。13.1 陷阱类型
阅读更多...
最新文章

Copyright @ 2022~2023