Python实现十种滤波算法

已于 2022-04-10 10:18:16 修改
阅读量1.1w 收藏 107
点赞数 14
分类专栏： python基础 文章标签： python
于 2022-04-10 10:15:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39720178/article/details/124073666
版权

1、限幅滤波法（又称程序判断滤波法）

2、中位值滤波法

3、算术平均滤波法

4、递推平均滤波法（又称滑动平均滤波法）

5、中位值平均滤波法（又称防脉冲干扰平均滤波法）

6、限幅平均滤波法

7、一阶滞后滤波法

8、加权递推平均滤波法

9、消抖滤波法

10、限幅消抖滤波法

import scipy.signal as signal
import numpy as np
import pylab as pl
import matplotlib.pyplot as plt
import matplotlib
 
'''
算术平均滤波法
'''
def ArithmeticAverage(inputs,per):
	if np.shape(inputs)[0] % per != 0:
		lengh = np.shape(inputs)[0] / per
		for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
			inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
	inputs = inputs.reshape((-1,per))
	mean = []
	for tmp in inputs:
		mean.append(tmp.mean())
	return mean
 
'''
递推平均滤波法
'''
def SlidingAverage(inputs,per):
	if np.shape(inputs)[0] % per != 0:
		lengh = np.shape(inputs)[0] / per
		for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
			inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
	inputs = inputs.reshape((-1,per))
	tmpmean = inputs[0].mean()
	mean = []
	for tmp in inputs:
		mean.append((tmpmean+tmp.mean())/2)
		tmpmean = tmp.mean()
	return mean
 
'''
中位值平均滤波法
'''
def MedianAverage(inputs,per):
	if np.shape(inputs)[0] % per != 0:
		lengh = np.shape(inputs)[0] / per
		for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
			inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
	inputs = inputs.reshape((-1,per))
	mean = []
	for tmp in inputs:
		tmp = np.delete(tmp,np.where(tmp==tmp.max())[0],axis = 0)
		tmp = np.delete(tmp,np.where(tmp==tmp.min())[0],axis = 0)
		mean.append(tmp.mean())
	return mean
 
'''
限幅平均滤波法
Amplitude:	限制最大振幅
'''
def AmplitudeLimitingAverage(inputs,per,Amplitude):
	if np.shape(inputs)[0] % per != 0:
		lengh = np.shape(inputs)[0] / per
		for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
			inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
	inputs = inputs.reshape((-1,per))
	mean = []
	tmpmean = inputs[0].mean()
	tmpnum = inputs[0][0]						#上一次限幅后结果
	for tmp in inputs:
		for index,newtmp in enumerate(tmp):
			if np.abs(tmpnum-newtmp) > Amplitude:
				tmp[index] = tmpnum
			tmpnum = newtmp
		mean.append((tmpmean+tmp.mean())/2)
		tmpmean = tmp.mean()
	return mean
 
'''
一阶滞后滤波法
a:			滞后程度决定因子，0~1
'''
def FirstOrderLag(inputs,a):
	tmpnum = inputs[0]							#上一次滤波结果
	for index,tmp in enumerate(inputs):
		inputs[index] = (1-a)*tmp + a*tmpnum
		tmpnum = tmp
	return inputs
 
'''
加权递推平均滤波法
'''
def WeightBackstepAverage(inputs,per):
	weight = np.array(range(1,np.shape(inputs)[0]+1))			#权值列表
	weight = weight/weight.sum()
 
	for index,tmp in enumerate(inputs):
		inputs[index] = inputs[index]*weight[index]
	return inputs
 
'''
消抖滤波法
N:			消抖上限
'''
def ShakeOff(inputs,N):
	usenum = inputs[0]								#有效值
	i = 0 											#标记计数器
	for index,tmp in enumerate(inputs):
		if tmp != usenum:					
			i = i + 1
			if i >= N:
				i = 0
				inputs[index] = usenum
	return inputs
 
'''
限幅消抖滤波法
Amplitude:	限制最大振幅
N:			消抖上限
'''
def AmplitudeLimitingShakeOff(inputs,Amplitude,N):
	#print(inputs)
	tmpnum = inputs[0]
	for index,newtmp in enumerate(inputs):
		if np.abs(tmpnum-newtmp) > Amplitude:
			inputs[index] = tmpnum
		tmpnum = newtmp
	#print(inputs)
	usenum = inputs[0]
	i = 0
	for index2,tmp2 in enumerate(inputs):
		if tmp2 != usenum:
			i = i + 1
			if i >= N:
				i = 0
				inputs[index2] = usenum
	#print(inputs)
	return inputs
 
T = np.arange(0, 0.5, 1/4410.0)
num = signal.chirp(T, f0=10, t1 = 0.5, f1=1000.0)
pl.subplot(2,1,1)
pl.plot(num)
result = ArithmeticAverage(num.copy(),30)
 
#print(num - result)
pl.subplot(2,1,2)
pl.plot(result)
pl.show()

限幅滤波法（又称程序判断滤波法）

设定两次采样允许的最大偏差为A
如果（本次值-上次值）的绝对值大于A，则本次值无效，用上次值代替本次值
如果（本次值-上次值）的绝对值小于等于于A，则本次值有效，采用本次值

优点：  能有效克服因偶然因素引起的脉冲干扰  

缺点  无法抑制那种周期性的干扰  平滑度差  

import numpy as np
from matplotlib import pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号

plt.figure(figsize = (20,8))
list_s = []

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')

for i in range(len(s)-1):
    if abs(s[i+1] - s[i]) >= 15:
        s[i+1] = s[i]
    list_s.append(s[i+1])

plt.plot(list_s,label = '滤波后数据')
plt.title('限幅滤波法')
plt.legend()
plt.show()
中位值滤波法  

方法：  连续采样N次（N取奇数）  把N次采样值按大小排列  取中位数为本次有效值 

优点：  能有效克服因偶然因素引起的波动干扰  对温度、液位的变化缓慢的被测参数有良好的滤波效果  

缺点：  对流量、速度等快速变化的参数不宜  

plt.figure(figsize = (20,8))

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')

n = 7     #一次采样的次数
rank = []
for i in range(int(len(s)/n)):
    select_s = s[i*n:(i+1)*n]     #切片选取一次采样的个数
    mid_s = np.median(select_s)
    for j in range(n):       #将取到的值都赋值为中值，方便画图体现，实际中可以只要一次值
        rank.append(mid_s)

plt.plot(rank,label = '滤波后的数据')
plt.title('中值滤波算法')
plt.legend()
plt.show()
算术平均滤波法

 方法：  连续取N个采样值进行算术平均运算，得到的平均数为本次采样结果  

N值较大时：信号平滑度较高，但灵敏度较低 

N值较小时：信号平滑度较低，但灵敏度较高  

N值的选取：一般流量，N=12；压力：N=4 

优点：  适用于对一般具有随机干扰的信号进行滤波  这样信号的特点是有一个平均值，信号在某一数值范围附近上下波动  

缺点：  对于测量速度较慢或要求数据计算速度较快的实时控制不适用  比较浪费RAM  

plt.figure(figsize = (20,8))

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')
mean = []
n = 7     #一次采样的次数
for i in range(int(len(s)/n)):
    select_s = s[i*n:(i+1)*n]     #切片选取一次采样的个数
    mean_s = np.mean(select_s)
    for j in range(n):       #将取到的值都赋值为平均值，方便画图体现，实际中可以只要一次值
        mean.append(mean_s)

plt.plot(mean,label = '滤波后的数据')
plt.title('算数平均滤波算法')
plt.legend()
plt.show()

'''
算术平均滤波法(另一篇文章的代码）

def ArithmeticAverage(inputs,per):
    if np.shape(inputs)[0] % per != 0:
        lengh = np.shape(inputs)[0] / per
        for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
            inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
    inputs = inputs.reshape((-1,per))
    mean = []
    for tmp in inputs:
        mean.append(tmp.mean())
    return mean
'''
递推平均滤波法（又称滑动平均滤波法） 

方法：  把连续取N个采样值看成一个队列，遵循先进先出原则  队列的长度固定为N  每次采样到一个新数据放入队尾,并扔掉原来队首的一次数据.(先进先出原则)  把队列中的N个数据进行算术平均运算,就可获得新的滤波结果  N值的选取：流量，N=12；压力：N=4；液面，N=4~12；温度，N=1~4 

优点：  对周期性干扰有良好的抑制作用，平滑度高  适用于高频振荡的系统 

缺点：  灵敏度低  对偶然出现的脉冲性干扰的抑制作用较差  不易消除由于脉冲干扰所引起的采样值偏差  不适用于脉冲干扰比较严重的场合  比较浪费RAM  

plt.figure(figsize = (20,8))

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')

N = 7      #队列大小
mean_list = []
select_s = list(s[i:i+N])      #先选择一个队列的数据，求平均
mean = np.mean(select_s)
select_s.insert(len(select_s),select_s[0])    #左移一位
select_s.remove(select_s[0])
#select_s[-1] = mean
mean_list.append(mean)

for i in range(len(s)-N):       #然后添加一个新数据，左移一位，去头去尾，重复迭代
    select_s.append(s[i+N])
    select_s.insert(len(select_s),select_s[0])    #左移一位
    select_s.remove(select_s[0])
    select_s.remove(select_s[-1])
    mean = np.mean(select_s)
    #select_s[-1] = mean
    mean_list.append(mean)

plt.plot(mean_list,label = '滤波后的数据')
plt.title('滑动平均滤波算法')
plt.legend()
plt.show()


'''
递推平均滤波法

def SlidingAverage(inputs,per):
    if np.shape(inputs)[0] % per != 0:
        lengh = np.shape(inputs)[0] / per
        for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
            inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
    inputs = inputs.reshape((-1,per))
    tmpmean = inputs[0].mean()
    mean = []
    for tmp in inputs:
        mean.append((tmpmean+tmp.mean())/2)
        tmpmean = tmp.mean()
    return mean
'''
中位值平均滤波法（又称防脉冲干扰平均滤波法）  

方法：  相当于“中位值滤波法”+“算术平均滤波法”  连续采样N个数据，去掉一个最大值和一个最小值  然后计算N-2个数据的算术平均值  N值的选取：3~14  

优点：  融合了两种滤波法的优点  对于偶然出现的脉冲性干扰，可消除由于脉冲干扰所引起的采样值偏差  

缺点：  测量速度较慢，和算术平均滤波法一样  比较浪费RAM  

plt.figure(figsize = (20,8))

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')
mean = []
n = 7     #一次采样的次数
for i in range(int(len(s)/n)):
    select_s = s[i*n:(i+1)*n]     #切片选取一次采样的个数
    select_s = sorted(select_s)
    select_s.remove(select_s[0])
    select_s.remove(select_s[-1])

    mean_s = np.mean(select_s)
    for j in range(n):       #将取到的值都赋值为平均值，方便画图体现，实际中可以只要一次值
        mean.append(mean_s)

plt.plot(mean,label = '滤波后的数据')
plt.title('中位值平均滤波算法')
plt.legend()
plt.show()

'''
中位值平均滤波法

def MedianAverage(inputs,per):
    if np.shape(inputs)[0] % per != 0:
        lengh = np.shape(inputs)[0] / per
        for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
            inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
    inputs = inputs.reshape((-1,per))
    mean = []
    for tmp in inputs:
        tmp = np.delete(tmp,np.where(tmp==tmp.max())[0],axis = 0)
        tmp = np.delete(tmp,np.where(tmp==tmp.min())[0],axis = 0)
        mean.append(tmp.mean())
    return mean

'''
限幅平均滤波法 

方法：  相当于“限幅滤波法”+“递推平均滤波法”  每次采样到的新数据先进行限幅处理，  再送入队列进行递推平均滤波处理  （此处稍微做了改动，代码中将每次得到的平均值送入队尾，这样得到的滤波数据更偏向于稳定）

优点：  融合了两种滤波法的优点  对于偶然出现的脉冲性干扰，可消除由于脉冲干扰所引起的采样值偏差  

缺点：  比较浪费RAM  

plt.figure(figsize = (20,8))

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')

N = 8      #队列大小
mean_list = []
select_s = list(s[i:i+N])      #先选择一个队列的数据，求平均
mean = np.mean(select_s)
select_s.insert(len(select_s),select_s[0])    #左移一位
select_s.remove(select_s[0])
select_s[-1] = mean
mean_list.append(mean)

for i in range(len(s)-N):       #然后添加一个新数据，左移一位，去头去尾，重复迭代
    if abs(select_s[-1] - s[i+N]) >= 30:
        s[i+N] = select_s[-1]
    else:
        s[i+N] = s[i+N]

    select_s.append(s[i+N])
    select_s.insert(len(select_s),select_s[0])    #左移一位
    select_s.remove(select_s[0])
    select_s.remove(select_s[-1])
    mean = np.mean(select_s)
    select_s[-1] = mean
    mean_list.append(mean)

plt.plot(mean_list,label = '滤波后的数据')
plt.title('限幅平均滤波算法')
plt.legend()
plt.show()

'''
限幅平均滤波法
Amplitude:    限制最大振幅

def AmplitudeLimitingAverage(inputs,per,Amplitude):
    if np.shape(inputs)[0] % per != 0:
        lengh = np.shape(inputs)[0] / per
        for x in range(int(np.shape(inputs)[0]),int(lengh + 1)*per):
            inputs = np.append(inputs,inputs[np.shape(inputs)[0]-1])
    inputs = inputs.reshape((-1,per))
    mean = []
    tmpmean = inputs[0].mean()
    tmpnum = inputs[0][0]                        #上一次限幅后结果
    for tmp in inputs:
        for index,newtmp in enumerate(tmp):
            if np.abs(tmpnum-newtmp) > Amplitude:
                tmp[index] = tmpnum
            tmpnum = newtmp
        mean.append((tmpmean+tmp.mean())/2)
        tmpmean = tmp.mean()
    return mean

'''
一阶滞后滤波法 

方法：  取a=0~1  本次滤波结果=（1-a）*本次采样值+a*上次滤波结果 

优点：  对周期性干扰具有良好的抑制作用  适用于波动频率较高的场合  

缺点：  相位滞后，灵敏度低  滞后程度取决于a值大小  不能消除滤波频率高于采样频率的1/2的干扰信号  

plt.figure(figsize = (20,8))
list_s = []

s = np.random.normal(0,25,400)
plt.plot(s,label = '原始数据')
a = 0.7    #a取0-1之间，a越接近1越稳定，越接近0越灵敏

for i in range(len(s)-1):
    s[i+1] = (1-a) * s[i+1] + a * s[i]
    list_s.append(s[i+1])

plt.plot(list_s,label = '滤波后数据')
plt.title('一阶滞后滤波算法')
plt.legend()
plt.show()

'''
一阶滞后滤波法
a:            滞后程度决定因子，0~1

def FirstOrderLag(inputs,a):
    tmpnum = inputs[0]                            #上一次滤波结果
    for index,tmp in enumerate(inputs):
        inputs[index] = (1-a)*tmp + a*tmpnum
        tmpnum = tmp
    return inputs

'''
加权递推平均滤波法 

 方法：  是对递推平均滤波法的改进，即不同时刻的数据加以不同的权  通常是，越接近现时刻的数据，权取得越大。  给予新采样值的权系数越大，则灵敏度越高，但信号平滑度越低 

优点：  适用于有较大纯滞后时间常数的对象  和采样周期较短的系统  

缺点：  对于纯滞后时间常数较小，采样周期较长，变化缓慢的信号  不能迅速反应系统当前所受干扰的严重程度，滤波效果差 

'''
加权递推平均滤波法
'''
def WeightBackstepAverage(inputs,per):
    weight = np.array(range(1,np.shape(inputs)[0]+1))            #权值列表
    weight = weight/weight.sum()

    for index,tmp in enumerate(inputs):
        inputs[index] = inputs[index]*weight[index]
    return inputs
消抖滤波法  

方法：  设置一个滤波计数器  将每次采样值与当前有效值比较：  如果采样值＝当前有效值，则计数器清零  如果采样值<>当前有效值，则计数器+1，并判断计数器是否>=上限N(溢出)  如果计数器溢出,则将本次值替换当前有效值,并清计数器  

优点：  对于变化缓慢的被测参数有较好的滤波效果,  可避免在临界值附近控制器的反复开/关跳动或显示器上数值抖动  

缺点：  对于快速变化的参数不宜  如果在计数器溢出的那一次采样到的值恰好是干扰值,则会将干扰值当作有效值导入系统  

'''
消抖滤波法
N:            消抖上限
'''
def ShakeOff(inputs,N):
    usenum = inputs[0]                                #有效值
    i = 0                                             #标记计数器
    for index,tmp in enumerate(inputs):
        if tmp != usenum:
            i = i + 1
            if i >= N:
                i = 0
                inputs[index] = usenum
    return inputs
限幅消抖滤波法  

方法：  相当于“限幅滤波法”+“消抖滤波法”  先限幅,后消抖  

优点：  继承了“限幅”和“消抖”的优点  改进了“消抖滤波法”中的某些缺陷,避免将干扰值导入系统  

缺点：  对于快速变化的参数不宜 

'''
限幅消抖滤波法
Amplitude:    限制最大振幅
N:            消抖上限
'''
def AmplitudeLimitingShakeOff(inputs,Amplitude,N):
    #print(inputs)
    tmpnum = inputs[0]
    for index,newtmp in enumerate(inputs):
        if np.abs(tmpnum-newtmp) > Amplitude:
            inputs[index] = tmpnum
        tmpnum = newtmp
    #print(inputs)
    usenum = inputs[0]
    i = 0
    for index2,tmp2 in enumerate(inputs):
        if tmp2 != usenum:
            i = i + 1
            if i >= N:
                i = 0
                inputs[index2] = usenum
    #print(inputs)
    return inputs

T = np.arange(0, 0.5, 1/4410.0)
num = signal.chirp(T, f0=10, t1 = 0.5, f1=1000.0)
pl.subplot(2,1,1)
pl.plot(num)
result = ArithmeticAverage(num.copy(),30)

#print(num - result)
pl.subplot(2,1,2)
pl.plot(result)
pl.show() 

C.S.D.N.老鼠
关注
  • 14
    点赞
  • 踩
  • 107
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
python实现逆滤波与维纳滤波示例
09-17
逆滤波和维纳滤波是图像处理中的两种重要技术，常用于...Python提供了丰富的库和函数，使得实现这些滤波算法变得相对简单。不过，在实际应用中，还需要根据具体场景和噪声特性来调整滤波参数，以获得最佳的恢复效果。
卡尔曼滤波算法的Python实现.zip
03-14
卡尔曼滤波算法 卡尔曼滤波算法的Python实现
python的一些滤波器函数
Steve1z的博客
03-23 1437
python的一些数字滤波器库
Python图像平滑滤波处理(均值滤波、方框滤波、高斯滤波、中值滤波、双边滤波)
L888666Q的博客
10-08 7146
图像平滑是指受传感器和大气等因素的影响，遥感图像上会出现某些亮度变化过大的区域，或出现一些亮点(也称噪声)。这种为了抑制噪声，使图像亮度趋于平缓的处理方法就是图像平滑。图像平滑实际上是低通滤波，平滑过程会导致图像边缘模糊化。
python进行滤波处理
最新发布
weixin_45570158的博客
05-10 367
在Python中，滤波处理通常涉及对数据序列应用某种算法或函数，以消除或减小不需要的噪声、异常值或其他干扰。这可以通过多种方法来实现，包括使用内置函数、库（如NumPy、SciPy、Pandas和信号处理库）以及自定义函数。除了NumPy和SciPy之外，还有一些专门的信号处理库（如PyWavelets、PyAudioAnalysis等）可以用于更高级的信号处理和滤波任务。例如，你可以编写一个函数来检测并替换异常值，或者实现某种特定的非线性滤波算法。可以使用NumPy库进行简单的滤波操作，如滑动平均滤波。
python实现滤波算法 中值滤波 低通滤波（博文底部vx获取）
01-19 903
python实现滤波算法 中值滤波 低通滤波
Python 图像滤波 代码实现 （sobel、average、gaussian、laplace）
m0_61899108的博客
10-26 5575
图像在频域里面，频率低的地方说明它是比较平滑的，因为平滑的地方灰度值变化比较小，而频率高的地方通常是边缘或者噪声，因为这些地方往往是灰度值突变的。 所谓高通滤波就是保留频率比较高的部分，即突出边缘； 低通滤波就是保留频率比较低的地方，即平滑图像，弱化边缘，消除噪声。
卡尔曼滤波算法——基本原理及举例（python实现radar数据滤波）
Williamcsj的博客
06-01 5104
卡尔曼滤波分为两大阶段：预测和更新。预测公式如下： x′=Fx+Bu x^{\prime}=Fx+B u x′=Fx+Bu P′=FPFT+Q P^{\prime}=F P F^{T}+Q P′=FPFT+Q 其中，x′x^{\prime}x′ 表示；FFF 表示；xxx 表示；BBB 表示；UUU 表示；P′P^{\prime}P′ 表示；PPP 表示；QQQ 表示。更新公式如下： K=P′HT(HP′HT+R)−1 K=P^{\prime} H^{T}\left(H P^{\prime} H^{T}+
基于python的Hessian Frangi滤波算法设计与实现
05-01
基于python的Hessian Frangi滤波算法设计与实现
Python 实现中值滤波、均值滤波的方法
12-24
红包： Lena椒盐噪声图片： # -*- coding: utf-8 -*- """ Created on Sat Oct 14 22:16:47 2017 @author: Don """ from tkinter import * from skimage import io ...im=io.imread('lena_sp.jpg', as_grey=True) ...
卡尔曼滤波Python代码实例实现
05-08
卡尔曼滤波算法(KF)是序贯数据同化的一种，是由Kalman针对随机过程状态估计提出的。KF的基本思想是利用前一时刻的状态估计值和当前时刻的观测值来获得动态系统当前时刻状态变量的最优估计。
快速上手的Python版二维卡尔曼滤波解析
qq_40280673的博客
04-07 5696
快速上手的Python版二维卡尔曼滤波解析。代码每一个部分都有详细的注释，更加的通俗易懂，希望能帮助到需要快速上手卡尔曼滤波的学习者。
ADC采样滤波算法利用卡尔曼滤波算法详解
热门推荐
moge19的专栏
08-16 3万+
1 ADC采样模型 假设ADC采样的值已经为稳定状态，设k+1k+1k+1时刻ADC采样值为Xk+1Xk+1X_{k+1},则kkk时刻ADC采样值为XkXkX_k，假设k+1k+1k+1时刻的采样值为Zk+1Zk+1Z_{k+1}，则有： {Xk+1=Xk,Zk+1=Xk+1+δ,δ为噪声{Xk+1=Xk,Zk+1=Xk+1+δ,δ为噪声 \begin{cases} X_{k+1} = X...
python-opencv之图像滤波（blur，boxFilter，GaussianBlur，medianBlur）
恍恍惚惚的大穷猫的博客
09-14 4704
高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。中值滤波是一种典型的非线性滤波，是基于排序统计理论的一种能够有效抑制噪声的非线性信号处理技术，基本思想是用像素点邻域灰度值的中值来代替该像素点的灰度值，让周围的像素值接近真实的值从而消除孤立的噪声点。中值滤波会取当前像素点及其周围临近像素点（一共有奇数个像素点）的像素值，将这些像素值排序，然后将位于中间位置的像素值作为当前像素点的像素值。如果normalize!
心电信号去噪python
一个学长的博客
05-24 7863
心电信号去噪python 我妥协了实话实说，比起教程，这篇算是一个笔记吧，在我做心电的过程中，观察了一下心电相关的去噪方法，国内主要集中在应用中值滤波和小波变换，国外一般直接用一巴特沃斯了事。目前我只会应用，本来我是想理论都吃透了再写的，奈何类似小波之类的基本原理学起来实在一言难尽，说白了还是能力不够 ，等我再学一遍数字信号处理归来之日就是将理论补足之时。 1.巴特沃斯滤波器 1.1 巴特沃斯高通滤波 巴特沃斯滤波器是心电信号滤波最好用的滤波器，一个低频的高通滤波器可以去除基线漂移 比起我之前写了一整篇中值
Python 简单的信号处理
Chandler_river的博客
01-15 1979
Numpy信号处理
卡尔曼滤波法进行一维数据滤波（python实现）
weixin_45259896的博客
11-24 7823
文章目录前言一：卡尔曼滤波法原理简单理解二：卡尔曼滤波法五条经典公式三：卡尔曼滤波法实现参考 前言 最近在做一个蓝牙定位的小项目，在采集ibeancon蓝牙基站RSSI信号强度数据时，噪声对精度的影响特别的严重，翻阅了些文献，里面提到一种卡尔曼滤波法，所以准备使用卡尔曼滤波法来处理我们收集来的一维rssi数据，这片文章，主要简单介绍了卡尔曼滤波法的原理，还有介绍一下如何用代码来实现卡尔曼滤波法。 一：卡尔曼滤波法原理简单理解 若直接看卡尔曼滤波法的经典五条方差，估计很多人都会懵逼，这都讲了啥，xx是个傻鸟。
开发技巧 | Python极简实现滑动平均滤波（基于Numpy.convolve）
Python大本营的博客
05-18 9768
作者|小宋是呢来源 |CSDN博客1.滑动平均概念滑动平均滤波法（又称递推平均滤波法），时把连续取N个采样值看成一个队列 ，队列的长度固定为N ，每次采样到一个新数...
用python实现自适应LMS滤波算法
05-25
自适应LMS滤波算法是一种常见的数字信号处理算法，可以用于信号降噪、信号分离、信号估计等领域。下面是用Python实现自适应LMS滤波算法的代码示例： ```python import numpy as np def lms_filter(x, d, M, mu): """ 自适应LMS滤波算法 :param x: 输入信号 :param d: 目标信号 :param M: 滤波器阶数 :param mu: 步长因子 :return: 滤波器系数和滤波后的输出信号 """ N = len(x) w = np.zeros(M) # 初始化滤波器系数 y = np.zeros(N-M) # 初始化输出信号 for n in range(M, N): x_n = x[n-M:n] # 取M个输入信号 y[n-M] = np.dot(w, x_n) # 计算输出信号 e = d[n] - y[n-M] # 计算误差 delta_w = mu * e * x_n # 计算权值更新量 w = w + delta_w # 更新滤波器系数 return w, y ``` 其中，`x`表示输入信号，`d`表示目标信号，`M`表示滤波器的阶数，`mu`表示步长因子。函数返回滤波器系数和滤波后的输出信号。 下面是一个示例： ```python import matplotlib.pyplot as plt # 生成带噪音的信号 t = np.arange(0, 1, 0.01) x = np.sin(2*np.pi*10*t) + 0.5*np.random.randn(len(t)) # 生成目标信号 d = np.sin(2*np.pi*10*t) # 自适应LMS滤波 M = 50 mu = 0.01 w, y = lms_filter(x, d, M, mu) # 绘制结果 plt.plot(t, x, label='Input Signal') plt.plot(t, d, label='Desired Signal') plt.plot(t[M:], y, label='Output Signal') plt.legend() plt.show() ``` 运行上述代码，可以得到滤波后的结果图像。可以看到，自适应LMS滤波算法可以有效地去除输入信号中的噪音，提取出目标信号。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值