精华内容
下载资源
问答
  • 图像边缘检测算法

    2021-01-25 04:00:20
    C语言实现灰度图像的集中常用边缘检测算法,包括:梯度算子,roberts边缘检测算法,Sobel边缘检测算法,Laplace边缘检测算法和Canny边缘检测算法
  • 基于matlab的图像边缘检测算法研究和仿真 第1章绪论 1 1.1序言 1 1.2数字图像边缘检测算法的意义 1 第2章传统边缘检测方法及理论基础 2 2.1数字图像边缘检测的现状与发展 2 2.2 MATLAB和图像处理工具箱的背景知识 3 ...
  • 个人资料整理 仅限学习使用 目录 个人资料整理 仅限学习使用 个人资料整理 仅限学习使用 基于 VC的图像边缘检测算法的研究与比较 摘要 图像的边缘是图像最基本的特征它是灰度不连续的结果图像分析和理解的第 一步是...
  • 图像边缘检测算法的研究内容 3.边缘检测算子 3.1.Sobel 算子 3.2.Canny 算子 4. 基于 Matlab 的实验结果与分析 三图像边缘检测的应用 一.前言 在实际图像边缘检测问题中图像的边缘作为图像的一种基本特 征经常被...
  • 针对传统的Canny算法在处理模糊的矿井巷道图像时存在边缘提取效果较差的问题,提出了一种基于小波变换和Canny算法的矿井巷道图像边缘检测算法。该算法首先对矿井巷道原始图像做小波分解,获得低频图像和高频图像,从而...
  • 基于 matlab 的图像边缘检测算法研究和仿真 目 录 第1章绪论 1 1.1 序言 1 1.2 数字图像边缘检测算法的意义 1 第 2 章 传统边缘检测方法及理论基础 2 2.1 数字图像边缘检测的现状与发展 2 2.2 MATLAB和图像处理工具...
  • 数字图像边缘检测算法对比研究 周蕊1 , 于晓明2 (1陕西科技大学理学院陕西 西安710021; 2陕西科技大学电气与信息工程学院陕西 西安 710021) 摘要边缘检测是图像分析和模式识别的主要特征提取手段为更精确地检测噪声...
  • 为了满足计算机视觉标定与精密测量对图像边缘定位的精确度高和抗噪性强的要求,提出一种基于 Franklin 矩的亚像素级图像边缘检测算法。首先,建立亚像素边缘模型,利用各级 Franklin 矩的卷积来提取图像边缘点的细节...
  • 针对自适应蚁群优化(AACO)算法在图像边缘提取中经常出现效率低、易陷入局部极值等问题,提出一种结合生物Predator-Prey 行为的自适应蚁群图像边缘检测算法。该算法将Predator-Prey 行为与AACO 算法相结合,将蚁群...
  • 利用细胞神经网络(CNN)模型导出了一种新的彩色图像边缘检测算法。为了充分利用图像中的颜色信息, 在RGB 彩色空间中用Mahalanobis 距离来度量象素之间的差异。为了解决常规边缘提取方法输出二值结果的缺点, 采用可以...
  • PAGE 基于小波变换的图像边缘检测算法仿真实现 学 生 姓 名 XX 指 导 教 师 xxx 专 业 班 级 电子信息 学 号 00000000000 学 院 计算机与信息工程学院 二一五 年 五 月 二十 日 哈尔滨商业大学本科毕业设计论文 PAGE...
  • 基于小波空间熵的图像边缘检测算法研究,叶庆卫,武冬星,图像边缘检测对于目标图像提取有十分重要的意义,在传感器视频跟踪等领域有着广泛的应用。经典的图像边缘检测算法包括Roberts 算子�
  • C#实现图像边缘检测算法 //定义roberts算子函数 private static Bitmap robert(Bitmap a) { int w = a.Width; int h = a.Height; try { Bitmap dstBitmap = new Bitmap(w, h, System.Drawing.Imaging.Pixel...

    C#实现图像边缘检测算法

    //定义roberts算子函数
    private static Bitmap robert(Bitmap a)
    {
        int w = a.Width;
        int h = a.Height;
        try
        {
            Bitmap dstBitmap = new Bitmap(w, h, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            System.Drawing.Imaging.BitmapData srcData = a.LockBits(new Rectangle
                    (0, 0, w, h), System.Drawing.Imaging.ImageLockMode.ReadOnly,
                System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            System.Drawing.Imaging.BitmapData dstData = dstBitmap.LockBits(new Rectangle
                    (0, 0, w, h), System.Drawing.Imaging.ImageLockMode.WriteOnly,
                System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            unsafe
            {
                byte* pIn = (byte*) srcData.Scan0.ToPointer();
                byte* pOut = (byte*) dstData.Scan0.ToPointer();
                byte* p;
                int stride = srcData.Stride;
                for (int y = 0; y < h; y++)
                {
                    for (int x = 0; x < w; x++)
                    {
                        //边缘八个点像素不变
                        if (x == 0 || x == w - 1 || y == 0 || y == h - 1)
                        {
                            pOut[0] = pIn[0];
                            pOut[1] = pIn[1];
                            pOut[2] = pIn[2];
                        }
                        else
                        {
                            int r0, r5, r6, r7;
                            int g5, g6, g7, g0;
                            int b5, b6, b7, b0;
                            double vR, vG, vB;
                            //右
                            p = pIn + 3;
                            r5 = p[2];
                            g5 = p[1];
                            b5 = p[0];
                            //左下
                            p = pIn + stride - 3;
                            r6 = p[2];
                            g6 = p[1];
                            b6 = p[0];
                            //正下
                            p = pIn + stride;
                            r7 = p[2];
                            g7 = p[1];
                            b7 = p[0];
                            //中心点
                            p = pIn;
                            r0 = p[2];
                            g0 = p[1];
                            b0 = p[0];
                            vR = (double) (Math.Abs(r0 - r5) + Math.Abs(r5 - r7));
                            vG = (double) (Math.Abs(g0 - g5) + Math.Abs(g5 - g7));
                            vB = (double) (Math.Abs(b0 - b5) + Math.Abs(b5 - b7));
                            if (vR > 0)
                            {
                                vR = Math.Min(255, vR);
                            }
                            else
                            {
                                vR = Math.Max(0, vR);
                            }
    
                            if (vG > 0)
                            {
                                vG = Math.Min(255, vG);
                            }
                            else
                            {
                                vG = Math.Max(0, vG);
                            }
    
                            if (vB > 0)
                            {
                                vB = Math.Min(255, vB);
                            }
                            else
                            {
                                vB = Math.Max(0, vB);
                            }
    
                            pOut[0] = (byte) vB;
                            pOut[1] = (byte) vG;
                            pOut[2] = (byte) vR;
                        }
    
                        pIn += 3;
                        pOut += 3;
                    }
    
                    pIn += srcData.Stride - w * 3;
                    pOut += srcData.Stride - w * 3;
                }
            }
    
            a.UnlockBits(srcData);
            dstBitmap.UnlockBits(dstData);
            return dstBitmap;
        }
        catch
        {
            return null;
        }
    }
    

    希望本文所述对大家的C#程序设计有所帮助。欢迎大家加群一起交流技术。
    UE4高级开发者

    展开全文
  • 基于 MATLAB的数字图像分析与边缘检测 摘 要 图像处理是用计算机对图像进行一系列的操作 一般操作是先 将图像数字化即易于获得某种预期结果的技术其中边缘检测图像处理 中必不可少的一步采用微分算子检测边缘是最...
  • 为了提高多尺度边缘检测算法的定位精度,更好地抑制图像中的噪声和细节,将改进力场转换理论与多尺度图像边缘检测算法相结合,提出了改进力场转换理论的多尺度图像边缘检测算法。新算法计算每个尺度下图像中各像素点...
  • 图像边缘检测算法的设计和研究,邱烨,高珩,边缘检测是图像分析与识别必不可少的环节,而目前使用的传统算法大多具有抗噪性差、定位精度不高、容易出现伪边缘等缺点;多层感
  • 针对激光主动成像图像特点, 提出一种分数阶微分与Sobel算子相结合的边缘检测算法。构造小波软阈值法与非...实验结果表明, 与传统边缘检测算法相比, 该算法能够检测出更多的图像边缘细节, 且具有更好的可匹配性参数。
  • 提出了一种多方向模糊形态学彩色图像边缘检测算法,并将灰度模糊形态学推广到彩色图像。首先采用隶属度函数将彩色图像映射到模糊域;然后采用多方向模糊形态学在R、G、B三个分量上进行边缘检测;最后合成各分量的...
  • 本文主要介绍的是一种sobel图像边缘检测算法的Python及Verilog实现。 一、sobel图像边缘检测算法的Python实现 sobel图片边缘检测算法的核心就是图片的卷积操作,我们所用的是如下图所示的一个3*3的卷积核。 -1 ...

    引言

          本文是之前AI加速器项目的一个补充,即之前AI加速器中PL部分的工作。本文主要介绍的是一种sobel图像边缘检测算法的Python及Verilog实现。

    一、sobel图像边缘检测算法的Python实现

          sobel图片边缘检测算法的核心就是图片的卷积操作,我们所用的是如下图所示的一个3*3的卷积核。

    -1 0 1
    -2 0 2
    -1 0 1

          图片的卷积操作简单来说就是移位相乘然后累加运算,具体资料各位可以上网查找,关于原理方面的介绍非常多,本文不再赘述。在本文中,利用Python对lenna图做了一个简单的边缘提取操作,一是为verilog提供测试数据,二是获取结果与verilog仿真结果形成比较,以判断verilog仿真结果的效果如何。  

    • Python实现代码
    # -*- coding: utf-8 -*-
    """
    Created on Sat Aug 15 14:44:19 2020
    @author: lenovo
    """
    import matplotlib.pyplot as plt # plt 用于显示图片
    import matplotlib.image as mpimg # mpimg 用于读取图片
    #import skimage
    import tensorflow as tf
    #import numpy as np
    # 有符号数转十六进制补码,返回值为字符串
    def int_to_hex(num):
        if(num < 0):
            result = hex(num & 0xff)
        else:
            result = hex(num)
        return result
    
    image = mpimg.imread('lenna.jpg') # 读取lenna图
    #image = skimage.transform.resize(image, (64,64)) # 减小像素
    #image = (image * 255).astype(np.uint8)# 限定数据范围为 0 - 255
    '''
    #写入图片数据到txt文件中供verilog仿真使用 512*512=262144
    for i in range(512):
        for j in range(512):
            fp = open('lenna.txt',mode='a')# 追加模式
            fp.write(int_to_hex(image[i][j])[2:4]+"\n")
    fp.close()# 关闭文件
    '''
    # 显示原始图片
    plt.figure(1)
    plt.imshow(image) 
    plt.title('before filter')
    plt.axis('off') # 不显示坐标轴
    
    # 转换输入图片维度
    image = tf.convert_to_tensor(image,dtype = tf.float32)
    image = tf.reshape(image,[1,512,512,1])
    
    # 创建卷积核
    filter = tf.Variable(tf.constant([[-1.0,0,1.0], [-2.0,0,2.0], [-1.0,0,1.0]],shape = [3,3,1,1],dtype = tf.float32))
    # 执行卷积
    conv = tf.nn.conv2d(image,filter, strides=[1, 1, 1, 1], padding='VALID')
    # 转换图片维度
    conv = tf.reshape(conv, shape=[510,510])
    
    # 显示滤波后图片
    plt.figure(2)
    plt.imshow(conv.numpy()) 
    plt.title('after filter')
    plt.axis('off') # 不显示坐标轴
    
    • 结果展示

    二、sobel图像边缘检测算法的Verilog实现

          本节主要介绍sobel图像边缘检测算法的Verilog实现,仿真平台采用Modelsim,由于FPGA具有并行处理能力,运行速度很快,所以在大规模图像和信号处理方面具有非常广阔的应用,受到了业界的青睐。

    • 顶层文件
    module conv (
    	//system signals
    	input		rst_n					,//复位信号
    	input		clk						,//时钟信号
    	input		start					,//卷积开始信号
    	input		wire  signed [7:0]conv_in,//卷积输入数据
    	output		reg  finish				,//卷积完成信号
    	output		reg  signed [19:0]conv_out//卷积结果数据输出
    );
    // 临时数据存储器
    wire signed  [7:0] conv_temp[0:8];
    wire signed [19:0] conv_mul[0:8];
    wire signed [19:0] conv_result;
    
    reg signed [3:0]conv_core[0:8];// 寄存3*3卷积核数据
    // 初始化卷积核[-1,0,1;-2,0,2;-1,0,1]
    always @(negedge rst_n)
    begin
      conv_core[0] <= 4'hf;//-1
      conv_core[1] <= 4'h0;//0
      conv_core[2] <= 4'h1;//1
      conv_core[3] <= 4'he;//-2
      conv_core[4] <= 4'h0;//0
      conv_core[5] <= 4'h2;//2
      conv_core[6] <= 4'hf;//-1
      conv_core[7] <= 4'h0;//0
      conv_core[8] <= 4'h1;//1
    end
    
    // 加载输入数据,输入图片维度为[64,64]
    reg 	[9:0]ini_count		;// 输入数据行计数
    reg 	[9:0]inj_count		;// 输入数据列计数
    reg     conv_cal_start      ;// 卷积计算开始信号(数据加载完成信号)
    reg  signed  [7:0]conv_iArrayData[0:511][0:511];//寄存输入数据
    always @ (posedge clk or negedge rst_n or posedge finish) begin
    	if(!rst_n || finish)begin
    		ini_count <= 10'd0;
    		inj_count <= 10'd0;
    		conv_cal_start <= 1'b0;
    	end
    	else if(start && (ini_count < 10'd512))// 启动行优先寄存数据,即一行一行地寄存输入数据
    	begin
    		if (inj_count < 10'd511) 
    			inj_count <= inj_count + 1'b1;
    		else begin if(ini_count < 10'd511)
    			begin
    				ini_count <= ini_count + 1'b1;
    				inj_count <= 10'd0;
    			end
    			else begin
    				conv_cal_start <= 1'b1;	
    			end
    		end
    		conv_iArrayData[ini_count][inj_count] <= conv_in;// 加载输入数据
    	end
    end
    
    // 执行卷积
    reg 	[9:0]convi_count		;// 卷积行计数
    reg 	[9:0]convj_count		;// 卷积列计数
    reg  signed  [19:0]conv_oArrayData[0:509][0:509];// 寄存卷积结果输出
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n)begin
    		convi_count <= 10'd0;
    		convj_count <= 10'd0;
    		finish <= 1'b0;
    	end
    	else if(conv_cal_start && (convi_count < 10'd510))// 启动行优先遍历数据,即一行一行地遍历输入数据
    	begin
    		if (convj_count < 10'd509) 
    			convj_count <= convj_count + 1'b1;
    		else begin if(convi_count < 10'd509)
    			begin
    				convi_count <= convi_count + 1'b1;
    				convj_count <= 10'd0;
    			end
    			else begin
    				finish <= 1'b1;	
    			end
    		end
    		conv_oArrayData[convi_count][convj_count] <= conv_result;// 输出
    	end	
            
    end
    
    // 卷积计算
    // 取出3*3卷积核对应位置的图片数据
    assign conv_temp[0] = conv_iArrayData[convi_count+0][convj_count+0];
    assign conv_temp[1] = conv_iArrayData[convi_count+0][convj_count+1];
    assign conv_temp[2] = conv_iArrayData[convi_count+0][convj_count+2];
    assign conv_temp[3] = conv_iArrayData[convi_count+1][convj_count+0];
    assign conv_temp[4] = conv_iArrayData[convi_count+1][convj_count+1];
    assign conv_temp[5] = conv_iArrayData[convi_count+1][convj_count+2];
    assign conv_temp[6] = conv_iArrayData[convi_count+2][convj_count+0];
    assign conv_temp[7] = conv_iArrayData[convi_count+2][convj_count+1];
    assign conv_temp[8] = conv_iArrayData[convi_count+2][convj_count+2];
    // 卷积核对应位置数据和卷积核相乘
    assign conv_mul[0] = conv_core[0]*conv_temp[0];
    assign conv_mul[1] = conv_core[1]*conv_temp[1];
    assign conv_mul[2] = conv_core[2]*conv_temp[2];
    assign conv_mul[3] = conv_core[3]*conv_temp[3];
    assign conv_mul[4] = conv_core[4]*conv_temp[4];
    assign conv_mul[5] = conv_core[5]*conv_temp[5];
    assign conv_mul[6] = conv_core[6]*conv_temp[6];
    assign conv_mul[7] = conv_core[7]*conv_temp[7];
    assign conv_mul[8] = conv_core[8]*conv_temp[8];
    // 求和累加
    assign conv_result = conv_mul[0] + conv_mul[1] + conv_mul[2] + 
                         conv_mul[3] + conv_mul[4] + conv_mul[5] + 
                         conv_mul[6] + conv_mul[7] + conv_mul[8];
    
    // 输出数据
    reg 	[9:0]outi_count		;// 卷积行计数
    reg 	[9:0]outj_count		;// 卷积列计数
    always @ (posedge clk or negedge rst_n or posedge start) begin
    	if(!rst_n || start)begin
    		outi_count <= 10'd0;
    		outj_count <= 10'd0;
    	end
    	else if(finish && (outi_count < 10'd510))begin // 启动行优先输出数据,即一行一行地输出卷积结果
        	if(outj_count < 10'd509)  
        		outj_count <= outj_count + 1'b1;
        	else begin if(outi_count < 10'd509)
        		begin 
          			outi_count <= outi_count + 1'b1; 
          			outj_count <= 10'd0; 
          		end
        	end
        conv_out <= conv_oArrayData[outi_count][outj_count];// 输出数据
      end
    end
    endmodule
    •  测试文件
    `timescale 1ns/1ps
    module conv_tb ();
    // input
    reg clk;
    reg rst_n;
    reg start;//卷积开始信号
    reg signed[7:0]conv_in;//输入数据
    
    // output
    wire finish;
    wire  signed [19:0]conv_out;//卷积结果数据输出
    
    reg [9:0] i;
    reg [9:0] j;
    reg  signed  [7:0]myimage[0:511][0:511];//寄存输入图片数据
    reg  signed [19:0]image_result[0:509][0:509];  //寄存输出图片数据
    integer out_file;//定义文件句柄
    
    // 例化模块
    conv demo(.rst_n(rst_n),
    		  .clk(clk),
    		  .start(start),
    		  .conv_in(conv_in),
    		  .finish(finish),
    		  .conv_out(conv_out));
    
    //初始化块
    initial
    begin
    	$display("step1:Load  Data");
      	$readmemh("C:/Users/lenovo/Desktop/conv_verilog/lenna.txt",myimage);
      	for(i = 0; i <= 10'd511; i = i + 1)
      		for (j = 0; j <= 10'd511 ; j = j + 1)
        		$display("%d",myimage[i][j]);
        // 时钟、复位初始化		
    	clk = 1'b0;
    	start = 1'b0;
    	rst_n = 1'b1;
    	#5 rst_n = 1'b0;
    	#5 rst_n = 1'b1;
    	   start = 1'b1;
    	// 写数据到conv模块的conv_iArrayData数组中
    	$display("step2:Write Data to conv_iArrayData");
    	for(i = 0; i <= 10'd511; i = i + 1)
      		for(j = 0; j <= 10'd511; j = j + 1)
      		begin
          		conv_in= myimage[i][j];
          		#10;
      		end
      	start = 1'b0;//完成写数据
      	//执行卷积
      	$display("step3:Convolution");
      	while(!finish) #10;
      	#10;
      	//写结果到文件
      	out_file = $fopen("C:/Users/lenovo/Desktop/conv_verilog/result.txt","w");//获取文件句柄
      	$display("step4:write result");
      	for(i = 0; i <= 10'd509; i = i + 1)
      		for(j = 0; j <= 10'd509; j = j + 1)  
      		begin
          		image_result[i][j] = conv_out;
          		#10;
      		end  
      	for(i = 0; i <= 10'd509; i = i + 1)
      		for(j = 0; j <= 10'd509; j = j + 1)begin
      			$display("%d",image_result[i][j]); 
      			$fwrite(out_file,"%d\n",$signed(image_result[i][j]));
      		end
        		
    	$display("done");
    end
    always #5 clk = ~clk;
    endmodule
    
    • 仿真波形

    verilog仿真通过后将结果输出到.txt文件中,我们在Python中进行读取验证,与Python结果进行比较。

    # -*- coding: utf-8 -*-
    """
    Created on Sun Aug 16 15:46:04 2020
    @author: lenovo
    """
    import matplotlib.pyplot as plt # plt 用于显示图片
    import numpy as np
    
    result = np.genfromtxt("result.txt", delimiter=" ")# 读入fpga处理后的结果
    result = np.reshape(result,[510,510])
    
    # 显示滤波后图片
    plt.imshow(result) 
    plt.title('after fpga')
    plt.axis('off') # 不显示坐标轴
    •    Verilog 仿真结果

         Verilog仿真结果图片与Python结果图片有些许不同,但大体一致,这种不同可能是由于Verilog在运算过程中存在量化误差而导致的,但总的来说可以接受。

     

     

    展开全文
  • 一种改进的Sobel图像边缘检测算法.pdf 一种改进的Sobel图像边缘检测算法.pdf 一种改进的Sobel图像边缘检测算法.pdf 一种改进的Sobel图像边缘检测算法.pdf 一种改进的Sobel图像边缘检测算法.pdf
  • 灰度图像边缘检测算法的matlab实现

    热门讨论 2012-05-05 23:32:44
    一个matlab编写的实用的灰度图像边缘检测算法,实时性较好,算法效果较高。
  • 针对传统边缘检测算子对噪声敏感的缺点,提出一种新的基于数学形态学的彩色图像边缘检测算法。该算法在传统形态学边缘检测算子的基础上,通过综合形态膨胀和形态腐蚀,设计出一种多尺度、多结构元素的抗噪型边缘检测...
  • 一种基于图像形态学的dicom图像边缘检测算法,论文表述了针对dicom图像进行边缘检测的一般算法,并提出了一种基于形态学的边缘检测算法
  • title: "Python实现图像边缘检测算法" date: 2018-06-12T17:06:53+08:00 tags: ["图形学"] categories: ["python"] 实现效果 代码 #!/usr/bin/env python3 # coding=utf-8 from PIL import Image import numpy ...

    title: "Python实现图像边缘检测算法"
    date: 2018-06-12T17:06:53+08:00
    tags: ["图形学"]
    categories: ["python"]


    实现效果

    5650040.jpg

    48501449.jpg

    代码

    
    #!/usr/bin/env python3
    # coding=utf-8
    from PIL import Image
    import numpy as np
    
    
    img_name = input("输入要处理的图片\n")
    # img_name = "t3.png"
    img = Image.open(img_name).convert("L")  # 读图片并转化为灰度图
    img.show()
    img_array = np.array(img)  # 转化为数组
    
    w, h = img_array.shape
    
    img_border = np.zeros((w-1, h-1))
    
    for x in range(1, w - 1):
        for y in range(1, h - 1):
            Sx = img_array[x + 1][y - 1] + 2 * img_array[x + 1][y] + img_array[x + 1][y + 1] - \
                    img_array[x - 1][y - 1] - 2 * \
                    img_array[x - 1][y] - img_array[x - 1][y + 1]
            Sy = img_array[x - 1][y + 1] + 2 * img_array[x][y + 1] + img_array[x + 1][y + 1] - \
                    img_array[x - 1][y - 1] - 2 * \
                    img_array[x][y - 1] - img_array[x + 1][y - 1]
            img_border[x][y] = (Sx * Sx + Sy * Sy) ** 0.5
    
    img2 = Image.fromarray(img_border)
    img2.show()
    

    转载于:https://www.cnblogs.com/lepeCoder/p/9174110.html

    展开全文
  • 基于小波和形态学的图像边缘检测算法研究及应用_杨小艳.caj

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,324
精华内容 1,329
关键字:

图像边缘检测算法