图像处理 提取边界_图像处理为什么提取的边界不闭合,是断续的 - CSDN
精华内容
参与话题
  • 图像处理中二值图像边界提取

    千次阅读 2018-05-02 16:58:31
    今天下午要完成一部分实验,中间涉及到二值边界提取,去百度了一下。根据自己实验的结果表明,方法确实是好用,关键自己之前写过,但是效果不如网上的好!需要在别人的基础上结合自己的需要或者自己已有的结果具体...

    今天下午要完成一部分实验,中间涉及到二值边界的提取,去百度了一下。根据自己实验的结果表明,方法确实是好用,关键自己之前写过,但是效果不如网上的好!

    需要在别人的基础上结合自己的需要或者自己已有的结果具体问题具体分析。本来想直接copy一下,结果人家的是.png,而自己是已知图像中的一些数据,所以直接将我得类别标签图转化为二值图,然后按照网上的思路写就可以了,我参考的是:https://www.cnblogs.com/tiandsp/archive/2013/04/26/3045747.html

    %%%一下是matlab代码

    %%%TureFlag是我的类别标签图,本来有7类地物,二值化一下就可以。所以如果你的也不是二值图,你可以将图像二值化再做


    function [TrueFlag]=BoundaryJudge(Image,TrueFlag)

    [m,n]=size(TrueFlag);
    imgn=zeros(m,n);
    ed=[-1 -1;0 -1;1 -1;1 0;1 1;0 1;-1 1;-1 0];
    for i=2:m-1
        for j=2:n-1
            if TrueFlag(i,j)==1%如果当前像素是前景像素
                for k=1:8
                    ii=i+ed(k,1);
                    jj=j+ed(k,2);
                    if TrueFlag(ii,jj)==0%当前像素周围如果是背景,边界标记图像相应像素标记
                        imgn(ii,jj)=1;
                    end
                end
            end
        end

    end

       figure;                       %由于只有0,1,所以colormap(gray)也没关系,显示出来就是黑白图
       imagesc(imgn);
       colormap(gray);     

    end


    结果图:

    展开全文
  • 边缘提取算子 一阶:Roberts算子、Sobel算子、Prewitt算子、Kirsch算子、Robinson算子 二阶: Laplacian算子、Canny算子、Marr-Hildreth(LoG算子) Roberts 算子 在(i+1/2,j+1/2)处差分 转化为模板即为 ...

    边缘提取算子

    一阶:  Roberts算子、Sobel算子、Prewitt算子、Kirsch算子、Robinson算子

    二阶: Laplacian算子、Canny算子、Marr-Hildreth(LoG算子)

     

    Roberts 算子

    在(i+1/2,j+1/2)处差分

    转化为模板即为

    Roberts算子,又称罗伯茨算子,是一种最简单的算子,是一种利用局部差分算子寻找边缘的算子。他采用对角线方向相邻两象素之差近似梯度幅值检测边缘。检测垂直边缘的效果好于斜向边缘,定位精度高,对噪声敏感,无法抑制噪声的影响。

    Roberts算子检测方法对具有陡峭的低噪声的图像处理效果较好,但是提取边缘的结果是边缘比较粗,因此边缘的定位不是很准确。

     

    Sobel算子

    Sobel算法是一个离散的一阶差分算子,用来计算图像亮度函数的一阶梯度之近似值。在图像的任何一点使用此算子,将会产生该点对应的梯度矢量或是其法矢量。

     

    Prewitt算子

    Prewitt算子是一种一阶微分算子边缘检测,利用像素点上下、左右邻点的灰度差,在边缘处达到极值检测边缘,去掉部分伪边缘,对噪声具有平滑作用。

    其原理是在图像空间利用两个方向模板与图像进行邻域卷积来完成的,这两个方向模板一个检测水平边缘,一个检测垂直边缘。

    Prewitt算子检测方法对灰度渐变和噪声较多的图像处理效果较好。但边缘较宽,而且间断点多。

    对数字图像f(x,y),Prewitt算子的定义如下:

    G(i)={[f(i-1,j-1)+f(i-1,j)+f(i-1,j+1)]-[f(i+1,j-1)+f(i+1,j)+f(i+1,j+1)]}

    G(j)={[f(i-1,j+1)+f(i,j+1)+f(i+1,j+1)]-[f(i-1,j-1)+f(i,j-1)+f(i+1,j-1)]}

    则P(i,j)=max[G(i),G(j)]或 P(i,j)=G(i)+G(j)

     

    Kirsch算子

    Kirsch算子是R.Kirsch提出来一种边缘检测算法,它采用8个3*3的模板对图像进行卷积,这8个模板代表8个方向,并取最大值作为图像的边缘输出,8个模板如下,它在保持细节和抗噪声方面都有较好的效果。

     

     

    Robinson算子

    规则同上,也是8个模板。

     

    Laplacian算子

    Laplacian算子法对噪声比较敏感,所以很少用该算子检测边缘,而是用来判断边缘像素视为与图像的明区还是暗区。

    Laplacian 算子是n维欧几里德空间中的一个二阶微分算子,定义为梯度grad的散度div。可使用运算模板来运算这定理定律。

    函数的拉普拉斯算子也是该数的黑塞矩阵的迹,可以证明,它具有各向同性,即与坐标轴方向无关,坐标轴旋转后梯度结果不变。

    Laplacian 算子对噪声比较敏感,所以图像一般先经过平滑处理,因为平滑处理也是用模板进行的,所以,通常的分割算法都是把Laplacian 算子和平滑算子结合起来生成一个新的模板。

    如果邻域系统是4 邻域,Laplacian 算子的模板为:

    如果邻域系统是8 邻域,Laplacian 算子的模板为:

     

    Canny算子

    Canny方法不容易受噪声干扰,能够检测到真正的弱边缘。

    优点在于,使用两种不同的阈值分别检测强边缘和弱边缘,并且当弱边缘和强边缘相连时,才将弱边缘包含在输出图像中。

    该算子效果较好,但是它实现起来较为麻烦,Canny算子是一个具有滤波,增强,检测的多阶段的优化算子,在进行处理前,Canny算子先利用高斯平滑滤波器来平滑图像以除去噪声,Canny分割算法采用一阶偏导的有限差分来计算梯度幅值和方向,在处理过程中,Canny算子还将经过一个非极大值抑制的过程,最后Canny算子还采用两个阈值来连接边缘。

    Canny边缘检测算法

    step1: 用高斯滤波器平滑图象;

    step2: 用一阶偏导的有限差分来计算梯度的幅值和方向;

    step3: 对梯度幅值进行非极大值抑制

    step4: 用双阈值算法检测和连接边缘

    参考:

    https://blog.csdn.net/fengye2two/article/details/79190759

    https://blog.csdn.net/jiachen0212/article/details/80078685

    https://www.cnblogs.com/zhuifeng-mayi/p/9563947.html

    https://www.cnblogs.com/techyan1990/p/7291771.html

     

    Marr-HildrethLoG算子

    LoG可以看成是一个高斯模板的拉普拉斯变换   Laplace of Gaussian

    (图像的高斯拉普拉斯(LoG),可利用差分高斯(DoG)近似)

    参考:

    好:LOG高斯-拉普拉斯算子 https://blog.csdn.net/touch_dream/article/details/62237018 

    DoG算子和LoG算子 https://blog.csdn.net/dreamguard/article/details/83988814

    好:LoG算子 https://blog.csdn.net/songzitea/article/details/12851079

    LOG边缘检测--Marr-Hildreth边缘检测算法 https://blog.csdn.net/bettyshasha/article/details/51757185  

    好:SIFT特征点检测,特征点描述,特征点匹配理解 https://blog.csdn.net/ds0529/article/details/79617619

    matlab代码

     

    matlab自带edge函数

    matlab中edge函数提供了很多算子,函数原型和算子包括:

    matlab自带edge函数 使用代码:

    clear;clc;
    
    %读取图像
    I=imread('Lena512.png');
    %I=rgb2gray(I);
    figure;imshow(I,[]);title('Original Image');
    
    %sobel----------------------
    sobelBW = edge(I,'sobel',0.06);  %可以省去0.06,系统会默认。
    figure;imshow(sobelBW,[]);title('Sobel 0.06')
    
    %roberts----------------------
    robertsBW=edge(I,'roberts');
    figure;imshow(robertsBW);title('Roberts Edge');
    
    %prewitt----------------------
    prewittBW=edge(I,'prewitt');
    figure;imshow(prewittBW);title('Prewitt Edge');
    
    %Laplacian----------------------
    logBW=edge(I,'log');
    figure;imshow(logBW);title('Laplasian of Gaussian Edge');
    
    %canny----------------------
    cannyBW=edge(I,'canny');
    figure;imshow(cannyBW);title('Canny Edge');
    
    %高斯滤波 再 canny ----------------------
    h=fspecial('gaussian',5);%高斯滤波
    I2=imfilter(I,h,'replicate');
    GcannyBW=edge(I2,'canny');%高斯滤波后使用Canny算子进行边缘检测
    figure;imshow(GcannyBW);title('Gaussian & Canny Edge');

     

    非matlasb自带 :梯度法、roberts算子、prewitt算子、sobel算子、krisch算子、LoG算子

    %% 非matlasb自带 :梯度法、roberts算子、prewitt算子、sobel算子、krisch算子、LoG算子
    clear;clc;close all
    f=imread('Lena512.png');
    T=20;%阈值
    [m,n]=size(f);
    %------梯度法-------
    f_g=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_g(i,j)=abs(f(i+1,j)-f(i,j))+abs(f(i,j+1)-f(i,j));
            if f_g(i,j)<T
                f_g(i,j)=0;
            else
                f_g(i,j)=255;
            end
        end
    end
    figure(1);
    subplot(2,3,1);imshow(uint8(f_g));title('梯度法');
    %------roberts算子-------
    f_r=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_r(i,j)=abs(f(i+1,j+1)-f(i,j))+abs(f(i,j+1)-f(i+1,j));
            if f_r(i,j)<T
                f_r(i,j)=0;
            else
                f_r(i,j)=255;
            end
        end
    end
    %f_r=imbinarize(imfilter(f,r),T);
    subplot(2,3,2);imshow(uint8(f_r));title('Roberts算子');
     
    %------prewitt算子-------
    f_p=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_p(i,j)=abs(f(i-1,j-1)+f(i,j-1)+f(i+1,j-1)-f(i-1,j+1)-f(i,j+1)-f(i+1,j+1))+abs(f(i+1,j-1)+f(i+1,j)+f(i+1,j+1)-f(i-1,j-1)-f(i-1,j)-f(i-1,j+1));
            if f_p(i,j)<15
                f_p(i,j)=0;
            else
                f_p(i,j)=255;
            end
        end
    end
    subplot(2,3,3);imshow(uint8(f_p));title('Prewitt算子');
     
    %------sobel算子-------
    f_s=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_s(i,j)=abs(f(i-1,j-1)+2*f(i,j-1)+f(i+1,j-1)-f(i-1,j+1)-2*f(i,j+1)-f(i+1,j+1))+abs(f(i+1,j-1)+2*f(i+1,j)+f(i+1,j+1)-f(i-1,j-1)-2*f(i-1,j)-f(i-1,j+1));
            if f_s(i,j)<T
                f_s(i,j)=0;
            else
                f_s(i,j)=255;
            end
        end
    end
    subplot(2,3,4);imshow(uint8(f_s));title('Sobel算子');
     
    %------krisch算子-------
    k(:,:,1)=[-3,-3,-3;
        -3,0,5;
        -3,5,5];
    k(:,:,2)=[-3,-3,5;
        -3,0,5;
        -3,-3,5];
    k(:,:,3)=[-3,5,5;
        -3,0,5;
        -3,-3,-3];
    k(:,:,4)=[-3,-3,-3;
        -3,0,-3;
        5,5,5];
    k(:,:,5)=[5,5,5;
        -3,0,-3;
        -3,-3,-3];
    k(:,:,6)=[-3,-3,-3;
        5,0,-3;
        5,5,-3];
    k(:,:,7)=[5,-3,-3;
        5,0,-3;
        5,-3,-3];
    k(:,:,8)=[5,5,-3;
        5,0,-3;
        -3,-3,-3];
    kk=zeros(size(f));
    I=double(f);
    for i=1:8
        f_k(:,:,i)=conv2(I,k(:,:,i),'same');
        kk=max(kk,f_k(:,:,i));
    end
    f_kk=imbinarize(kk,600);
    subplot(2,3,5);imshow(f_kk);title('Krisch算子');
     
    %------LoG算子-------
    log1=[0 0 -1 0 0;
        0 -1 -2 -1 0;
        -1 -2 16 -2 -1;
        0 -1 -2 -1 0;
        0 0 -1 0 0];
     
    f_l=conv2(f,log1,'same');
    f_ll=imbinarize(abs(f_l),300);
    subplot(2,3,6);imshow(f_ll);title('LoG算子');

     

    非matlab自带   Kirsch算子

    (参考https://blog.csdn.net/u014485485/article/details/78339420

    clear;clc;close all
    
    %读取图像
    bw1=imread('Lena512.png');
    %bw1=rgb2gray(bw1);
    figure;imshow(bw1,[]);title('Original Image');
    
    %均值滤波
    bw2=filter2(fspecial('average',3),bw1);
    %高斯滤波
    bw3=filter2(fspecial('gaussian'),bw2);
    %利用小波变换对图象进行降噪处理
    [thr,sorh,keepapp]=ddencmp('den','wv',bw3);     %获得除噪的缺省参数
    bw4=wdencmp('gbl',bw3,'sym4',2,thr,sorh,keepapp);%图象进行降噪处理
    
    %提取图象边缘
    t=[0.8 1.0 1.5 2.0 2.5].*10^5 ;     %设定阈值
    bw5=double(bw4);            
    [m,n]=size(bw5);             
    g=zeros(m,n); 
    d=zeros(1,8);
    %利用Kirsch算子进行边缘提取
    for i=2:m-1
       for j=2:n-1
           d(1) =(5*bw5(i-1,j-1)+5*bw5(i-1,j)+5*bw5(i-1,j+1)-3*bw5(i,j-1)-3*bw5(i,j+1)-3*bw5(i+1,j-1)-3*bw5(i+1,j)-3*bw5(i+1,j+1))^2; 
           d(2) =((-3)*bw5(i-1,j-1)+5*bw5(i-1,j)+5*bw5(i-1,j+1)-3*bw5(i,j-1)+5*bw5(i,j+1)-3*bw5(i+1,j-1)-3*bw5(i+1,j)-3*bw5(i+1,j+1))^2; 
           d(3) =((-3)*bw5(i-1,j-1)-3*bw5(i-1,j)+5*bw5(i-1,j+1)-3*bw5(i,j-1)+5*bw5(i,j+1)-3*bw5(i+1,j-1)-3*bw5(i+1,j)+5*bw5(i+1,j+1))^2; 
           d(4) =((-3)*bw5(i-1,j-1)-3*bw5(i-1,j)-3*bw5(i-1,j+1)-3*bw5(i,j-1)+5*bw5(i,j+1)-3*bw5(i+1,j-1)+5*bw5(i+1,j)+5*bw5(i+1,j+1))^2; 
           d(5) =((-3)*bw5(i-1,j-1)-3*bw5(i-1,j)-3*bw5(i-1,j+1)-3*bw5(i,j-1)-3*bw5(i,j+1)+5*bw5(i+1,j-1)+5*bw5(i+1,j)+5*bw5(i+1,j+1))^2; 
           d(6) =((-3)*bw5(i-1,j-1)-3*bw5(i-1,j)-3*bw5(i-1,j+1)+5*bw5(i,j-1)-3*bw5(i,j+1)+5*bw5(i+1,j-1)+5*bw5(i+1,j)-3*bw5(i+1,j+1))^2; 
           d(7) =(5*bw5(i-1,j-1)-3*bw5(i-1,j)-3*bw5(i-1,j+1)+5*bw5(i,j-1)-3*bw5(i,j+1)+5*bw5(i+1,j-1)-3*bw5(i+1,j)-3*bw5(i+1,j+1))^2; 
           d(8) =(5*bw5(i-1,j-1)+5*bw5(i-1,j)-3*bw5(i-1,j+1)+5*bw5(i,j-1)-3*bw5(i,j+1)-3*bw5(i+1,j-1)-3*bw5(i+1,j)-3*bw5(i+1,j+1))^2;      
           g(i,j) = max(d);
        end
    end 
    
    %显示边缘提取后的图象
    figure(2)
    for k=1:5
        for i=1:m
            for j=1:n
                if g(i,j)>t(k)
                    bw5(i,j)=255;           
                else
                    bw5(i,j)=0;
                end
            end
        end
        subplot(1,5,k)
        imshow(bw5,[])
        title(['Kirsch' '   ' num2str(t(k))])
    end

    最后我之前自己写的梯度法:

    I=imread('1.jpg');
    I=rgb2gray(I);
    T=10;%阈值
    [x,y]=gradient(double(I));   %获取梯度
    t=sqrt(x.^2+y.^2);  
    I(t>=T)=255;           %梯度提取边缘 画黑
    I(t<T)=0;
    I=uint8(I);
    imshow(I);
    
    imwrite(I,'my开方梯度.jpg');  %保存图像到当前目录

    本人水平有限,难免有错误疏漏,还望大佬多多批评指正。

    展开全文
  • MATLAB图像处理之图像边缘提取

    万次阅读 2018-10-02 23:06:53
    MATLAB中有几种算法可以对图像进行边缘提取,其中一种就是edge算法,这个edge算法中有好几个算子,每一个算子分别对应着一种边缘提取的原理,接下来就来看一下几种方法的异同 %读取一张图片,并显示 original_...

    MATLAB中有几种算法可以对图像进行边缘提取,其中一种就是edge算法,这个edge算法中有好几个算子,每一个算子分别对应着一种边缘提取的原理,接下来就来看一下几种方法的异同

    %读取一张图片,并显示
    original_picture=imread('D:\SoftWare\matlab2016a\Project\Picture\cat.jpg');
    Pic2=im2bw(original_picture,thresh);
    figure(1)
    subplot(2,2,1);
    imshow(original_picture);
    title('原始RGB图像')
    subplot(222)
    imshow(Pic2)
    title('二值化图像')
    
    %用edge算法对二值化图像进行边缘提取
    PicEdge1=edge(Pic2,'log');
    subplot(223);
    imshow(PicEdge1);
    title('log算子')
    
    PicEdge2 = edge(Pic2,'canny');
    subplot(224);
    imshow(PicEdge2);
    title('canny算子');
    
    PicEdge3=edge(Pic2,'sobel');
    figure(2)
    subplot(221)
    imshow(PicEdge3);
    title('sobel算子')
    
    PicEdge4=edge(Pic2,'prewitt');
    subplot(222)
    imshow(PicEdge4);
    title('sprewitt算子')
    
    PicEdge5=edge(Pic2,'zerocross');
    subplot(223)
    imshow(PicEdge5);
    title('zerocross算子')
    
    PicEdge6=edge(Pic2,'roberts');
    subplot(224)
    imshow(PicEdge6);
    title('roberts算子')
    
    



    虽然我们从提取的结果来看,可能他们的差别不是很明显,但是这几个算子的基本原理还是有区别的,另外由于我采用的原始图片可能图中的猫和背景颜色有的部分很相似,所以会导致有些猫的边缘没有被提取出来,以后还需改善。

    展开全文
  • 形态学图像处理边界提取与跟踪

    千次阅读 2019-08-11 22:07:58
    要在二值图像提取物体的边界,容易想到的一个方法是将所有物体内部的点删除(置为背景色)。具体地说,可以逐行扫描图像,如果发现一个黑点的8个邻域都是黑点,则该点为内部点,在目标图 像中将它删除。实际上这...

    边界提取

            要在二值图像中提取物体的边界,容易想到的一个方法是将所有物体内部的点删除(置为背景色)。具体地说,可以逐行扫描图像,如果发现一个黑点的8个邻域都是黑点,则该点为内部点,在目标图 像中将它删除。实际上这相当于采用一个3*3的结构元素对原图进行腐蚀,使得只有那些8个邻域都有黑点的内部点被保留,再用原图像减去腐蚀后的图像,恰好删除了这些内部点,留下了边界像素。这过程如下图所示。
    在这里插入图片描述

    示例演示

            利用OpenCV实现上面边界提取的功能。

    #include<opencv2/opencv.hpp>
    using namespace cv;
    
    int main(int argc, char *argv[])
    {
       Mat originimage = imread("E:/TestData/head_portrait.bmp");
       Mat element = getStructuringElement(MORPH_RECT, Size(3, 3));
       imshow("OriginImage", originimage);
       Mat erodeimage;
       cv::erode(originimage, erodeimage, element);
       imshow("ErodeImage", erodeimage);
    
       Mat output = originimage -  erodeimage;
       imshow("Output", output);
    
    
        waitKey(0);
        return 0;
    
    }
    

    运行结果

    在这里插入图片描述

    边界跟踪

            为了依次记录边界上的每个像素,边界跟踪首先按照某种扫描规则找到目标物体边界上的一个像素,然后就以该像素为起始点,根据某种顺序(如顺时针或逆时针)依次找出物体边界上的其余像素,直到又回到起始点,完成整条边界的跟踪。
    例如,我们可以按照从左到右、从上到下的顺序扫描图像,这样首先会找到目标物体最左上方的边界点P0.显然,这个点的左侧及上侧都不可能存在边界点(否则左侧或上侧的边界点就会称为第一个被扫描到的边界点),因此不妨从左下方逆时针开始探查,如左下方的点是黑点,直接跟踪至此边界点,否则探查方向逆时针旋转45度,直至找到第一个黑点为止,跟踪至此边界点。找到边界点后,在当前探查方向的基础上顺时针回转90度,继续用上述方法搜索下一个边界点,知道探查又回到初始的边界点P0,则完成整条边界的跟踪。

    示例演示

            在一幅图像中,实现跟踪多个边界的功能。对于带孔洞的物体也可以跟踪至其孔洞的轮廓。

    #include<opencv2/opencv.hpp>
    using namespace cv;
    
    //only process binary image
    //black is boundary
    std::vector<std::vector<cv::Point>> TraceBoundary(Mat &image)
    {
        std::vector<std::vector<Point>> boundaryset;
        Point start, current, next; // start point and current point
        //search dirction array
        int direction[8][2] ={{-1, 1}, //left-down
                              {0, 1}, // down
                              {1, 1}, //right-down
                              {1, 0}, //right
                              {1, -1}, //right-up
                              {0, -1}, //up
                              {-1, -1}, //left-up
                              {-1, 0}  // left
                             };
        int begindirection = 0, currentdirection = 0;
        bool atstart = false, findboundary = false;
    
        for(int i = 0; i < image.rows; i++)
        {
            for(int j = 0; j < image.cols; j++)
            {
                if(image.at<uchar>(i, j) == 0) //find start point
                {
                    start.x = j;
                    start.y = i;
                    current = start;
                    atstart = true;
                    findboundary =  true;
                    std::vector<Point> points;
                    points.push_back(current);
                    std::cout << "Start: " << j << " " << i << std::endl;
                    while((current.x != start.x) || (current.y != start.y) || atstart)
                    {
                        atstart = false;
    
                        //search next point
                        next.x = current.x + direction[currentdirection][0];
                        next.y = current.y + direction[currentdirection][1];
                        int searchtimes = 1;
                        while(next.x < 0 || next.x >= image.cols || next.y < 0 || next.y >= image.rows || image.at<uchar>(next) == 255)
                        {
                            currentdirection++; //rotate 45 degrees counterclockwise
                            currentdirection %= 8;
                            next.x = current.x + direction[currentdirection][0];
                            next.y = current.y + direction[currentdirection][1];
                            //there are no boundary points in 8 domains, which means they are isolated points
                            if(++searchtimes >= 8)
                                break;
                        }
                        if(image.at<uchar>(next) == 0) // find next point
                        {
                            std::cout << "Next: " << next.x << " " << next.y << std::endl;
                            points.push_back(next);
                            current = next;
                            currentdirection -= 2;
                            if(currentdirection < 0)
                                currentdirection += 8;
    
                        }
                        else // not find next point
                        {
                            findboundary = false;
                            break;
                        }
                    }
                    if(findboundary)
                    {
                        boundaryset.push_back(points);
                        for(auto &p : points)
                        {
                            image.at<uchar>(p) = 255;
                        }
                    }
                } // find boundary one time
            } // for j
        } // for i
        return boundaryset;
    }
    
    int main(int argc, char *argv[])
    {
       Mat originimage = imread("E:/TestData/head_boundary.bmp");
       imshow("OriginImage", originimage);
    
       Mat image;
       cvtColor(originimage, image, CV_BGR2GRAY);
       std::vector<std::vector<Point>> boundaryset = TraceBoundary(image);
    
       //show result
       Mat result;
       originimage.copyTo(result);
       for(auto &points : boundaryset)
       {
           for(auto &p : points)
           {
                result.at<Vec3b>(p)[0]= 0;
                result.at<Vec3b>(p)[0]= 0;
                result.at<Vec3b>(p)[1]= 255;
           }
       }
       imshow("Output", result);
    
    
        waitKey(0);
        return 0;
    
    }
    

    运行结果

    在这里插入图片描述

    展开全文
  • 图像处理——边缘提取&读取图片

    千次阅读 2019-06-09 19:18:02
    使用Java对图像进行处理的初始条件是把图像的路径找到并且设置一个读取图像的输入流 public BufferedImage img2color(String imgfile){ File file = new File(imgfile); BufferedImage bi = null; //将图片...
  • matlab对图像边界提取

    热门讨论 2020-07-30 23:32:55
    matlab对图像边界提取轮廓跟踪与提取 轮廓跟踪与提取
  • 形态学一般是使用二值图像,进行边界提取,骨架提取,孔洞填充,角点提取图像重建。  基本的算法:膨胀腐蚀,开操作,闭操作,击中击不中变换  边界提取主要涉及腐蚀和求补集操作 代码如下: int ...
  • %读入图像,并转换为double型,该计算针对的是二值图像,所以加入图像时需注意 %膨胀测试图像 I=im2double(imread('D:\Gray Files\9-14.tif')); %获得图像大小 [M,N]=size(I); %存放膨胀后的图像 J=zeros(M,N); %===...
  • Linear Image Processing
  • matlab图像处理之二值图像内外边界跟踪 注:原文链接:http://www.cnblogs.com/tiandsp/archive/2013/04/26/3045747.html  目标内边界的像素全都在目标里面,目标外边界的像素全都不在目标上,是包围着目标的。 二...
  • 高光谱遥感图像处理与信息提取综述

    万次阅读 多人点赞 2017-08-09 10:08:30
    高光谱遥感图像处理与信息提取综述   高光谱遥感是对地观测的重要手段,高光谱图像处理与信息提取技术则是高光谱遥感领域的核心研究内容之一。高光谱图像处理与信息提取技术的研究主要包括数据降维、图像分类、...
  • 基于Python 的简单栅格图像边界提取

    千次阅读 2017-05-21 12:57:34
    在GIS中,栅格属性里有关于栅格自身的信息,背景(nodata value)对于识别一张图像的边界像元尤为重要,我们目的只要把每行每列中的第一次出现不是nodata的像元和最后一...以下是部分代码提取边界像元的核心算法,其实
  • 图像处理中,边缘提取是一种基础的图像处理算法,常用于图像识别以及跟踪领域,为进一步分析和理解图像做准备,下面介绍两种不同的图像边缘检测方法。 二、边缘检测方法 本文介绍的边缘检测方法包括直接使用高斯...
  • 特征提取是计算机视觉和图像处理中的一个概念。它指的是使用计算机提取图像信息,决定每个图像的点是否属于一个图像特征。特征提取的结果是把图像上的点分为不同的子集,这些子集往往属于孤立的点、连续的曲线或者...
  • 图像处理基本算法 链码 边界跟踪

    千次阅读 2016-11-18 17:39:16
    链码在图像提取的后期即模式识别是一个很重要的特征,比如进行数字识别或者文字识别都会用到链码的特征,而链码的提取则可以借助于边界跟踪算法获取边界序列,注意是边界序列而不是边界边界很容易获取,但是要想把...
  • envi 水体边界提取

    万次阅读 2018-07-01 13:38:18
    方法1: 用水体指数提取水体,获得灰度图像 选择“Raster color slice”,结合真彩色图像,自定义水体提取分类阈值,只分为水体一类就可以 输出为shp文件 在arcgis中打开,转为线状要素 矢量编辑,提取边线 将...
  • 图像特征提取总结

    万次阅读 多人点赞 2018-10-06 17:36:09
     特征提取是计算机视觉和图像处理中的一个概念。它指的是使用计算机提取图像信息,决定每个图像的点是否属于一个图像特征。特征提取的结果是把图像上的点分为不同的子集,这些子集往往属于孤立的点、连续的曲线或者...
  • 图像处理之Matlab特征提取和表达

    万次阅读 多人点赞 2017-08-07 17:36:14
    介绍图像处理之特征提取和表达,使用bwboundaries函数获取边界,使用regionprops函数统计特征
  • 图像边界扩展

    2019-06-22 06:34:04
     对图像进行处理时,提取边界的某些目标时会出现访问越界的错误,一般这种情况有两种解决方案:1.只对不越界的像素进行访问,见数据增强之图像旋转及坐标对应(附代码);2.对图像边界进行扩展,这里对opencv中...
  • 图像特征提取

    万次阅读 多人点赞 2017-01-03 16:38:12
    严格地说, 图像特征提取属于图像分析的范畴, 是数字图像处理的高级阶段, 同时也是图像识别的开始。本文主要包括以下内容 常用的基本统计特征, 如周长、面积、均值等区域描绘子, 以及直方图和灰度共现矩阵等...
1 2 3 4 5 ... 20
收藏数 27,675
精华内容 11,070
关键字:

图像处理 提取边界