精华内容
下载资源
问答
  •  1,将传进来的图片矩阵用算子进行卷积求和(卷积和取绝对值)  2,新的矩阵(与原图一样大小)去接收每次的卷积和的值  3,卷积图片所有的像素点后,把新的矩阵数据类型转化为uint8 注意:  必须对求得的卷积...
  • 这是华中科技大学数字图像处理课程的作业,涉及图像边缘检测、手动实现sobel算子和prewitt算子,梯度图像的生成,街区距离的计算
  • 对一幅灰度图像进行边缘检测、二值化,这里使用roberts算子,程序如下:%%使用梯度算子实现边缘检测%%使用matlab自带的函数进行边缘检测clear all;...%应用罗伯特算子对像进行边缘检测,并进行二值化figure, imsho...

    对一幅灰度图像进行边缘检测、二值化,这里使用roberts算子,程序如下:

    %%使用梯度算子实现边缘检测

    %%使用matlab自带的函数进行边缘检测

    clear all;

    I = imread('rice.png'); %导入图像

    imshow(I), title('none');%显示原图

    G = edge(I, 'roberts');%应用罗伯特算子对像进行边缘检测,并进行二值化

    figure, imshow(G), title('roberts');

    %%另有博客主给出的MATLAB实现五种边缘检测,Matlab图像二值化,hen有参考意义

    %%自己编码,先卷积检测边缘(使用roberts算子),再将图像二值化

    myF = I;

    %卷积操作,先补零

    myF(:, size(I, 2) + 1) = 0;

    myF(size(I, 1) + 1, :) = 0;

    %进行卷积检测边缘

    P = ones(size(I, 1) + 1, size(I, 2) + 1);

    for i = 1:size(I, 1)

    for j = 1:size(I, 2)

    P(i, j) = P(i, j) + abs(myF(i + 1, j + 1) -myF(i, j)) + abs(myF(i +1, j) - myF(i, j + 1));

    end

    end

    P = P(1:size(I, 1), 1:size(I, 2));

    figure, imshow(P, []), title('梯度图像');

    %二值化操作

    %先统计0到255灰度级对应的像素个数

    L = zeros(1, 256);

    for i = 1:size(P, 1)

    for j = 1:size(P, 2)

    for k = 0:255

    if P(i, j) == k

    L(k+1) = L(k+1) + 1;

    end

    end

    end

    end

    %绘制I的灰度直方图

    figure, bar(0:255, L);

    axis([0,255,0,1650]);%设置坐标轴x和y的范围——x从0到255,y从0到1650

    %%取谷底的灰度级45为二值化阈值

    for i = 1:size(P, 1)

    for j = 1:size(P, 2)

    if P(i, j) <= 45

    P(i, j) = 0;

    else

    P(i, j) = 1;

    end

    end

    end

    figure, imshow(P, []), title('二值化图像');%输出二值化图像

    结果展示:

    原图:                                                                使用matlab自带函数进行的边缘检测结果:

    512e28e5891e205b1ff0bb8ccb1e8c87.png 5207cd0f0a880f4fd1993b49121c8a12.png

    自己使用roberts算子卷积后得到的梯度图像:

    b730e6957bafd304181e3990a753f1ce.png

    统计的灰度直方图,大约在45灰度级处取到谷底:

    74149192dd1f62700f0b8155b56bdd66.png

    对梯度图像二值化得到的结果:

    593844ce6a27f17e1489032b98511e81.png

    自己编码得到的边缘检测结果与matlab自带函数进行的边缘检测结果略有不同。。。

    展开全文
  • 1 在新插入的对话框中添加两个Picture Control和两个Button 2 打开图像代码he

    1 在新插入的对话框中添加两个Picture Control和两个Button

    2 打开图像代码和显示图像代码和前面两篇博文类似

    BEGIN_MESSAGE_MAP(CEdgeDetDlg, CDialogEx)
    	ON_WM_PAINT()
    	ON_BN_CLICKED(IDC_OPEN_BTN, &CEdgeDetDlg::OnClickedOpenBtn)
    	ON_BN_CLICKED(IDC_EDGE_DETECTION_BTN, &CEdgeDetDlg::OnClickedEdgeDetectionBtn)
    END_MESSAGE_MAP()
    
    
    // CEdgeDetDlg 消息处理程序
    
    void CEdgeDetDlg::OnClickedOpenBtn()
    {
    	// TODO: 在此添加控件通知处理程序代码
    	CFileDialog dlg(TRUE,_T(".bmp"),_T("*.jpg"),OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
    		_T("Bit Map(*.bmp)|*.bmp|JPEG Map(*.jpg)|*.jpg||"));
    	if(dlg.DoModal() == IDOK)
    	{
    		if(!yuantu.IsNull())
    		{
    			yuantu.Destroy();
    		}
    		yuantu.Load(dlg.GetPathName());
    		Invalidate(FALSE);
    	}
    }
    
    //边缘检测
    void CEdgeDetDlg::OnClickedEdgeDetectionBtn()
    {
    	if (yuantu.IsNull())
    	{
    		MessageBox(_T("还未打开图像"),_T("系统提示"),MB_OK);
    		return;
    	}
    	if(!bianyuantu.IsNull())
    	{
    		bianyuantu.Destroy();
    	}
    
    	int i,j,temp;
    	int pixel[4];
    	int width = yuantu.GetWidth();
    	int height = yuantu.GetHeight();
    	int widthBytes = yuantu.GetPitch();
    	bianyuantu.Create(width,height,yuantu.GetBPP());
    
    	if(yuantu.IsIndexed())
    	{
    		yuantu.GetColorTable(0,256,colorTable);
    		bianyuantu.SetColorTable(0,256,colorTable);
    	}
    	BYTE *pYuantuData = (BYTE*)yuantu.GetBits();
    	BYTE *pBianyuantuData =(BYTE*)bianyuantu.GetBits();
    
    	
    	for(j=0;j<height-1;j++)
    	{
    		for(i=0;i<width-1;i++)
    		{
    			pixel[0]=pYuantuData[j*widthBytes+i];
    			pixel[1]=pYuantuData[j*widthBytes+i+1];
    			pixel[2]=pYuantuData[(j+1)*widthBytes+i];
    			pixel[3]=pYuantuData[(j+1)*widthBytes+i+1];
    			temp=(int)sqrt((double)((pixel[0]-pixel[3])*(pixel[0]-pixel[3])
    				+(pixel[1]-pixel[2])*(pixel[1]-pixel[2])));
    			pBianyuantuData[j*widthBytes+i]=temp;
    		}
    	}
    
    	Invalidate(FALSE);
    }
    
    void CEdgeDetDlg::OnPaint()
    {
    	if (IsIconic())
    	{
    		CPaintDC dc(this); // 用于绘制的设备上下文
    
    		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
    
    		// 使图标在工作区矩形中居中
    		int cxIcon = GetSystemMetrics(SM_CXICON);
    		int cyIcon = GetSystemMetrics(SM_CYICON);
    		CRect rect;
    		GetClientRect(&rect);
    		int x = (rect.Width() - cxIcon + 1) / 2;
    		int y = (rect.Height() - cyIcon + 1) / 2;
    
    		// 绘制图标
    		dc.DrawIcon(x, y, m_hIcon);
    	}
    	else
    	{
    		CDialogEx::OnPaint();
    
    		if(!yuantu.IsNull())
    		{
    			CWnd* pWndYuantu = this->GetDlgItem(IDC_YUANTU);
    			CDC* pdc = pWndYuantu->GetDC();
    			yuantu.Draw(pdc->GetSafeHdc(), 0, 0);
    			pWndYuantu->ReleaseDC(pdc);
    		}
    
    		if(!bianyuantu.IsNull())
    		{
    			CWnd* pWndBianyuantu = this->GetDlgItem(IDC_BIANYUANTU);
    			CDC* pdc = pWndBianyuantu->GetDC();
    			bianyuantu.Draw(pdc->GetSafeHdc(), 0, 0);
    			pWndBianyuantu->ReleaseDC(pdc);
    		}
    	}
    }
    测试时用的是灰度图像,实现效果如下:



    展开全文
  • matlab实现灰度图像边缘检测,本代码采用roberts算子,其他算子代码方法类似!
  • 图像处理:Robert边缘检测算子

    千次阅读 2018-11-26 14:49:30
    哈哈,api学习还是有必要的,不必造轮子,不过,要有造轮子的能力,具体分的课题是边缘检测算法的Robert算子 书上只是给个函数,可以理解为伪代码,具体实现,还是要自己去动手的,书上只是给个思路而已: ...

    事情比较多比较杂,早点把学校的事弄完吧,好久没写博客了,最近计算机前沿这门课,老师要布置课题,大部分是Verilog HDL程序设计,脑壳疼,硬件太烦,在这里插入图片描述
    不过还好,可以选择其他方向的
    在这里插入图片描述

    哈哈,api学习还是有必要的,不必造轮子,不过,要有造轮子的能力,具体分的课题是边缘检测算法的Robert算子
    在这里插入图片描述
    书上只是给个函数,可以理解为伪代码,具体实现,还是要自己去动手的,书上只是给个思路而已:
    在这里插入图片描述

    核心就是对像素的处理,获取位图像素位,处理像素位,设置像素位,就这么几部,当初想,多么简单啊,其实还是不能大意,遇到一些问题,然后慢慢克服,最终解决难题,只有这样,才能不断成长,绝对不能眼高手低
    主要遇到的问题,就是获得位图的像素位

    一开始,我以为BITMAP结构的bmBits就是存放像素位的,结果运行有问题
    在这里插入图片描述
    还以为是我自己没有新加载一个位图,在新位图里存放新像素位,结果还是不行,调试时发现BITMAP的bmBits始终为0
    在这里插入图片描述
    所以问题出在这,我们并没有真正获取到位图的像素位,要获取位图的像素位,可以用GetBitmapBits函数,函数怎么用去查msdn或者百度
    相应的设置像素位用SetBitmapBits,下面就是Robert算子具体实现的核心代码了
    在这里插入图片描述

    最后实现效果:
    在这里插入图片描述
    在这里插入图片描述
    好了,大功告成,一定要注意,获取设置位图像素位,用BITMAP的bmBits成员是不行的,用GetBitmapBits和SetBitmapBits即可
    最后附上完整win32 API代码:

    //VC++图像处理程序
    //图像的边缘检测-Robert算子
    # include<windows.h>
    # include<cmath>
    
    
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);//窗口过程函数
    void RobertOperator(HDC hdc, HDC hMemDc, HBITMAP hBitmap, int Width, int Height);
    int WINAPI WinMain(HINSTANCE hInstance,
    	HINSTANCE hPrevInstance,
    	PSTR szCmdLine,
    	int iCmdShow) 
    {
    	TCHAR szAppName[] = TEXT("Robert算子");
    
    	//设计窗口类
    	WNDCLASS wndclass;//窗口类
    	wndclass.cbClsExtra = 0;
    	wndclass.cbWndExtra = 0;
    	wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);//窗口背景画刷(白色)
    	wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    	wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    	wndclass.hInstance = NULL;
    	wndclass.lpfnWndProc = WndProc;
    	wndclass.lpszClassName = szAppName;//类名
    	wndclass.lpszMenuName = NULL;
    	wndclass.style = CS_HREDRAW | CS_VREDRAW;
    
    	//注册窗口类
    	if (!RegisterClass(&wndclass))
    	{
    		MessageBox(NULL, TEXT("Program requires windows NT!"), szAppName, MB_ICONERROR);
    		return 0;
    	}
    
    	//创建窗口
    	HWND hwnd = CreateWindow(szAppName,
    		TEXT("Robert算子"),
    		WS_OVERLAPPEDWINDOW,
    		CW_USEDEFAULT,
    		CW_USEDEFAULT,
    	    540,
    		630,
    		NULL,
    		NULL,
    		hInstance,
    		NULL);
    
    	ShowWindow(hwnd, SW_SHOW);
    	UpdateWindow(hwnd);
    
    	MSG msg;//消息循环
    	while (GetMessage(&msg, NULL, 0, 0))
    	{
    		TranslateMessage(&msg);
    		DispatchMessage(&msg);
    	}
    	
    
    	return 0;
    }
    
    LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
    	static HDC hMemDc;
    	static int xWidth, yHeight;
    	static BITMAP bm;
    	static HBITMAP hBitmap;
    
    	switch (uMsg)
    	{
    	case WM_CREATE:
    	{
    		//原位图
    		 hBitmap= (HBITMAP)LoadImage(NULL, TEXT("Picture2.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
    		if (hBitmap == NULL)
    		{
    			MessageBox(NULL, TEXT("读取图片失败"), TEXT("Error"), MB_ICONERROR);
    			return 0;
    		}
    
    		//将原位图选进内存DC
    		HDC hdc = GetDC(hwnd);
    		hMemDc = CreateCompatibleDC(hdc);//内存DC
    		SelectObject(hMemDc, hBitmap);
    		ReleaseDC(hwnd, hdc);
    
    		//计算位图的宽和高
    		GetObject(hBitmap, sizeof(bm), &bm);
    		xWidth = bm.bmWidth;
    		yHeight = bm.bmHeight;
    		return 0;
    	}
    	case WM_PAINT:
    	{
    		HDC hdc;
    		PAINTSTRUCT ps;
    		hdc = BeginPaint(hwnd, &ps);
    		BitBlt(hdc, 0, 0, xWidth, yHeight, hMemDc, 0, 0, SRCCOPY);
    		//BitBlt(hdc, 0, 300, xTempWidth, yTempHeight, hTempMemDc, 0, 0, SRCCOPY);
    		RobertOperator(hdc, hMemDc,hBitmap,xWidth, yHeight);
    		//BitBlt(hdc, 590, 0, xWidth, yHeight, hMemDc, 0, 0, SRCCOPY);
    		EndPaint(hwnd, &ps);
    		return 0;
    	}
    	case WM_CLOSE:
    		DeleteDC(hMemDc);
    		PostQuitMessage(0);
    		//DestroyWindow(hwnd);
    		return 0;
    	}
    
    
    	return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    
    void RobertOperator(HDC hdc, HDC hMemDc,HBITMAP hBitmap,int Width, int Height)
    {
    	
    
    	int Robert_Pixel[4];//Robert算子
    	
    	
    	BYTE *pTempPixel = new BYTE[16*Width*Height];
    	//得到位图的像素位
    	GetBitmapBits(hBitmap,16*Width*Height,(LPVOID)pTempPixel);
    	
    	BYTE *pPixel = new BYTE[16*Width*Height];
    	for(int j=0;j<4*Height-1;j++)
    		for (int i = 0; i < 4*Width - 1; i++)
    		{
    			//生成Robert算子
    			Robert_Pixel[0] = pTempPixel[j*4*Width+i];
    			Robert_Pixel[1] = pTempPixel[j*4*Width+ i + 1];
    			Robert_Pixel[2] = pTempPixel[(j + 1)*4*Width+ i];
    			Robert_Pixel[3] = pTempPixel[(j + 1)*4*Width+i + 1];
    
    			//生成当前像素
    			pPixel[j*4*Width+i] = (int)sqrt((Robert_Pixel[0] - Robert_Pixel[3])*
    				(Robert_Pixel[0] - Robert_Pixel[3]) + (Robert_Pixel[1] - Robert_Pixel[2])*
    				(Robert_Pixel[1] - Robert_Pixel[2]));
    			//pPixel[j*Width + i] = pTempPixel[j*Width + i] + 100;
    
    		}
    	//设置新像素位
    	SetBitmapBits(hBitmap,16* Width*Height,pPixel);
    	BitBlt(hdc,0, 300, Width, Height, hMemDc, 0, 0, SRCCOPY);
    
    }
    

    注意相应的位图文件要放在工程目录下,以及位图的文件名

    展开全文
  • 图像边缘检测:Sobel、拉普拉斯算子

    热门讨论 2012-08-04 13:49:11
    图像边缘检测算法。 参考博客:http://blog.csdn.net/xiaowei_cqu/article/details/7829481
  •   这次我们学习一下计算机视觉的边缘检测算子,主要介绍Robert、Sobel、Canny算子的python实现。   1、Canny算法,主要有以下步骤:   (1)灰度化(通常灰度化采用的公式是:Gray=0.299R+0.587G+0.114B;)   ...

      这次我们学习一下计算机视觉的边缘检测算子,主要介绍Robert、Sobel、Canny算子的python实现。
      1、Canny算法,主要有以下步骤:
      (1)灰度化(通常灰度化采用的公式是:Gray=0.299R+0.587G+0.114B;)
      (2)高斯滤波
      (3)计算图像的梯度和梯度方向,(本文使用Sobel算子)
      (4)非极大值抑制(上一步得到的边缘较粗,这里会细化边缘)
      (5)双阈值筛选边缘(二值化显示)

    // Canny算子实现
    import numpy as np
    import cv2
    import math
    
    
    def Canny(img,threshold1,threshold2):
        #step1:高斯滤波
        gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
        new_gray=cv2.GaussianBlur(gray,(5,5),1)
    
        #展示高斯滤波后的图片
        # gaus_result=new_gray.copy()
        gaus_result=np.uint8(np.copy(new_gray))
        cv2.imshow('gaus',gaus_result)
        # cv2.waitKey(0)
    
        #step2:求梯度值及梯度方向
        H1,W1=new_gray.shape
        print(new_gray.shape)
        dx=np.zeros([H1-1,W1-1])
        dy=np.zeros([W1-1,W1-1])
        #求出的图像值
        d=np.zeros([H1-1,W1-1])
        #梯度方向
        dgree=np.zeros([H1-1,W1-1])
        for i in range(1,H1-1):
            for j in range(1,W1-1):
                #dx水平方向
                dx[i,j]=new_gray[i-1,j-1]+2*new_gray[i,j-1]+new_gray[i+1,j-1]-\
                        new_gray[i-1,j+1]-2*new_gray[i,j+1]-new_gray[i+1,j+1]
                #dy垂直方向
                dy[i,j]=new_gray[i-1,j-1]+2*new_gray[i-1,j]+new_gray[i-1,j+1]-\
                        new_gray[i+1,j-1]-2*new_gray[i+1,j]-new_gray[i+1,j+1]
                #G=sqrt(Gx**2+Gy**2)
                d[i,j]=np.sqrt(np.square(dx[i,j])+np.square(dy[i,j]))
                #math.atan2求出弧度,math.degrees转为角度
                dgree[i,j]=math.degrees(math.atan2(dy[i,j],dx[i,j]))
                if dgree[i,j]<0:
                    dgree+=360
    
        #
        d_show=np.uint8(np.copy(d))
        cv2.imshow('d_show',d_show)
    
        #非极大值抑制
        H2, W2=d.shape
        NMS=np.uint8(np.copy(d))
        NMS[0,:]=NMS[W2-1,:]=NMS[:,0]=NMS[:,H2-1]=0
        for i in range(1,H2-1):
            for j in range(1,W2-1):
                if d[i,j]==0:
                    NMS[i,j]=0
                else:
                    g1=None
                    g2=None
                    #也可以使用插值方法,此处为设定角度计算
                    #0度水平方向
                    if (dgree[i,j]<=22.5 and dgree[i,j]>=0) or (dgree[i,j]>=337.5):
                        g1=NMS[i,j-1]
                        g2=NMS[i,j+1]
                    #45度方向
                    elif (dgree[i,j]<=67.5 and dgree[i,j]>22.5) or (dgree[i,j]<=337.5 and dgree[i,j]>292.5):
                        g1=NMS[i-1,j+1]
                        g2=NMS[i+1,j-1]
                    #90度方向
                    elif (dgree[i,j]<=112.5 and dgree[i,j]>67.5) or (dgree[i,j]<=292.5 and dgree[i,j]>247.5):
                        g1=NMS[i-1,j]
                        g2=NMS[i+1,j]
                    #135度方向
                    elif (dgree[i,j]<=157.5 and dgree[i,j]>112.5) or (dgree[i,j]<=247.5 and dgree[i,j]>202.5):
                        g1=NMS[i-1,j-1]
                        g2=NMS[i+1,j+1]
                    #180度方向
                    else:
                        g1=NMS[i,j-1]
                        g2=NMS[i,j+1]
                    #如果当前值小于梯度方向上的任一值,则NMS[i,j]=0,否则保留原值
                    if NMS[i,j]<g1 or NMS[i,j]<g2:
                        NMS[i,j]=0
    
        cv2.imshow('NMS_show',NMS)
    
        #双阈值算法检测,连接边缘
        H3,W3=NMS.shape
        DT=np.zeros([H3,W3])
        #定义高低阈值
        TL=min(threshold1,threshold2)
        TH=max(threshold1,threshold2)
    
        for i in range(1,H3-1):
            for j in range(1,W3-1):
                #小于TL的值设置为0
                if (NMS[i,j]<TL):
                    DT[i,j]=0
                #大于TH的值设置为255,即边缘
                elif (NMS[i,j]>TH):
                    DT[i,j]=255
                #对于在TL~TH之间的数,如果相邻点大于TH,即和边缘值有连接,则也为边缘值,设置为255
                else:
                    if NMS[i-1,j]>TH or NMS[i-1,j-1]>TH or NMS[i-1,j+1]>TH or NMS[i,j-1]>TH \
                        or NMS[i,j+1]>TH or NMS[i+1,j]>TH or NMS[i+1,j-1]>TH or NMS[i+1,j+1]>TH:
                        DT[i,j]=255
    
        return DT
    
    img=cv2.imread('data/lena.png')
    cv2.imshow('orginal_img',img)
    canny_img=Canny(img,50,140)
    cv2.imshow('canny_img',canny_img)
    cv2.waitKey(0)
    
    
    
    #OpenCV实现Canny算子
    # import cv2
    #
    # img=cv2.imread('data/lena.png')
    # canny_img=cv2.Canny(img,150,200)
    # cv2.imshow('canny_img',canny_img)
    # cv2.waitKey(0)
    

    以经典图片为例,原图如下
    在这里插入图片描述
    step1:高斯滤波
    在这里插入图片描述step2:sobel算子得到边缘在这里插入图片描述
    step3:非极大值抑制(上一步得到的边缘较粗,这里会细化边缘)
    在这里插入图片描述
    step4:双阈值筛选边缘(二值化显示),输出Canny结果。
    在这里插入图片描述
    2、Robert算子
    原理可以参考文章:https://blog.csdn.net/u013007900/article/details/78301951
    代码实现入下。

    // Robert算子
    import cv2
    
    
    #robert算子[[-1,-1],[1,]]
    def robert(img):
        h,w=img.shape[:2]
        r=[[-1,-1],[1,1]]
        for i in range(h):
            for j in range(w):
                if (j+2<w) and (i+2<=h):
                    process_img=img[i:i+2,j:j+2]
                    list_robert=r*process_img
                    img[i,j]=abs(list_robert.sum())
    
        return img
    
    img=cv2.imread('data/lena.png',cv2.IMREAD_GRAYSCALE)
    cv2.imshow('orl_img',img)
    img=robert(img)
    cv2.imshow('robert',img)
    cv2.waitKey(0)
    

    原图
    在这里插入图片描述
    Robert结果
    在这里插入图片描述
    3、Sobel算子
    原理参考:边缘检测:Canny算子,Sobel算子
    代码实现

    // Sobel算子
    import cv2
    import numpy as np
    
    
    def sobel(img):
        h,w=img.shape
        new_img=np.zeros([h,w])
        x_img=np.zeros(img.shape)
        y_img=np.zeros(img.shape)
        sobel_x=np.array([[-1,0,1],[-2,0,2],[-1,0,1]])
        sobel_y=np.array([[-1,-2,-1],[0,0,0],[1,2,1]])
        for i in range(h-2):
            for j in range(w-2):
                x_img[i+1,j+1]=abs(np.sum(img[i:i+3,j:j+3]*sobel_x))
                y_img[i+1,j+1]=abs(np.sum(img[i:i+3,j:j+3]*sobel_y))
                new_img[i+1,j+1]=np.sqrt(np.square(x_img[i+1,j+1])+np.square(y_img[i+1,j+1]))
    
        return np.uint8(new_img)
    
    img=cv2.imread('data/lena.png',cv2.IMREAD_GRAYSCALE)
    cv2.imshow('orl_img',img)
    img=sobel(img)
    cv2.imshow('sobel',img)
    cv2.waitKey(0)
    
    

    原图灰度后
    在这里插入图片描述
    Sobel算子结果
    在这里插入图片描述

    展开全文
  • 对一副已经给出的图像进行中值滤波处理,利用罗伯特算子、索伯尔算子、canny算子、拉普拉斯算子,分别进行边缘检测。具体见说明文档。
  • 边缘检测边缘检测指的是灰度值发生急剧变化的位置,边缘检测的目的是制作一个线图,在不会损害理解图像内容的情况下, 有大大减少了图像的数据量,提供了对图像数据的合适概述。 一:Roberts算子 代码...
  • 一般来说,图像的能量主要集中在其低频部分,噪声所在的频段主要在高频段,同时图像边缘信息也主要集中在其高频部分。这将导致原始图像在平滑处理之后,图像边缘和图像轮廓模糊的情况出现。为了减少这类不利效果的...
  • 这里给出了4种经典的边缘检测算子在matlab中的算法实现,可运行
  • 实现思路:1,将传进来的图片矩阵用算子进行卷积求和(卷积和取绝对值)2,新的矩阵(与原图一样大小)去接收每次的卷积和的值3,卷积图片所有的像素点后,把新的矩阵数据类型转化为uint8注意:必须对求得的卷积和的值...
  • Roberts算子边缘检测原理及实现

    万次阅读 多人点赞 2019-06-10 17:31:41
    Robert算子是一种一阶微分算子,而且Robert算子是第一个边缘检测算子,提出者是Lawrence Roberts in 1963。 从这篇博客开始,会陆续介绍几种经典的边缘检测算子。先附上各种边缘检测算法的优缺点: 原理 ...
  • 图象处理中的边缘检测------canny算子

    千次阅读 2019-02-21 20:06:10
    图象处理中的边缘检测------canny算子
  • 不同图像灰度不同,边界处一般会有明显的边缘,利用此特征可以分割图像。需要说明的是:边缘和物体间的边界并不等同,边缘指的是图像中像素的值有突变的地方,而物体间的边界指的是现实场景中的存在于物体之间的边界...
  • Canny算子边缘检测

    万次阅读 2014-11-07 09:52:53
    回顾一下Canny算子的基本原理:总的来说,图像边缘检测必须满足两个步骤 (1)有效的抑制噪声,使用高斯算子图像进行平滑; (2)尽量精确的确定边缘的位置; Canny算子边缘检测可以分为三个步骤: Step 1...
  • 边缘检测之Robert算子

    万次阅读 2017-10-21 10:51:57
    算子边缘检测的作用是提供边缘候选点,Robert算子相比于其他3x3算子,在不经过后处理时,可以给出相对较细的边缘算子介绍以下坐标新采用的是i,ji, j坐标系,其中i=−y,j=xi = -y, j = x。Robert算子的形式是Gi≅...
  • Robert算子、sobel算子、Prewitt算子、canny边缘检测算子 之前做的笔记,懒得再敲一遍了,先传上来,方便自己以后加深记忆
  • 【Matlab图像边缘检测】Sobel+Prewitt+Robert算子图像边缘检测【含GUI源码 203期】 二、matlab版本及参考文献 1 matlab版本 2014a 2 参考文献 [1] 蔡利梅.MATLAB图像处理——理论、算法与实例分析[M].清华大学出版社...
  • 罗伯特梯度法(Robert Gradient), 是一种交叉差分方法。其数学表达式可近似为: G[f(x, y)] ≈|f(i, j)-f(i+1, j+1) |+|f(i+1, j)-f(i, j+1)| ################################################ # Robert算子 #...
  • 假设某像素与其8领域如下矩阵表示: 那么,根据图像梯度的定义: gx = z8 - z5 gy = z6 - z5 上面提到,这种原始定义的梯度只是这种灰度值变化情况的度量工具,这种度量工具只有这一种吗?显然不是的! z9-z5算...
  • Roberts算子图像噪声具有较高的敏感性。有两种形式:加粗部分为锚点位置。 当需要反映45°、135°对角线方向变化率: 反映垂直和水平方向边缘
  • 图像处理中,一阶导数是梯度幅度实现的,图像的梯度定义为二维列向量 ∇f≡grad(f)=[gxgy]=[∂f/∂x∂f/∂y ](3.57)\nabla f \equiv \text{grad}(f) = \begin{bmatrix} g_x \\ g_y \end{bmat
  • 图像边缘检测——Roberts交叉算子

    千次阅读 2013-11-25 21:05:32
    经典图像边缘检测(微分法思想)——Roberts交叉算子 如果我们沿如下图方向角度求其交叉方向的偏导数,则得到Roberts于1963年提出的交叉算子边缘检测方法。该方法最大优点是计算量小,速度快。但该方法由于是采用...
  • 自己实现Roberts算子边缘检测

    千次阅读 2016-09-26 16:11:17
    自己实现Roberts算子的代码 ---------------- #include #include using namespace std; using namespace cv; void Roberts(Mat &src,Mat &dst); void Roberts(Mat &src,Mat &dst) { dst=src.clone(); int nWidth ...
  • matlab图像边缘检测

    2021-12-06 01:08:46
    1、对图像分别用罗伯特交叉算子、蒲瑞维特算子和索贝尔算子进行边缘检测使用1范数和无穷范数计算各算子的输出值 clear;clc; % 输入1、2、3选择不同算子,具体顺序如下 x = input('please input a number:'); % ...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 268
精华内容 107
关键字:

用罗伯特算子检测图像的边缘