Sobel算子实现（完结）

已于 2023-10-30 20:07:42 修改
阅读量87 收藏
点赞数
分类专栏： 检讨书 文章标签： fpga开发 图像处理
于 2023-08-20 19:10:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NoNoUnknow/article/details/132394635
版权

1.上板前先波形仿真，又把读写地址的清零和保持写反了。

2.读地址要在取用数据的前一个时钟周期赋予RAM。

3.进行sobel运算以后像素矩阵的大小会发生改变！要调整VGA控制器里window的数值！

        size_h = [(size_origin_h - kernel_h + 1 + padding + stride) /(stride)]

        公式来自动手学深度学习！此处kernel = 3 ,size_h = 200 -3 + 1 = 198!

4.参数化设计大大减少了我的修改时间，以后所有的设计我都要参数化！

5.题外话：怎么让window里的画面也动起来呢？只要让读出RAM的深度比实际读取的数据深度更深就行了，因为后读出的数据会刷新前面读取出数据，而因为RAM深度和实际开窗需要读取的总深度不符合，就会产生移动的效果。

        ↑这是我只改了开窗参数没改RAM深度发现的。

        sobel的大于阈值部分就是我们需要凸显的部分。

        添加背景：   

        assign rgb = (set_sign)?((RD_DATA == black)?(backgroud_color):(RD_DATA))(backgroud_color);

        

module vga_ctrl #(
    parameter   H_Sync       = 96,
    parameter   H_backporch  = 40 ,
    parameter   H_left       = 8  ,
    parameter   H_data       = 640,
    parameter   H_right      = 8  ,
    parameter   H_Frontporch = 8  ,
    parameter   H_total      = H_Sync + H_backporch + H_left + H_data + H_right + H_Frontporch,
    parameter   H_width      = $clog2(H_total),
    parameter   V_Sync       = 2,
    parameter   V_backporch  = 25 ,
    parameter   V_left       = 8  ,
    parameter   V_data       = 480,
    parameter   V_right      = 8  ,
    parameter   V_Frontporch = 2  ,
    parameter   V_total      = V_Sync + V_backporch + V_left + V_data + V_right + V_Frontporch,
    parameter   V_width      = $clog2(V_total),
    // parameter   RGB_width    = 24,
    //ram
    parameter   window       = 198,
    parameter   RAM_depth    = 39204,//window^2
    parameter   RAM_depth_WIDTH = $clog2(RAM_depth),
    //color
    parameter RED   = 8'b111_000_00,
    parameter GRENN = 8'b000_111_00,
    parameter BLUE  = 8'b000_000_11
)(
    input   wire            Sys_clk      ,
    input   wire            Rst_n        ,
 // input   wire    [RGB_width-1:0]   RGB_IN      , 
    output  wire    [2:0]   red_sign     ,
    output  wire    [2:0]   grenn_sign   ,
    output  wire    [1:0]   blue_sign    ,
    output  reg             H_Sync_sign  ,
    output  reg             V_Sync_sign  ,
    output  wire    [H_width-1:0] H_addr ,
    output  wire    [V_width-1:0] V_addr ,
    //ram 
    input   wire                  WR_EN  ,
    input   wire                  WR_CLK ,//sobel_clk 50mhz
    input   wire    [7:0]         WR_data
);
    localparam white = 8'b111_111_11;
    localparam black = 8'b000_000_00;
        //  reg     [23:0]          reg_RGB;
            wire     [7:0]          rgb   ;
            reg     [H_width-1:0]   H_cnt ;
            reg     [H_width-1:0]   H_cnt_move ;
            reg                     H_full;
            reg     [V_width-1:0]   V_cnt ;
            reg     [V_width-1:0]   V_cnt_move ;
            reg                     V_full;
            wire                    Pixl_avai;
        //mov
            wire                    set_sign ;
            reg                     x_move;//移动标志位x_axis
            reg                     y_move;//移动标志位y_axis
        //ram
            reg     [RAM_depth_WIDTH-1:0]   RAM_WR_ADDR_CNT;
            reg     [RAM_depth_WIDTH-1:0]   RAM_RD_ADDR_CNT;
            wire    [7:0]                   RD_DATA;
        //background
            reg     [7:0]                   backgroud_color;
/
    //addr
    assign H_addr    =  (Pixl_avai)?(H_cnt - (H_Sync + H_backporch +  H_left)):10'd0;
    assign V_addr    =  (Pixl_avai)?(V_cnt - (V_Sync + V_backporch +  V_left)):10'd0;
    //pixl_able
    assign Pixl_avai = (H_cnt >  (H_Sync + H_backporch  + H_left  -1'b1 ))
                    && (H_cnt <= (H_total- H_Frontporch - H_right -1'b1 )) 
                    && (V_cnt >  (V_Sync + V_backporch +  V_left  -1'b1 ))
                    && (V_cnt <= (V_total- V_Frontporch - V_right -1'b1 ));
    assign {red_sign,grenn_sign,blue_sign} = (Pixl_avai) ? rgb : 8'd0;
    //Sync
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            H_Sync_sign <= 1'b1;
        end else if(H_cnt == H_total - 1'b1) begin
            H_Sync_sign <= 1'b1;
        end else if(H_cnt == H_Sync -1'b1) begin
            H_Sync_sign <= 1'b0;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            V_Sync_sign <= 1'b1;
        end else if((V_cnt == V_total - 1'b1) && (H_cnt == H_total - 1'b1)) begin
            V_Sync_sign <= 1'b1;
        end else if((V_cnt == V_Sync  - 1'b1) && (H_cnt == H_total - 1'b1)) begin
            V_Sync_sign <= 1'b0;
        end
    end
    // always@(posedge Sys_clk or negedge Rst_n) begin
    //     if(Rst_n == 0) begin
    //         reg_RGB <= 0;
    //     end else begin
    //         reg_RGB <= RGB_IN;
    //     end
    // end
//
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            backgroud_color <= white;
        end else if(V_addr >= 0 && V_addr <= 159) begin
            backgroud_color <= RED;
        end else if(V_addr >= 160 && V_addr <= 319) begin
            backgroud_color <= GRENN;
        end else if(V_addr >= 320 && V_addr <= 479) begin
            backgroud_color <= BLUE;
        end else begin
            backgroud_color <= white;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            x_move <= 0;
        end else if((H_cnt_move ==  H_data - 1'b1 -window)
                 && (V_cnt == V_total - 1'b1) 
                 && (H_cnt == H_total - 1'b1)) begin
            x_move <= 1;
        end else if((H_cnt_move ==  1)
                && (V_cnt == V_total - 1'b1) 
                && (H_cnt == H_total - 1'b1)) begin
            x_move <= 0;
        end else begin
            x_move <= x_move;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            y_move <= 0;
        end else if((V_cnt_move == V_data - 1'b1 - window)
                 && (V_cnt == V_total - 1'b1) 
                 && (H_cnt == H_total - 1'b1)) begin
            y_move <= 1;
        end else if((V_cnt_move ==  1)
                 && (V_cnt == V_total - 1'b1) 
                 && (H_cnt == H_total - 1'b1)) begin
            y_move <= 0;
        end else begin
            y_move <= y_move;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if (Rst_n == 0) begin
            H_cnt_move <= 0;
        end else if(V_full && x_move == 0) begin
            H_cnt_move <= H_cnt_move + 1'b1;
        end else if(V_full && x_move == 1) begin
             H_cnt_move <= H_cnt_move - 1'b1;
        end else begin
            H_cnt_move <= H_cnt_move;
        end
    end 
    always@(posedge Sys_clk or negedge Rst_n) begin
        if (Rst_n == 0) begin
            V_cnt_move <= 0;
        end else if(V_full && y_move == 1) begin
            V_cnt_move <= V_cnt_move - 1'b1;
        end else if(V_full && y_move == 0) begin
            V_cnt_move <= V_cnt_move + 1'b1;
        end else begin
            V_cnt_move <= V_cnt_move;
        end
    end 
    // always@(posedge Sys_clk or negedge Rst_n) begin
    //     if(Rst_n == 0) begin
    //         set_sign <= 0;
    //     end else if(Pixl_avai) begin
    //         if((H_addr <= H_cnt_move + window -1'b1) 
    //         && (H_addr >= H_cnt_move) 
    //         && (V_addr <= V_cnt_move + window -1'b1) 
    //         && (V_addr >= V_cnt_move))  begin
    //             set_sign <= 1'b1;
    //         end else begin
    //             set_sign <= 0;
    //         end
    //     end else begin
    //         set_sign <= 0;
    //     end
    // end
    assign set_sign = (Pixl_avai)?((((H_addr <= H_cnt_move + window -1'b1) 
                                 && (H_addr  >= H_cnt_move) 
                                 && (V_addr  <= V_cnt_move + window -1'b1) 
                                 && (V_addr  >= V_cnt_move)))
                                 ?(1'b1):(1'b0))
                                 :1'b0;
    assign rgb = (set_sign)?(RD_DATA):(backgroud_color);
    // assign rgb = (set_sign)?((RD_DATA == black)?(backgroud_color):(RD_DATA)):(backgroud_color);
    // always@(posedge Sys_clk or negedge Rst_n) begin
    //     if(Rst_n == 0) begin
    //         rgb <= black;
    //     end else if(set_sign) begin
    //         rgb <= white;
    //     end else begin
    //         rgb <= black;
    //     end
    // end
    //assign REAL_RGB = (RD_DATA == black)?(backgroud_color):(RD_DATA);
///
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            H_cnt <= 0;
        end else if(H_cnt == H_total - 1'b1) begin
            H_cnt <= 0;
        end else begin
            H_cnt <= H_cnt + 1'b1;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            H_full <= 1'b0;
        end else if(H_cnt == H_total - 1'b1) begin
            H_full <= 1'b1;
        end else begin
            H_full <= 1'b0;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            V_cnt <= 0;
        end else if((V_cnt == V_total - 1'b1) && (H_cnt == H_total - 1'b1)) begin
            V_cnt <= 0;
        end else if(H_cnt == H_total - 1'b1) begin
            V_cnt <= V_cnt + 1'b1;
        end else begin
            V_cnt <= V_cnt;
        end
    end
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            V_full <= 1'b0;
        end else if((V_cnt == V_total - 1'b1) && (H_cnt == H_total - 1'b1)) begin
            V_full <= 1'b1;
        end else begin
            V_full <= 1'b0;
        end
    end
//
    //RD_EN
    assign RD_EN = (((H_cnt >  (H_Sync + H_backporch +  H_left -2'd2) + H_cnt_move))
                 && ((H_cnt <= (H_Sync + H_backporch +  H_left -2'd2) + H_cnt_move + window))
                 && ((V_cnt >  (V_Sync + V_backporch +  V_left -1'b1) + V_cnt_move))
                 && ((V_cnt <= (V_Sync + V_backporch +  V_left -1'b1) + V_cnt_move + window)));

    /
    //RAM_WR_ADDR_CNT
    always@(posedge WR_CLK or negedge Rst_n) begin
        if(Rst_n == 0) begin
            RAM_WR_ADDR_CNT <= 'd0;
        end else if((RAM_WR_ADDR_CNT == RAM_depth -1'b1) && (WR_EN == 1'b1)) begin
            RAM_WR_ADDR_CNT <= 'd0;
        end else if(WR_EN == 1'b1) begin
            RAM_WR_ADDR_CNT <= RAM_WR_ADDR_CNT + 1'b1;
        end else begin
            RAM_WR_ADDR_CNT <= RAM_WR_ADDR_CNT;
        end
    end
    //RAM_RD_ADDR_CNT
    always@(posedge Sys_clk or negedge Rst_n) begin
        if(Rst_n == 0) begin
            RAM_RD_ADDR_CNT <= 'd0;
        end else if(RD_EN) begin
            if(RAM_RD_ADDR_CNT == RAM_depth -1'b1) begin
                RAM_RD_ADDR_CNT <= 'd0;
            end else begin
                RAM_RD_ADDR_CNT <= RAM_RD_ADDR_CNT + 1'b1;
            end
        end else begin
            RAM_RD_ADDR_CNT <= RAM_RD_ADDR_CNT;
        end
    end
    // //ILA
    //         wire [35:0]        CONTROL0      ;        
    //         wire [9:0]         TRIG0         ;
    // assign TRIG0 = {
    //                 RAM_WR_ADDR_CNT[15:6]};
//
bram_40000x8_sw_sr INST0_bram_40000x8_sw_sr (
  .clka     ( WR_CLK          ),  // input           write clk
  .wea      ( WR_EN           ),  // input  [0 : 0]  wr_en
  .addra    ( RAM_WR_ADDR_CNT ),  // input  [15 : 0] wr_addr
  .dina     ( WR_data         ),  // input  [7 : 0]  wr_addr
  .clkb     ( Sys_clk         ),  // input           read clk
  .addrb    ( RAM_RD_ADDR_CNT ),  // input  [15 : 0] rd_addr
  .doutb    ( RD_DATA         )   // output [7 : 0]  rd_data
);
//     cs_icon Inst0_cs_icon (
//     .CONTROL0 ( CONTROL0     ) // INOUT BUS [35:0]
//     );
//     cs_ila Inst0_ila (
//     .CONTROL  ( CONTROL0     ), // INOUT BUS [35:0]
//     .CLK      ( WR_CLK      ), // IN
//     .TRIG0    ( TRIG0        ) // IN BUS [9:0]
// );
endmodule

NoNoUnknow
关注
专栏目录
Pytorch 实现sobel算子的卷积操作详解
09-18
本文将深入讲解如何使用PyTorch实现Sobel算子的卷积操作，以进行边缘检测。 Sobel算子是一种一阶微分算子，常用于图像边缘检测，因为它可以有效地捕捉图像中的梯度变化。Sobel算子包含两个方向的核：水平和垂直，...
sobel算子原理与实现
热门推荐
五仁月饼哭了的博客
07-15 15万+
一、原理： 首先介绍背景知识：    1)边缘：灰度或结构等信息的突变处，边缘是一个区域的结束，也是另一个区域的开始，利用该特征可以分割图像。    2)边缘点：图像中具有坐标[x，y]，且处在强度显著变化的位置上的点。    3)边缘段：对应于边缘点坐标[x，y]及其方位 ，边缘的方位可能是梯度角。        索贝尔算子（Sobeloperator）主要用作边缘
sobel算子实现原理和c++实现sobel（）检测边缘函数
共觞的博客
05-18 8080
一、OpenCV中的sobel（）函数 OpenCV中的 Sobel(src,dst,ddepth,dx,dy,ksize=3,scale=1,delta=0,borderType=BORDER_DEFAULT) 实现了边缘检测的功能。其中src表示输入矩阵；dst表示输出矩阵，即src与sobel核得到的卷积；ddepth表示输出矩阵的数据类型；dx，dy表示src与差分方向为水平方向上的So...
Sobel算法：边缘提取的原理与实践【基于python、C++基于opencv的代码实现！！】
最新发布
xiaoh_7的博客
05-01 1894
Sobel算法作为边缘检测的经典方法，通过计算图像的梯度来准确捕捉边缘信息。本文深入解析了Sobel算法的原理，包括卷积操作、梯度计算与合成以及阈值处理等步骤，并探讨了其在实际应用中的优缺点。并给出了代码实现！
sobel算子边缘检测利用不同方式实现，为什么结果也不同呢
CosineMai的博客
06-24 254
sobel算子边缘检测利用不同方式实现，为什么结果也不同呢
Sobel算子matlab实现
07-31
在MATLAB中实现Sobel算子，通常包括以下几个步骤： 1. **读取图像**：首先，使用`imread`函数读取图像，例如`map1=imread('BMW.jpg');`。这个例子中读取的图像文件名为'BMW.jpg'。 2. **获取图像尺寸**：通过`size...
八方向Sobel算子（3x3）的python实现
07-09
一种改进的八方向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...
1_sobel算子_
09-30
在MATLAB平台上，实现Sobel算子的操作相对简单，可以通过内置函数或者自定义函数来完成。 **1. Sobel算子的理论基础** Sobel算子由两个3x3的模板组成，一个用于水平方向的边缘检测（Sobel X），另一个用于垂直方向...
MATLAB的sobel算子
05-18
对图像的宽度，高度，深度，分别进行处理，得到边缘处理的照片。
八方向Sobel算子（5x5）的Python实现
07-09
基于河北师范大学硕士学位论文《基于八方向Sobel算子的边缘检测算法研究》。采用5x5， 0、 22.5、 45、 67.5、 90、 112.5、135、 157.5 八个方向的模板进行检测。
Sobel原理及计算过程详解
2301_76461741的博客
03-28 4820
该算子包含两组3x3的矩阵，分别为横向及纵向，将之与图像作平面卷积，即可分别得出横向及纵向的亮度差分近似值。首先，我们需要构建一个Sobel算子，通常是一个 3x3 的矩阵。Sobel算子可以分别计算水平和垂直方向的梯度值，然后将两者合并得到总梯度值。索贝尔算子(Sobel operator)主要用作边缘检测，在技术上，它是一离散性差分算子，用来运算图像亮度函数的灰度近似值。所以，我们假设选择图像矩阵中的点A(1, 1)，即第二行第二列的元素，对应的。接下来，我们将使用Sobel算子计算这个点的梯度值。
Sobel算子原理及matlab和opencv实现代码
qq_21603315的博客
11-27 5647
详细地分析了Sobel算子的数学原理，配有matlab和opencv实现代码
索伯（Sobel）算子原理讲解和实现
weixin_52668444的博客
05-29 1万+
文章目录边缘检测 边缘检测 边缘检测是常用的数字图像处理方法之一。 具体的边缘检测方法可以使用sobel(索伯)来做。 索伯算子是一种多用于边缘检测的离散性差分算子。索伯算子有两组不同的卷积因子，可以多一张图片做横向以及纵向的平面卷积。详细的讲就是，假设要对一张图中的（x，y）这个点使用索伯算子。首先用两个卷积因子分别对该点做卷积，从而可得出该点在这两个方向上的亮度差分近似值。将xy两个方向的亮度近似值进行结合之后，即可得到该点亮度。 得到的是一个数，如果这个值大于了阈值，那么这个点就可以被考虑成边缘点。
基于sobel算法的边缘检测设计与实现（一）
好好学习，天天向上
06-20 3073
基于sobel算法的边缘检测设计与实现
Sobel算子原理及OpenCv实现
The Dawn
04-23 7317
索贝尔算子（Sobeloperator）主要用于获得数字图像的一阶梯度，常见的应用和物理意义是边缘检测。 在技术上，它是一个离散的一阶差分算子，用来计算图像亮度函数的一阶梯度之近似值，用来运算图像亮度函数的灰度值近似值。 在图像的任何一点使用此算子，将会产生该点对应的梯度矢量或是其法矢量。 一、Sobel边缘检测算子 在讨论边缘算子之前，首先给出一些术语的定
sobel算子介绍和C++代码实现
csy900411的博客
03-17 1988
sobel算子介绍和C++代码实现 1、Sobel算子介绍 首先看一下一个sobel算子在垂直和水平方向上的作用，其中★为full卷积 其主要用于边缘检测，在技术上它是以离散型的差分算子，用来运算图像亮度函数的梯度的近似值，Sobel 算子有两个，一个是检测水平边缘的 ；另一个是检测垂直边缘的 。与Prewitt算子相比，Sobel算子对于像素的位置的影响做了加权，可以降低边缘模糊程度，因此效果更好。 缺点是Sobel算子并没有将图像的主题与背景严格地区分开来，换言之就是Sobel算子并没有基于图像灰度进
【学习opencv】Sobel算子原理及其实现
zhulinspace
11-17 4178
Sobel算子原理及其实现原理：Sobel算子理论上是对图像进行一阶求导，而后为了方便计算设计了3x3的卷积模板。Sobel算子可以计算水平Gx和垂直方向Gy的梯度变换.Gx方向的卷积模板：Gy方向的卷积模板：opencv还提供了一个scharr函数，比Sobel算子更为精准，也是3x3的模板。实现：实现较为简单，只需要遍历像素矩阵，对每一个3x3的像素矩阵与模板矩阵进行卷积运算即可，这里需要注意的
【opencv2】Sobel算子原理与实现
autocyz
01-13 8667
对于一幅图像，假设图像为全白，但是中间有一条黑色的垂直的直线。那么直线所在的位置有何特征呢？        稍微想想便可以知道，在直线的左边为全白，那么从图像最左边至中间黑色的直线，其像素点的灰度变化率始终是为0的。同理，直线右边也是这种情况。但是，在黑色直线旁边的点，其会度变化率则不为0。如果把黑色直线看成是图像左右两边的分界线，那么只要知道灰度变化率不为0 的点，就可以找到这个边界的准确位置
sobel代码实现
chilian12321的博客
06-21 3374
Sobel主要用于初步寻找图像的边缘信息，同时也可以起到图像锐化作用。常用的3*3的模板卷积实现，主要是通过水平和垂直两个方向卷积实现。#include &lt;opencv2/opencv.hpp&gt;#include &lt;iostream&gt;using namespace std;using namespace cv;Mat sobel(Mat src,Mat dst){int y...
sobel算子实现边缘检测
11-24
Sobel算子是一种常用的边缘检测算法，其基本思想是通过计算图像中像素点的梯度来检测边缘。使用Sobel算子进行边缘检测的步骤如下： 1. 首先进行高斯模糊，降噪。 2. 将图像转换成灰度图像。 3. 使用Sobel函数，求x和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值