从相关卷积到图像高斯模糊的快速计算

最新推荐文章于 2023-05-31 20:37:14 发布
最新推荐文章于 2023-05-31 20:37:14 发布
阅读量445 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 图像算法 基础算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/walletiger/article/details/109741188
博客主要介绍了信号相关、线性卷积、圆周卷积的概念及计算方法。相关用于衡量信号相似程度，线性卷积有公式及物理解释，圆周卷积有多种求法。还阐述了利用圆周卷积计算线性卷积的方法，介绍了FFT快速卷积和IIR型高斯滤波器。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

几年前的总结 ，在此记录一下：

一 相关

相关是用来衡量两个信号  "形状" 和 "相位"(起始位置）的相似程度 . 

计算相关性的两个信号必须要有相同起始位置和长度，然后对两个信号逐点乘积加和，当两个信号完全一致时相关性是最高的．

离散信号相关计算定义：

信号中的直流分量通常对信号表达是没有意义的，反而会产生干扰。所以某些相关性计算要先对信号做减直流处理，如数理统计里用协方差来度量相关性： 

 

相关的计算是满足交换律的， "x 与 h的相关性" 等价于 "h与x的相关性" , 在这里我们把 h看成特征模板，x看成未知信号(下文卷积也都按这种约定)．从这个角度来看

相关性计算也表达了"模板信号对未知信号加权和"的意思．比如要从一个很长的序列里匹配一段已知信号，相关计算算法可能从任意起始位置截取一段 x(0 ~ n) , 与 h 做加权和，得分最高的位置即是最匹配的信号.

 

二卷积(通常是指线卷积)

卷积与相关类似，按字面理解，先卷(与相关的主要区别），再积，离散卷积公式：

公式如下：

                先把模板h翻卷(按原点对褶） h(i) -> h(-i)

                h的零点对齐(平移) 到x的目标点n  h(-i) -> h(n - i)

                再对两段序列求逐点积，加和

当卷积模板中心对称时，卷积的结果与相关是一致的！！

同样的卷积计算满足交换率，即 (x * h)(n)  <==> (h * x)(n) 

卷积的物理解释：

a  : 假如一幅只有不同黑色程度的水墨画下雨泡了水。  x(p) 表示水墨画在 p 点的含墨量，h(delta) 表示字画泡水后，单位墨向位置 (p + delta)扩散了多少 ( 实际扩散了 x(p) * h(p + delta)  , 线性时不变系统) , 问题求是这幅画最终每一点的墨迹量。  注意， x 的定义域为整个画的二维坐标， h的定义域为与x,y平面原点中心对称的矩形区域。

 

    显然用卷积的定义求解就很容易， 目标点 P1受到模板h定义的所有邻域点影响，对于邻域点 Q1 , 位移了delta 到 P1 , 则 Q1 + delta = P1 ，即受Q1的影响为 x(Q1) * h (P1 - Q1) ,  p1 点收到总的影响为：

b  : 假如小明在t时刻脸被挨打强度为x(t),  受单位强度的力挨打后， 脸鼓起的包随时间变化函数为 h(t) , 那问题来了， 求{0 , ... N}任意时刻小明脸鼓起的包强度。  显然 x(t) 和h(t) 的定义域只有时间正轴，包括零点。

信号里 x 被称为冲激函数， h 为冲激响应，这里冲激函数只会对后面的时刻产生响应。挨打之前脸上就有包那是不负责任的！ 同样计算公式如下：

卷积计算的几种方法：             

a 按公式 反褶(与零点)、平移(h 0点到目标位置n) , 逐点乘积 再求和

 

b 多项式方法（竖式计算法则）一种快捷计算方式

X1 = 

X2 =  

 

如图所示，竖式计算时，两个序列要做到齐次项对齐，即定义域零点对齐。

 

三圆周卷积

圆周卷积也称作循环卷积，百度百科里的定义如下图：

 

两个序列x,h (序列下标从0开始) , 作L点的圆周卷积:

        1    首先将x ,h补成L长度的序列（少则补0,多则截断) 

        2    模板序列h逆时针排成一圈，x 顺时针排成一圈 

        3    求 0 点的圆周卷积对应位置相乘加和

        4    求 点n 的圆周圈积，将模板h 顺时针转n下，再逐点乘积求和。

 

也来个定义:

 

假设两个序列长度分别为 M,N , L >= M + N - 1 时 圆周卷积和线性卷积值是一致的！！ 

 

圆周卷积求法2:  竖式计算

X = {1 , 4  , 3 } ,  H ＝ {1 , 2 , 3}

方法是用H的每一个元素去乘  X 每一组顺时针循环移位的序列，再求和：

                        1 X    {1 , 4 ,  3}  +  2 X   {3 , 1 , 4}  + 3 X {4 , 3 , 1}  =          1          4            3

                                                                                                                          6          2           8         

                                                                                                                          12        9           3

                                                                                                                    ---------------------------------

                                                                                                                         19        15         14

圆周卷积求法3:  矩阵乘法

X = {1 , 4  , 3 } ,  H ＝ {1 , 2 , 3}

 

                                         0

先将 H周期延拓(1,2,3 , 1,2,3 , 1,2,3)，沿0点反转 ， 再依次求每组顺时针循环右称的序列

HM = 

    |    1    3     2    |

    |    2    1     3    |

    |    3    2     1    |

F列向量 =    ＝ {19 , 15 , 14}

圆周卷积求法4:  DFT 

经证明圆周卷积与 两个序列先DFT再乘积再逆DFT结果是一致。个人理解圆周卷积只是计算上有DFT 这种快速算法，没有线卷积那么强的物理意义，L = N + M - 1 时二者实现了统一。 L < N + M - 1 时会造成混叠效应。

 

四 利用圆周卷积来计算线性卷积

4.1 模板定义域为正轴数据 

a 将 x & h 扩展成 L = N + M - 1 序列 

b 计算圆周卷积。

c 再截掉 最后  2 *floor(M / 2) = M - 1个值 

 

4.2 模板h定义域包含负值 

这里举一个 h 中心对称的例子，同样 x 序列长度为N , h 长度为M M为奇数, 且h 定义域为 [ -M / 2 , M/ 2]

a 将包含负值的定义域平移到0点变成 [0 , M]，这样最终卷积的结果会延时(晚)  floor(M/2) 个点！

b 将 x & h 扩展成 L = N + M - 1 序列 

c 计算圆周圈积。 

4 截掉最前面 floor(M / 2) 和最后 (M / 2) 个点

 

4.3 线卷积matlab 代码 

function [s] = linear_cov(x , h)


N = size(x , 2);
M = size(h , 2);
L = N + M - 1;


% fprintf(2 , 'M = %d , N = %d , L = %d \n' , M ,  N , L);


s = zeros(1 , L);


for i=1:N
    for j=1:M
        s(j + i - 1) = s(j + i - 1) + x(i) * h(j);
    end
end  

测试:

X=[4,5,6,7,8,9,10];
H=[1,2,3];
s=linear_cov(X,H);
%s=conv(H,X);

4.4 圆周卷积matlab 代码

function [s] = circle_cov(x , h , L)


N = size(x , 2);
M = size(h , 2);


if N < L 
    X1 = [x , zeros(1 , L - N)];
else
    X1 = x(1:L);
end


if M < L
    H1 = [h , zeros(1 , L - M)];
else
    H1 = h(1:L);
end


s = zeros(1 , L);


for i=1:L
    for j=1:L
        s(i) = s(i) + X1(j) * H1(1 + mod(i - j , L));
    end
end

测试：

X=[4,5,6,7,8,9,10];
H=[1,2,3];
s=circle_cov(X,H , 9);

 

9点的圆周卷积结果与线卷积一致。

五 FFT 快速卷积

求x, h的卷积 matlab 代码： ( h (x) : x >= 0)

function [s] = fft_cov(x , h)


N = size(x , 2);
M = size(h , 2);
L = N + M - 1;


X = [x , zeros(1 , L - N)];
H = [h , zeros(1 , L - M)];


f_x = fft(X);
f_h = fft(H);


f_s = f_x .* f_h;
s   = ifft(f_s);

如果 h 定义域  x [-a , b] , a < 0 , 卷积输出会延时 a 长度。 对于二维图像卷积适用。

六 IIR 型高斯滤波器

参考：

https://www.cnblogs.com/luo-peng/p/5223910.html

IIR 型高斯滤波器特点是计算复杂度与 核 大小无关有一定参考意义

实现代码

//iir_guass_blur.h

#ifndef __IIR_GUASS_BLUR_H
#define __IIR_GUASS_BLUR_H

#ifdef __cplusplus
extern "C"
{
#endif

long IIR_guass_filter_create(int w , int h , float sigma);

void IIR_guass_filter_do(long  h_flt , const uint8_t * src_plane , int src_pitch , uint8_t *dst_plane , int dst_pitch);

void IIR_guass_filter_destroy(long  h_flt);

long IIR_guass_filterI_create(int w , int h , float sigma);

void IIR_guass_filterI_do(long  h_flt , const uint8_t * src_plane , int src_pitch , uint8_t *dst_plane , int dst_pitch);

void IIR_guass_filterI_destroy(long  h_flt);



#ifdef __cplusplus
}
#endif

#endif

//iir_guass_blur.c

#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <assert.h>
#include <math.h>
#include "iir_guass_blur.h"

/* *** IIR guass blur formula : ***
 *  
 *  forward pass  : 
        w[n]  =  B * x[n] + (b1 * y[n - 1] + b2 * y[n - 2] + b3 * y[n - 3]) / b0;
  
 *  backword pass :
       out[n] =  B * w[n] + (b1 * out[n + 1] + b2 * out[n + 2] + b3 * out[n + 3]) / b0;

 *      B = 1 - (b1 + b2 + b3) / b0; 
 *
*/

typedef struct IIR_guass_coefs
{
    float   B;
    float   b[4];    
}IIR_guass_coefs;

typedef struct IIR_guass_flt_context
{
    IIR_guass_coefs     coeff;
    int                 w;
    int                 h;
    float               sigma;
    float               *w1;
    float               *w2;
    uint8_t             *dst_1pass;
}IIR_guass_flt_context;


static void compute_coefs3(IIR_guass_coefs *c , float sigma)  
{  
    float q, q2, q3;  
    if (sigma >= 2.5){  
        q = 0.98711 * sigma - 0.96330;  
    }  
    else if ((sigma >= 0.5) && (sigma < 2.5)){  
        q = 3.97156 - 4.14554 * (float) sqrtf ((float) 1 - 0.26891 * sigma);  
    }  
    else {  
        q = 0.1147705018520355224609375;  
    }  

    q2 = q * q;  
    q3 = q * q2;  
    c->b[0] = 1/(1.57825+(2.44413*q)+(1.4281 *q2)+(0.422205*q3));  
    c->b[1] = (        (2.44413*q)+(2.85619*q2)+(1.26661 *q3)) *c->b[0];  
    c->b[2] = (                   -((1.4281*q2)+(1.26661 *q3)))*c->b[0];  
    c->b[3] = (                                 (0.422205*q3)) *c->b[0];  
    c->B = 1.0-(c->b[1]+c->b[2]+c->b[3]);  
}  

long IIR_guass_filter_create(int w , int h , float sigma)
{
    IIR_guass_flt_context *ctx;
    int max_len;

    ctx = (IIR_guass_flt_context *)calloc(1 , sizeof(IIR_guass_flt_context));
    assert(ctx != NULL);

    ctx->w      = w;
    ctx->h      = h;
    ctx->sigma  = sigma;

    compute_coefs3(&ctx->coeff , sigma);

    max_len     = w > h ? w + 3 : h + 3;

    ctx->w1     = (float *)malloc(sizeof(float) * max_len);
    ctx->w2     = (float *)malloc(sizeof(float) * max_len);

    assert(ctx->w1 != 0);
    assert(ctx->w2 != 0);

    ctx->dst_1pass = (uint8_t *)malloc(sizeof(uint8_t) * h * w);
    assert(ctx->dst_1pass != 0);
    

    return (long)ctx;
    
}   

void IIR_guass_filter_onepass( IIR_guass_flt_context *ctx , int width , int height , const uint8_t * src_plane , int src_pitch , uint8_t *dst_plane , int dst_pitch)
{
    const uint8_t       *p_src;
    uint8_t             *p_dst;
    int n , h;
    float *w1 , *w2 , *b , B;

	p_src       = src_plane;
    p_dst		= dst_plane;
    w1          = ctx->w1;
    w2          = ctx->w2;
    b           = ctx->coeff.b;
    B           = ctx->coeff.B;

    for(h = 0 ; h < height ; ++h){
        /*forward process*/
        w1[0] = w1[1] = w1[2] = p_src[0];
        for(n = 3 ; n < width + 3 ; ++n){
            w1[n] = B * p_src[n - 3] + b[1] * w1[n - 1] + b[2] * w1[n - 2] + b[3] * w1[n - 3];
        }
        /*backward process*/
        w2[width] = w2[width + 1] = w2[width + 2] = w1[width + 2];
        for(n = width - 1; n >= 0 ; --n){
            w2[n] = B * w1[n + 3]    + b[1] * w2[n + 1] + b[2] * w2[n + 2] + b[3] * w2[n + 3];
        }
        /*store data*/
        for(n = 0 ; n < width ; ++n){
            p_dst[n * dst_pitch] = w2[n];
        }
        p_src += src_pitch;
        p_dst++;
    }
}
	
void IIR_guass_filter_do(long  h_flt , const uint8_t * src_plane , int src_pitch , uint8_t *dst_plane , int dst_pitch)
{
    IIR_guass_flt_context *ctx;

    ctx = (IIR_guass_flt_context *)h_flt;

    /*process horizontal data*/    
	IIR_guass_filter_onepass(ctx , ctx->w , ctx->h , src_plane , src_pitch , ctx->dst_1pass , ctx->h);
	
    /*process vertical data*/ 
	IIR_guass_filter_onepass(ctx , ctx->h , ctx->w , ctx->dst_1pass , ctx->h , dst_plane , dst_pitch);
	
}

void IIR_guass_filter_destroy(long  h_flt)
{
    IIR_guass_flt_context *ctx; 

    ctx = (IIR_guass_flt_context *)h_flt;

    if (ctx->dst_1pass){
        free(ctx->dst_1pass);
        ctx->dst_1pass = 0;
    }

    if (ctx->w1){
        free(ctx->w1);
        ctx->w1 = 0;
    }

    if (ctx->w2){
        free(ctx->w2);
        ctx->w2 = 0;
    }

    free(ctx);
}


typedef struct IIR_guass_coefsI
{
    int32_t   B;
    int32_t   b[4];    
}IIR_guass_coefsI;

typedef struct IIR_guass_fltI_context
{
    IIR_guass_coefsI    coeff;
    int                 w;
    int                 h;
    float               sigma;
    int32_t             *w1;
    int32_t             *w2;
    uint8_t             *dst_1pass;
}IIR_guass_fltI_context;


static void compute_coefs3_I(IIR_guass_coefsI *c , float sigma)  
{  
    double q, q2, q3;  
    if (sigma >= 2.5){  
        q = 0.98711 * sigma - 0.96330;  
    }  
    else if ((sigma >= 0.5) && (sigma < 2.5)){  
        q = 3.97156 - 4.14554 * (float) sqrtf ((float) 1 - 0.26891 * sigma);  
    }  
    else {  
        q = 0.1147705018520355224609375;  
    }  

    q2 = q * q;  
    q3 = q * q2;  
    c->b[0] = 16384 / (1.57825+(2.44413*q)+(1.4281 *q2)+(0.422205*q3));  
    c->b[1] = (        (2.44413*q)+(2.85619*q2)+(1.26661 *q3))  * c->b[0];  
    c->b[2] = (                   -((1.4281*q2)+(1.26661 *q3))) * c->b[0];  
    c->b[3] = (                                 (0.422205*q3))  * c->b[0];  
    c->B = 16384 - (c->b[1]+c->b[2]+c->b[3]);  
}  

long IIR_guass_filterI_create(int w , int h , float sigma)
{
    IIR_guass_fltI_context *ctx;
    int max_len;

    ctx = (IIR_guass_fltI_context *)calloc(1 , sizeof(IIR_guass_fltI_context));
    assert(ctx != NULL);

    ctx->w      = w;
    ctx->h      = h;
    ctx->sigma  = sigma;

    compute_coefs3_I(&ctx->coeff , sigma);

    max_len     = w > h ? w + 3 : h + 3;

    ctx->w1     = (int32_t *)malloc(sizeof(int32_t) * max_len);
    ctx->w2     = (int32_t *)malloc(sizeof(int32_t) * max_len);

    assert(ctx->w1 != 0);
    assert(ctx->w2 != 0);

    ctx->dst_1pass = (uint8_t *)malloc(sizeof(uint8_t) * h * w);
    assert(ctx->dst_1pass != 0);

    return (long)ctx;
    
}   

void IIR_guass_filterI_onepass( IIR_guass_fltI_context *ctx , int width , int height , const uint8_t * src_plane , int src_pitch , uint8_t *dst_plane , int dst_pitch)
{
    const uint8_t       *p_src;
    uint8_t             *p_dst;
    int n , h;
    int32_t *w1 , *w2 , *b , B;

	p_src       = src_plane;
    p_dst		= dst_plane;
    w1          = ctx->w1;
    w2          = ctx->w2;
    b           = ctx->coeff.b;
    B           = ctx->coeff.B;

    for(h = 0 ; h < height ; ++h){
        /*forward process*/
        w1[0] = w1[1] = w1[2] = p_src[0];
        for(n = 3 ; n < width + 3 ; ++n){
            w1[n] = B * p_src[n - 3] + b[1] * w1[n - 1] + b[2] * w1[n - 2] + b[3] * w1[n - 3];
        }
        /*backward process*/
        w2[width] = w2[width + 1] = w2[width + 2] = (w1[width + 2] >> 14);
        for(n = width - 1; n >= 0 ; --n){
            w2[n] = (B * (w1[n + 3] >> 14)) + b[1] * w2[n + 1] + b[2] * w2[n + 2] + b[3] * w2[n + 3];
        }
        /*store data*/
        for(n = 0 ; n < width ; ++n){
            p_dst[n * dst_pitch] = (w2[n] >> 14);
        }
        p_src += src_pitch;
        p_dst++;
    }
}
	
void IIR_guass_filterI_do(long  h_flt , const uint8_t * src_plane , int src_pitch , uint8_t *dst_plane , int dst_pitch)
{
    IIR_guass_fltI_context *ctx;

    ctx = (IIR_guass_fltI_context *)h_flt;

    /*process horizontal data*/    
	IIR_guass_filterI_onepass(ctx , ctx->w , ctx->h , src_plane , src_pitch , ctx->dst_1pass , ctx->h);
	
    /*process vertical data*/ 
	IIR_guass_filterI_onepass(ctx , ctx->h , ctx->w , ctx->dst_1pass , ctx->h , dst_plane , dst_pitch);
	
}

void IIR_guass_filterI_destroy(long  h_flt)
{
    IIR_guass_fltI_context *ctx; 

    ctx = (IIR_guass_fltI_context *)h_flt;

    if (ctx->dst_1pass){
        free(ctx->dst_1pass);
        ctx->dst_1pass = 0;
    }

    if (ctx->w1){
        free(ctx->w1);
        ctx->w1 = 0;
    }

    if (ctx->w2){
        free(ctx->w2);
        ctx->w2 = 0;
    }

    free(ctx);
}

 

异常检测之普通高斯算法和多元高斯算法学习总结
沉默的夏虫
12-25 767
普通高斯算法： 特点：如果不主动去建立特征与特征之间的关系特征，则普通的高斯算法没有特征的关联性 实现方式简述： 1.取1000组非异常的对象，并归纳其n中特种 2.分别计算每种特种高斯公式函数里的 3.将第二部中计算出的带入下边的计算公式得出p(x)的表达式 4.另外取200组混有异常对象的数据带入p(x)表达式，确定阈值 当p(x)&lt;时则预测为异常对象，否则为正常对...
二维冲激函数及其傅里叶变换对
weisiyi1的博客
04-17 5691
一维冲激函数为 为了加以利用，我们限制他满足条件： 对应的，我们有 如果我们把情况扩散到二维，其实也是一样的。 一维的时候我们的冲激只有一个变量t，在二维里我们有两个变量分别是t跟z。 因此我们定义二维冲激为： 对应的 以及我们需要的取样特性： 我们把在0点的取样特性推广到一般： 以上是连续的 在此，我们定义离散变量x和y，二维离散冲激函数定义为： 在离散条件下，其取样特性为： ...
数字图像处理第四章：频率域滤波
sketch_2314的博客
05-31 3253
第四章：频率域滤波1.背景2.基本概念复数傅立叶级数冲激函数及其取样性质连续单变量函数的傅立叶变换卷积3.取样和取样函数的傅立叶变换取样取样后的傅立叶变换取样定理与混叠重建函数4.单变量的离散傅立叶变换由取样函数变换的DFT取样和频率间隔的关系5.二变量函数的傅立叶变换二维冲激及其取样性质二维连续傅立叶变换对二维取样及取样定理图像中的混叠DFT及IDFT6.二维离散傅立叶变换和反变换的性质空间间隔和频率间隔的关系平移和旋转周期性对称性傅立叶频谱和相角二维离散卷积定理7.频率域滤波基础频率域的其他性质频率域滤
第4章 Python 数字图像处理(DIP) - 频率域滤波5 - 二变量函数的傅里叶变换、图像中的混叠、二维离散傅里叶变换及其反变换
jasneik的博客
02-24 1028
目录二变量函数的傅里叶变换二维冲激及其取样性质二维连续傅里叶变换对二维取样和二维取样定理图像中的混叠二维离散傅里叶变换及其反变换 二变量函数的傅里叶变换 二维冲激及其取样性质 两个连续变量的冲激函数定义为： δ(t,z)={1,t=z=00,others(4.52)\delta(t, z) = \begin{cases} 1, & t=z=0 \\ 0, & \text{others} \end{cases} \tag{4.52}δ(t,z)={1,0,​t=z=0others​(4.52)
数字图像处理第四章——频率域滤波
jgq1466693的博客
06-24 2166
第三章我们研究了空间滤波的相关知识，但是若想彻底理解这一领域，我们还需学习在图像滤波中如何应用傅里叶变换核频率域的基本知识，注重关注基本原理以及它们与数字图像处理的关系，本章将为傅里叶变换打下基础，并强调图像特征与用于表达这些特征的数学工具之间的联系。 在高等数学中我们便学习到了傅里叶级数与傅里叶变换，这是由法国数学家吉恩·巴普提斯特·约瑟夫·傅里叶发现并发表，这两个重要的数学公式为数学发展历史上做出了巨大贡献，它点出了任何周期函数都可以表示为不同频率的正弦项和/或余弦项的形式，每个正弦项和/
Java编程实现高斯模糊和图像的空间卷积详解
08-28
在Java编程中，实现高斯模糊涉及到图像的空间卷积，这是一种数学运算，通过将图像与高斯核进行卷积来达到模糊效果。 高斯模糊的原理基于高斯函数，这是一种在统计学和数学中广泛使用的正态分布函数。在二维空间中，...
易语言图像高斯模糊处理源码-易语言
06-13
本文将深入探讨易语言中的图像高斯模糊处理源码，以及如何利用这些源码实现图像处理。 高斯模糊是基于高斯函数的滤波操作，通过将图像的每个像素值替换为其邻域像素的加权平均值来实现。在数学上，这个加权平均过程...
Python scipy的二维图像卷积运算与图像模糊处理操作示例
09-18
scipy库中的`signal.fftconvolve`函数通过快速傅里叶变换（FFT）实现卷积，这是一种高效的方法，特别是在处理大尺寸图像时。 以下是一个使用scipy进行二维图像卷积的简单例子： ```python import numpy as np from...
Opencv+Python实现图像运动模糊和高斯模糊的示例
01-20
高斯模糊则是通过将图像与二维高斯分布的概率密度函数进行卷积来实现的。这种模糊方法可以平滑图像，同时保持边缘相对清晰，减少噪声的影响。在OpenCV中，`cv2.GaussianBlur()`函数是实现高斯模糊的关键。函数的`...
冲激函数与冲激函数相乘与冲激函数对冲激函数卷积之间的区别
whynat的博客
03-30 3万+
首先说，当一个运算出现了冲激函数与冲激函数相乘的运算时，就说明这个运算是错误的，违反了某些规则。例如： sin（t）的傅里叶变换为：Dirac（w+1）+Dirac（w-1） 单位直流信号的傅里叶变换为2π*Dirac（w） 上述是正规的数学描述，但是按照容易的理解方式，我更愿意把Dirac（w+1）写成Dirac（1），同时将直流信号的2π暂时的省略（哈哈，为了简便）。 那么： sin（t）的傅...
【信号与系统】3. 阶跃函数、冲激函数
普罗米修斯的博客
03-14 5万+
阶跃函数、冲激函数均属于奇异函数（奇异函数是指函数本身有不连续点或其导数或积分有不连续点的一类函数） 【1.阶跃函数】 1. 单位阶跃函数 将 yn（t）的 n→ ∞ 得到 ε（t）。 2. 延迟单位阶跃函数 3. 阶跃函数的性质 （1）表示某些信号 （2）表示信号的作用区间 （3）积分 【 2.单位冲激函数】 对强度极大，作用时间极短的一种物理量的理想化模型。 1. 狄...
冲激串采样
seniusen的博客
11-04 6972
在一定条件下，一个连续时间信号完全可以用该信号在等时间间隔点上的值或样本来表示，并且可以用这些样本值把该信号全部恢复出来。 一般来讲，在没有任何附加条件或说明下，我们不能指望一个信号都能唯一地由一组等间隔的样本值来表征。例如，下图中三个不同的连续时间信号，在 TTT 的整数倍时刻点上，全部有相同的值，即 x1(kT)=x2(kT)=x3(kT) x_1(kT) = x_2 (kT) = x_3...
二维带限函数
weisiyi1的博客
04-17 935
其实二维带限函数的理解跟一维带限函数是一样的 我们对取样率的表达如下（满足取样定理）： 则原函数可以由一组样本无误的恢复。 取样定理：取样率要大于该函数最高频率的两倍。 满足取样定理的取样率采集到的样本，才能无误还原函数。 ...
二维狄拉克函数matlab表示,二维狄拉克（Dirac）冲激函数具有性质.ppt
weixin_39929961的博客
03-18 1854
二维狄拉克(Dirac)冲激函数具有性质.ppt第三章??????????? 图像变换 3．1 概述 一、图像处理可用线性系统描述 其输入与输出图像的关系： 　　二、? 图像处理的方法 　1．?直接处理----阵列运算(线性代数) 　2．?间接处理---图像变换 　　条件：1)变换是可逆的； 2)算法不复杂 　　优点：1)运算速度快(快速算法) 　　　　...
点扩散函数point spread function (PSF)
热门推荐
不傻缺的专栏
01-13 14万+
概述概述 介绍 理论 历史和方法 显微镜中的PSF 天文学中的PSF 眼科的PSF References 点扩散函数（point spread function (PSF) 以下均使用PSF缩写）描述了一个成像系统对一个点光源（物体）的响应。PSF的一般术语就是系统响应，PSF是一个聚焦光学系统的冲击响应。在大多情况下，PSF可以认为像是一个能够表现未解析物体的图像中的一个扩展区块。函数上讲，PS
快速卷积运算_解析卷积高速计算中的细节，有代码有真相
weixin_39747399的博客
11-22 1578
作者：Manas Sahni编译：AI公园(ronghuaiyang)导读卷积是深度学习中的基础运算，那么卷积运算是如何加速到这么快的呢，掰开揉碎了给你看。我不太破旧的笔记本电脑CPU上，使用TensorFlow这样的库，我可以(最多)在10-100毫秒内运行大多数常见的CNN模型。在2019年，即使是智能手机也能在不到半秒的时间内运行“重”CNN(比如ResNet)模型。所以，想象一下...
卷积神经网络之快速卷积算法(img2col、Winograd、FFT)
qq_43409114的博客
04-10 2万+
前言 最近几天尝试着不用框架写一个卷积神经网络，后来代码写完之后发现运行的速度实在是太慢，分析了一下发现主要的时间都花在了卷积层上。于是查找各种资料，学习了两种现在主流的快速卷积算法，写此文主要记录一下其中的要点，在学习过程中遇到的问题。 FFT 如果学过或者了解过信号的，你肯定肯定，空间域中矩阵的卷积运算，实际上等价于频率域中两个矩阵对应元素相乘，关于怎么进行快速傅里叶变换,我之前的文章已经讲述...
卷积和快速傅里叶变换（FFT）的实现
Just do it !
08-22 2万+
卷积运算 卷积可以说是图像处理中最基本的操作。线性滤波通过不同的卷积核，可以产生很多不同的效果。假如有一个要处理的二维图像，通过二维的滤波矩阵（卷积核），对于图像的每一个像素点，计算它的领域像素和滤波器矩阵的对应元素的乘积，然后累加，作为该像素位置的值。关于图像卷积和滤波的一些知识点可以参考这篇博客。 下面是通过python模拟实现的图像卷积操作，模拟了sobel算子，prewitt算子和拉普...
图像处理——卷积运算实现图像均值模糊。
weixin_51546925的博客
12-17 735
自主实现卷积运算均值模糊。 先写出卷积核，再算出填充矩阵，最后卷积运算求加权平均。 一次只对一个通道进行运算，再mean_blur()中一次对三个通道没有实现，代码能力还不是很够，一直各种小错误，最后看我师兄写的却可以，并且代码也简介。。蒽，。 import numpy as np import cv2 import matplotlib.pyplot as plt def mean_blur(img,k_width,k_height,c): #均值模糊 #kernel： kerne
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

walletiger

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值