精华内容
下载资源
问答
  • 自适应阈值的八方向和四方向sobel边缘检测代码MATLAB版本,标注清晰,采用3×3模板,根据待处理图像进行阈值计算和边缘检测。
  • 一种改进的八方向Sobel算子,python代码(基于matlab源码改写)。八个Kernel为:mask1=[-1 -2 -1;0 0 0;1 2 1]; mask2=[-2 -1 0;-1 0 1;0 1 2]; mask3=[-1 0 1;-2 0 2;-1 0 1]; mask4=[0 1 2;-1 0 1;-2 -1 0]; mask5...
  • 利用八个方向sobel边缘检测,其中为防止灰度值溢出对灰度值进行一个扩大和缩放的过程,可以检测出八个方向的灰度梯度值,检测出的边缘更加平缓连续,有兴趣的可以了解一下。
  • 基于河北师范大学硕士学位论文《基于八方向Sobel算子的边缘检测算法研究》。采用5x5, 0、 22.5、 45、 67.5、 90、 112.5、135、 157.5 八个方向的模板进行检测。
  • 一种改进的八方向sobel算子,matlab源代码
  • 8方向sobel边缘梯度平方和图像质量检测,8方向sobel边缘梯度平方和图像质量检测
  • 参考河北师范大学硕士学位论文——基于八方向Sobel算子的边缘检测算法研究。 由于自己实现滤波器运算,计算速度很慢,以后有能力再进行改进。 算子定义如下: 算法思路: 1.将RGB图像转化为CIELab颜色空间...

    参考河北师范大学硕士学位论文——基于八方向Sobel算子的边缘检测算法研究。
    由于自己实现滤波器运算,计算速度很慢,以后有能力再进行改进。


    算子定义如下:
    这里写图片描述


    算法思路:
    1.将RGB图像转化为CIELab颜色空间的图像。
    2.计算不同方向上的梯度,乘以权值后取最大值当作输出值。
    这里写图片描述


    效果如下:
    这里写图片描述
    运行时间:33.543444 秒。

    这里写图片描述
    运行时间:79.695009 秒。

    跑的好慢QAQ


    代码如下:
    CIELabEdge.m(算法的总入口)

    %在CIELab颜色空间下对图片进行边缘检测(参数为待处理的RGB图像)
    %使用论文中的八方向Sobel算子进行滤波
    %论文引自--郑英娟. 基于八方向Sobel算子的边缘检测算法研究. 河北师范大学硕士学位论文. 2013.3.26
    
    %From:Yinggang Wang
    %Create Date:2018.3.30
    
    function [] = CIELabEdge(img)
    
    %颜色空间转换
    Lab = RGB2Lab(img);
    
    %滤波处理
    Edge = MyFilter(Lab);
    
    %输出结果
    figure('NumberTitle','off','Name','边缘');
    imshow(Edge,[]);
    
    figure('NumberTitle','off','Name','边缘(负片)');
    imshow(imcomplement(Edge),[]);

    MyFilter.m(自己实现的滤波器)

    %使用滤波器滤波(参数:CIELab颜色空间的三维矩阵)(图像输出大小比实际小一点)
    %
    %From:Yinggang Wang
    %Create Date:2018.3.30
    
    function im = MyFilter(ori)
    
    s = size(ori);
    im = zeros(s(1),s(1,2));
    
    for i = 3:(s(1)-2)
        for j = 3:(s(2)-2)
            im(i-2,j-2) = getOutput(ori,i,j);
        end
    end

    getOutput.m(得到每一点的输出值)

    %得到x,y坐标像素点的输出值
    %
    %From:Yinggang Wang
    %Create Date:2018.3.30
    
    function out = getOutput(ori,x,y)
    
    %以下是八个方向的算子
    D0 = [1,2,4,2,1];
    D22_5 = [1,2,4,2,4];
    D45 = [1,4,2,4,1];
    D67_5 = [1,2,4,2,4];
    D90 = [1,2,4,2,1];
    D112_5 = [1,2,4,2,1];
    D135 = [1,4,2,4,1];
    D157_5 = [1,2,4,2,4];
    
    a = zeros(1,8);
    a(1) = sum(D0 .* [CD(ori(x-2,y-1),ori(x-2,y+1)),CD(ori(x-1,y-1),ori(x-1,y+1)),CD(ori(x,y-1),ori(x,y+1)),CD(ori(x+1,y-1),ori(x+1,y+1)),CD(ori(x+2,y-1),ori(x+2,y+1))]);
    a(2) = sum(D22_5 .* [CD(ori(x-2,y),ori(x+2,y)),CD(ori(x-1,y+1),ori(x+1,y-1)),CD(ori(x,y-1),ori(x,y+1)),CD(ori(x-1,y-1),ori(x+1,y+1)),CD(ori(x-1,y),ori(x+1,y))]);
    a(3) = sum(D45 .* [CD(ori(x+1,y-2),ori(x+2,y-1)),CD(ori(x,y-1),ori(x+1,y)),CD(ori(x-1,y-1),ori(x+1,y+1)),CD(ori(x-1,y),ori(x,y+1)),CD(ori(x-2,y+1),ori(x-1,y+2))]);
    a(4) = sum(D67_5 .* [CD(ori(x,y-2),ori(x,y+2)),CD(ori(x-1,y-1),ori(x+1,y+1)),CD(ori(x-1,y),ori(x+1,y)),CD(ori(x-1,y+1),ori(x+1,y-1)),CD(ori(x,y+1),ori(x,y-1))]);
    a(5) = sum(D90 .* [CD(ori(x-1,y-2),ori(x+1,y-2)),CD(ori(x-1,y-1),ori(x+1,y-1)),CD(ori(x-1,y),ori(x+1,y)),CD(ori(x-1,y-2),ori(x+1,y-2)),CD(ori(x-1,y+2),ori(x+1,y+2))]);
    a(6) = sum(D112_5 .* [CD(ori(x,y-2),ori(x,y+2)),CD(ori(x-1,y-1),ori(x+1,y+1)),CD(ori(x-1,y),ori(x+1,y)),CD(ori(x-1,y+1),ori(x+1,y-1)),CD(ori(x,y+1),ori(x,y-1))]);
    a(7) = sum(D135 .* [CD(ori(x-1,y-2),ori(x-2,y-1)),CD(ori(x,y-1),ori(x-1,y)),CD(ori(x+1,y-1),ori(x-1,y+1)),CD(ori(x+1,y),ori(x,y+1)),CD(ori(x+2,y+1),ori(x+1,y+2))]);
    a(8) = sum(D157_5 .* [CD(ori(x-2,y),ori(x+2,y)),CD(ori(x-1,y+1),ori(x+1,y-1)),CD(ori(x,y-1),ori(x,y+1)),CD(ori(x-1,y-1),ori(x+1,y+1)),CD(ori(x-1,y),ori(x+1,y))]);
    
    a(1) = a(1)/10.0;
    a(2) = a(2)/13.0;
    a(3) = a(3)/12.0;
    a(4) = a(4)/13.0;
    a(5) = a(5)/10.0;
    a(6) = a(6)/13.0;
    a(7) = a(7)/12.0;
    a(8) = a(8)/13.0;
    
    out = ((max(a)+0.5));

    CD.m(求两点的欧式距离)

    %求两点的欧式距离
    %
    %From:Yinggang Wang
    %Create Date:2018.3.30
    
    function dis = CD(a,b)
    dis = sqrt((a-b)^2 + (a-b)^2 + (a-b)^2);

    代码已经上传:点击进入下载页面

    展开全文
  • Sobel算子->方向滤波

    千次阅读 2020-10-12 19:34:04
    索贝尔算子(Sobel operator) 在技术上,它是一离散性差分算子,用来运算图像亮度函数的灰度之近似值。在图像的任何一点使用此算子,将会产生对应的灰度矢量或是其法矢量,主要用作边缘检测,可被认为是图像在垂直和...

    索贝尔算子(Sobel operator
    在技术上,它是一离散性差分算子,用来运算图像亮度函数的灰度之近似值。在图像的任何一点使用此算子,将会产生对应的灰度矢量或是其法矢量,主要用作边缘检测,可被认为是图像在垂直和水平方向变化的测量。

    注意:
    ①观察灰度分布来描述一幅图像成为空间域,观察图像变化的频率被成为频域。
    ②频域分析:低频对应区域的图像强度变化缓慢,高频对应的变化快。低通滤波器去除了图像的高频部分,高通滤波器去除了图像的低频部分。
    两组3x3的矩阵,分别为横向及纵向

    这里的卷积因子是卷积神经的一个小知识点就是以卷积因子为标本去对比总样本中的数据,如图卷积因子的工作原理

    具体计算
    将卷积因子与图像作平面卷积,即可分别得出横向及纵向的亮度差分近似值。如果以A代表原始图像,Gx及Gy分别代表经横向及纵向边缘检测的图像灰度值,其公式如下:
    Gx = (-1)f(x-1, y-1) + 0f(x,y-1) + 1f(x+1,y-1)
    +(-2)f(x-1,y) + 0f(x,y)+2f(x+1,y)
    +(-1)f(x-1,y+1) + 0f(x,y+1) + 1
    f(x+1,y+1)
    = [f(x+1,y-1)+2f(x+1,y)+f(x+1,y+1)]-[f(x-1,y-1)+2f(x-1,y)+f(x-1,y+1)]*

    Gy =1 f(x-1, y-1) + 2f(x,y-1)+ 1f(x+1,y-1)
    +0f(x-1,y) 0f(x,y) + 0*f(x+1,y)
    +(-1)*f(x-1,y+1) + (-2)f(x,y+1) + (-1)f(x+1, y+1)
    = [f(x-1,y-1) + 2f(x,y-1) + f(x+1,y-1)]-[f(x-1, y+1) + 2
    f(x,y+1)+f(x+1,y+1)]

    其中f(a,b), 表示图像(a,b)点的灰度值;
    图像的每一个像素的横向及纵向灰度值通过以下公式结合,来计算该点灰度的大小:
    在这里插入图片描述
    通常,为了提高效率 使用不开平方的近似值:
    在这里插入图片描述
    如果梯度G大于某一阀值 则认为该点(x,y)为边缘点。

    然后可用以下公式计算梯度方向:
    在这里插入图片描述

    代码
    大致了解了Sobel算子的原理,我们来看一下在OpenCV中的使用方法:

    #include <iostream>
    #include <iomanip>
    #include <opencv2/core/core.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include "laplacianZC.h"
    
    int main()
    {
         //读取图像
        cv::Mat image= cv::imread("boldt.jpg",0);
        if (!image.data)
            return 0; 
    
        // 展示读入的图像
        cv::namedWindow("Original Image");
        cv::imshow("Original Image",image);
    
        // 计算 Sobel X 导数
        cv::Mat sobelX;
        cv::Sobel(image,sobelX,CV_8U,1,0,3,0.4,128);
    
        // 显示图像
        cv::namedWindow("Sobel X Image");
        cv::imshow("Sobel X Image",sobelX);
    
        // 计算 Sobel Y 导数
        cv::Mat sobelY;
        cv::Sobel(image,sobelY,CV_8U,0,1,3,0.4,128);
    
        // 显示图像
        cv::namedWindow("Sobel Y Image");
        cv::imshow("Sobel Y Image",sobelY);
    
        //  计算sobel的摸
        cv::Sobel(image,sobelX,CV_16S,1,0);
        cv::Sobel(image,sobelY,CV_16S,0,1);
        cv::Mat sobel;
        //compute the L1 norm
        sobel= abs(sobelX)+abs(sobelY);
    
        double sobmin, sobmax;
        cv::minMaxLoc(sobel,&sobmin,&sobmax);
        std::cout << "sobel value range: " << sobmin << "  " << sobmax << std::endl;
    
        // 打印窗口像素值
        for (int i=0; i<12; i++) {
            for (int j=0; j<12; j++)
                std::cout << std::setw(5) << static_cast<int>(sobel.at<short>(i+135,j+362)) << " ";
            std::cout << std::endl;
        }
        std::cout << std::endl;
        std::cout << std::endl;
        std::cout << std::endl;
    
        // 转换为8位图像
        // sobelImage = -alpha*sobel + 255
        cv::Mat sobelImage;
        sobel.convertTo(sobelImage,CV_8U,-255./sobmax,255);
    
        // 显示图像
        cv::namedWindow("Sobel Image");
        cv::imshow("Sobel Image",sobelImage);
    
        // 对Sobel norm应用阈值(低阈值)
        cv::Mat sobelThresholded;
        cv::threshold(sobelImage, sobelThresholded, 225, 255, cv::THRESH_BINARY);
    
        // 显示图像
        cv::namedWindow("Binary Sobel Image (low)");
        cv::imshow("Binary Sobel Image (low)",sobelThresholded);
    
        // 对Sobel norm应用阈值(高阈值)
        cv::threshold(sobelImage, sobelThresholded, 190, 255, cv::THRESH_BINARY);
    
        // 显示图像
        cv::namedWindow("Binary Sobel Image (high)");
        cv::imshow("Binary Sobel Image (high)",sobelThresholded);
    

    参考文章:
    OpenCV入门
    Sobel算法

    展开全文
  • sobel算子实现度图像的边缘提取,x和y方向叠加
  • OpenCV之sobel算子详解

    2021-01-06 16:07:09
    sobel算子是一种计算不同方向上梯度的工具。原理是使用卷积核对图像进行处理。 如果想计算x方向梯度,我们就需要这样的一个卷积核 以卷积核的中心为中心,将卷积核与图像上像素值一一对应,卷积核上的数字相当于...
  • sobel求X、Y方向梯度API实现

    千次阅读 2018-03-30 20:20:14
    OpenCV+VS 代码如下:#include &lt;cvInclude.h&gt; #include &lt;iostream&gt; using namespace cv;.../*******************************************************************.../* Sobel算子API实现...

    OpenCV+VS 代码如下:

    #include <cvInclude.h>
    #include <iostream>
    using namespace cv;
    
    /************************************************************************/
    /*                    Sobel算子API实现求图像X与Y方向梯度                    */
    /************************************************************************/
    
    int main()
    {
    	//cv::Mat matRgb(h, w, CV_8UC3);
    	//cv::Mat matGray(h, w, CV_8UC1);
    	//cv::Mat matShort(h, w, CV_16S);
    
    	Mat inImg = imread("F:/test_photo/hand.jpg");
    	if (!inImg.data)
    	{
    		printf("could not load image..\n");
    		return -1;
    	}
    	imshow("输入图像",inImg);
    	int height = inImg.rows;//输入图像的高
    	int weight = inImg.cols;//输入图像的宽
    	
    	//创建grad_x,grad_y
    	Mat grad_x, grad_y;
    	Mat abs_grad_x, abs_grad_y;
    
    	//求X方向梯度
    	//第3个参数:int类型的ddepth,输出图像的深度
    	//第4个参数:int类型dx,x方向的差分阶数;
    	//第5个参数:int类型dy,y方向的差分阶数;
    	//第6个参数:int类型ksize,默认值3,表示Sobel核的大小;必须取1,3,5,7
    	//第7个参数:double类型scale,计算导数值时可选的缩放因子,默认为1
    	//第8个参数:double类型delta,表示在结果存入目标图(dst)之前可选的delta值,默认值0
    	//第9个参数:int类型的borderType,边界模式,默认为BORDER_DEFAULT
    	Sobel(inImg, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT);
    	imshow("X方向Sobel", grad_x);
    	//必须取绝对值,否则输出全灰色。我猜是因为:梯度有方向
    	convertScaleAbs(grad_x, abs_grad_x);
    	imshow("X方向abs_Sobel", abs_grad_x);
    
    	//求Y方向梯度
    	Sobel(inImg, grad_y, CV_16S, 0, 1, 3, 1, 1, BORDER_DEFAULT);
    	imshow("Y方向Sobel", grad_y);
    	convertScaleAbs(grad_y, abs_grad_y);
    	imshow("Y方向abs_Sobel", abs_grad_y);
    
    	waitKey(0);
    	return 0;
    
    }

    输出结果:

                                             

        

       

    展开全文
  • OpenCV python 图像梯度-sobel x方向 处理原图片[source.jpg] import cv2 def main(): # 1.导入图片 img_src = cv2.imread("source.jpg") # 2.执行sobel算法 img_sobel_64 = cv2.Sobel(img_src, cv2.CV_64...
  • 使用Sobel算子进行图像水平或者垂直方向边缘检测,比较简单,直接附上代码: import cv2 import skimage from skimage import io,data,color,filters import matplotlib.pyplot as plt if __name__ == "__main__...
  • img_sobel_64x = cv2.Sobel(img_src, cv2.CV_64F, 1, 0) # 图像深度 64位浮点数 x方向一阶求导 img_sobel_64y = cv2.Sobel(img_src, cv2.CV_64F, 0, 1) # Gx Gy img_sobel_x = cv2.convertScaleAbs(img_sobel_64x...
  • 沿着一张图片X和Y轴的方向上的梯度是很有用的,因为在边缘和角点的梯度值是很大的,我们知道边缘和角点包含了很物体的形状信息。 怎么计算方向梯度直方图呢? 我们会先用图像的一个patch来解释。 第一步:预处理 ...
  • 关于sobel算子的算法,分为x和y方向的梯度,看完可以对sobel有个很好的了解
  • Sobel算子:用于边缘检测的离散微分算子。 梯度公式: 对于图像而言,它是离散的,所以h的最小值只能是1了,那么这意味着,图像中某个像素位置的梯度(以x方向为例)等于它左右两个像素点的像素之差除以2。 ...
  • 以前推导Laplace的时候大意了,以为Sobel算子的(1,2,1)(1,-2,1)也是二阶导。 最近回看发现并不对,根本找不出Sobel的数学原理... 找好久终于找到个似乎正确的:http://wap.sciencenet.cn/home.php?mod=space&...
  • 基于matlab的八个方向sobel图像边缘检测算法,希望能给大家带来帮助。
  • OpenCV Sobel算子水平和垂直方向导数问题

    万次阅读 多人点赞 2017-01-12 10:33:56
    sobel算子是一种常用的边缘检测算法,在各种论文或书籍中,我们常常能看到类似这样的话,被检测的对象存在大量的竖直边,所以可以采用sobel算子来找到第一个水平导数,它可以用来在图像中查找竖直边缘。 它在opencv...
  • sobel算子 dst=cv2.Sobel(src,ddepth,dx,dy,[ksize]) ddepth—处理结果图像深度...水平方向的梯度值组成一条线(垂直方向) dst=cv2.convertScaleAbs(src[,alpha[,beta]]):将原始图像src转换为256色位图,即:目标
  • 这是华中科技大学数字图像处理课程的作业,涉及图像边缘检测、手动实现sobel算子和prewitt算子,梯度图像的生成,街区距离的计算
  • 输出正确的方向梯度,sobel算子导出
  • OpenCV python 图像梯度–sobel XY方向叠加 处理原图:[source.jpg] import cv2 def main(): # 1.导入图片 img_src = cv2.imread("source.jpg") # 2.执行sobel算法 img_sobel_64x = cv2.Sobel(img_src, cv2....
  • Sobel算法

    2021-04-20 03:35:35
    1.2.1. Sobel算法分析索贝尔算子(Sobeloperator)主要用作边缘检测,在技术上,它是一离散性差分算子,用来运算图像亮度函数的灰度之近似值。在图像的任何一点使用此算子,将会产生对应的灰度矢量或是其法矢量。Sobel...
  • SOBEL算子梯度计算.zip

    2019-06-05 09:33:15
    通过定义sobel算子,对图像的各像素通过选定区域的卷积,得到相应像素点的X方向和Y方向的梯度,再利用梯度得到相应的计算内容,可以计算图像像素点的法线方向

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,179
精华内容 4,471
关键字:

多方向sobel