c#中的低通和高通滤波器
本文关键字:高通 滤波器 | 更新日期: 2023-09-27 18:13:57
我需要用c#编写的低通和高通滤波器。对于这个过滤过程,我有双数组。我想如果我尝试将matlab Butterworth和Chebyshev算法转换为c#,会更容易。但是我找不到黄油的代码。m和Chebyshev算法,我不想在我的电脑里安装matlab和信号处理工具箱。你能提供一下代码吗?谢谢. .
LP和HP过滤器- Musicdsp.org文档
我在上面的半代码中实现了过滤器,如下所示在我们的sEMG分析仪软件中,它工作得很好。
public class FilterButterworth
{
/// <summary>
/// rez amount, from sqrt(2) to ~ 0.1
/// </summary>
private readonly float resonance;
private readonly float frequency;
private readonly int sampleRate;
private readonly PassType passType;
private readonly float c, a1, a2, a3, b1, b2;
/// <summary>
/// Array of input values, latest are in front
/// </summary>
private float[] inputHistory = new float[2];
/// <summary>
/// Array of output values, latest are in front
/// </summary>
private float[] outputHistory = new float[3];
public FilterButterworth(float frequency, int sampleRate, PassType passType, float resonance)
{
this.resonance = resonance;
this.frequency = frequency;
this.sampleRate = sampleRate;
this.passType = passType;
switch (passType)
{
case PassType.Lowpass:
c = 1.0f / (float)Math.Tan(Math.PI * frequency / sampleRate);
a1 = 1.0f / (1.0f + resonance * c + c * c);
a2 = 2f * a1;
a3 = a1;
b1 = 2.0f * (1.0f - c * c) * a1;
b2 = (1.0f - resonance * c + c * c) * a1;
break;
case PassType.Highpass:
c = (float)Math.Tan(Math.PI * frequency / sampleRate);
a1 = 1.0f / (1.0f + resonance * c + c * c);
a2 = -2f * a1;
a3 = a1;
b1 = 2.0f * (c * c - 1.0f) * a1;
b2 = (1.0f - resonance * c + c * c) * a1;
break;
}
}
public enum PassType
{
Highpass,
Lowpass,
}
public void Update(float newInput)
{
float newOutput = a1 * newInput + a2 * this.inputHistory[0] + a3 * this.inputHistory[1] - b1 * this.outputHistory[0] - b2 * this.outputHistory[1];
this.inputHistory[1] = this.inputHistory[0];
this.inputHistory[0] = newInput;
this.outputHistory[2] = this.outputHistory[1];
this.outputHistory[1] = this.outputHistory[0];
this.outputHistory[0] = newOutput;
}
public float Value
{
get { return this.outputHistory[0]; }
}
}
注意这个过滤器是为音频DSP目的而创建的。要创建一个干净的输出,您需要将共振设置为sqrt(2)
。
我发现这个在线工具看起来很有前途:交互式数字滤波器设计:Butterworth/Bessel/Chebyshev滤波器
您只需输入您的要求:
- 滤波器设计:Butterworth/Bessel/Chebyshev
- 滤波器类型:低通/高通/带通/带阻 筛选器顺序
- <
- 转角频率/频率/gh>
点击提交,计算以下信息:
- 增益、极、零
- 递归关系 C代码实现递归关系
- 幅值、相位、脉冲和阶跃响应图
你可以在c#中直接从递归关系中实现一个过滤器。
如果你只需要几个常量过滤器,你就完成了。但是,如果您需要能够在运行时调整过滤器参数,则需要做更多的工作。幸运的是,教授提供了他的工具的源代码,应该可以转换为c#。
这是一个它有许多模式,HP LP BP峰值,等等,它是一个BiQuad可能是2极静态滤波器之类的,它是一个特定的滤波器,有某种数字结果:https://github.com/filoe/cscore/blob/master/CSCore/DSP/BiQuad.cs
/*
* These implementations are based on http://www.earlevel.com/main/2011/01/02/biquad-formulas/
*/
using System;
namespace CSCore.DSP
{
/// <summary>
/// Represents a biquad-filter.
/// </summary>
public abstract class BiQuad
{
/// <summary>
/// The a0 value.
/// </summary>
protected double A0;
/// <summary>
/// The a1 value.
/// </summary>
protected double A1;
/// <summary>
/// The a2 value.
/// </summary>
protected double A2;
/// <summary>
/// The b1 value.
/// </summary>
protected double B1;
/// <summary>
/// The b2 value.
/// </summary>
protected double B2;
/// <summary>
/// The q value.
/// </summary>
private double _q;
/// <summary>
/// The gain value in dB.
/// </summary>
private double _gainDB;
/// <summary>
/// The z1 value.
/// </summary>
protected double Z1;
/// <summary>
/// The z2 value.
/// </summary>
protected double Z2;
private double _frequency;
/// <summary>
/// Gets or sets the frequency.
/// </summary>
/// <exception cref="System.ArgumentOutOfRangeException">value;The samplerate has to be bigger than 2 * frequency.</exception>
public double Frequency
{
get { return _frequency; }
set
{
if (SampleRate < value * 2)
{
throw new ArgumentOutOfRangeException("value", "The samplerate has to be bigger than 2 * frequency.");
}
_frequency = value;
CalculateBiQuadCoefficients();
}
}
/// <summary>
/// Gets the sample rate.
/// </summary>
public int SampleRate { get; private set; }
/// <summary>
/// The q value.
/// </summary>
public double Q
{
get { return _q; }
set
{
if (value <= 0)
{
throw new ArgumentOutOfRangeException("value");
}
_q = value;
CalculateBiQuadCoefficients();
}
}
/// <summary>
/// Gets or sets the gain value in dB.
/// </summary>
public double GainDB
{
get { return _gainDB; }
set
{
_gainDB = value;
CalculateBiQuadCoefficients();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BiQuad"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The frequency.</param>
/// <exception cref="System.ArgumentOutOfRangeException">
/// sampleRate
/// or
/// frequency
/// or
/// q
/// </exception>
protected BiQuad(int sampleRate, double frequency)
: this(sampleRate, frequency, 1.0 / Math.Sqrt(2))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BiQuad"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The frequency.</param>
/// <param name="q">The q.</param>
/// <exception cref="System.ArgumentOutOfRangeException">
/// sampleRate
/// or
/// frequency
/// or
/// q
/// </exception>
protected BiQuad(int sampleRate, double frequency, double q)
{
if (sampleRate <= 0)
throw new ArgumentOutOfRangeException("sampleRate");
if (frequency <= 0)
throw new ArgumentOutOfRangeException("frequency");
if (q <= 0)
throw new ArgumentOutOfRangeException("q");
SampleRate = sampleRate;
Frequency = frequency;
Q = q;
GainDB = 6;
}
/// <summary>
/// Processes a single <paramref name="input"/> sample and returns the result.
/// </summary>
/// <param name="input">The input sample to process.</param>
/// <returns>The result of the processed <paramref name="input"/> sample.</returns>
public float Process(float input)
{
double o = input * A0 + Z1;
Z1 = input * A1 + Z2 - B1 * o;
Z2 = input * A2 - B2 * o;
return (float)o;
}
/// <summary>
/// Processes multiple <paramref name="input"/> samples.
/// </summary>
/// <param name="input">The input samples to process.</param>
/// <remarks>The result of the calculation gets stored within the <paramref name="input"/> array.</remarks>
public void Process(float[] input)
{
for (int i = 0; i < input.Length; i++)
{
input[i] = Process(input[i]);
}
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected abstract void CalculateBiQuadCoefficients();
}
/// <summary>
/// Used to apply a lowpass-filter to a signal.
/// </summary>
public class LowpassFilter : BiQuad
{
/// <summary>
/// Initializes a new instance of the <see cref="LowpassFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The filter's corner frequency.</param>
public LowpassFilter(int sampleRate, double frequency)
: base(sampleRate, frequency)
{
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
double k = Math.Tan(Math.PI * Frequency / SampleRate);
var norm = 1 / (1 + k / Q + k * k);
A0 = k * k * norm;
A1 = 2 * A0;
A2 = A0;
B1 = 2 * (k * k - 1) * norm;
B2 = (1 - k / Q + k * k) * norm;
}
}
/// <summary>
/// Used to apply a highpass-filter to a signal.
/// </summary>
public class HighpassFilter : BiQuad
{
private int p1;
private double p2;
/// <summary>
/// Initializes a new instance of the <see cref="HighpassFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The filter's corner frequency.</param>
public HighpassFilter(int sampleRate, double frequency)
: base(sampleRate, frequency)
{
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
double k = Math.Tan(Math.PI * Frequency / SampleRate);
var norm = 1 / (1 + k / Q + k * k);
A0 = 1 * norm;
A1 = -2 * A0;
A2 = A0;
B1 = 2 * (k * k - 1) * norm;
B2 = (1 - k / Q + k * k) * norm;
}
}
/// <summary>
/// Used to apply a bandpass-filter to a signal.
/// </summary>
public class BandpassFilter : BiQuad
{
/// <summary>
/// Initializes a new instance of the <see cref="BandpassFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The filter's corner frequency.</param>
public BandpassFilter(int sampleRate, double frequency)
: base(sampleRate, frequency)
{
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
double k = Math.Tan(Math.PI * Frequency / SampleRate);
double norm = 1 / (1 + k / Q + k * k);
A0 = k / Q * norm;
A1 = 0;
A2 = -A0;
B1 = 2 * (k * k - 1) * norm;
B2 = (1 - k / Q + k * k) * norm;
}
}
/// <summary>
/// Used to apply a notch-filter to a signal.
/// </summary>
public class NotchFilter : BiQuad
{
/// <summary>
/// Initializes a new instance of the <see cref="NotchFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The filter's corner frequency.</param>
public NotchFilter(int sampleRate, double frequency)
: base(sampleRate, frequency)
{
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
double k = Math.Tan(Math.PI * Frequency / SampleRate);
double norm = 1 / (1 + k / Q + k * k);
A0 = (1 + k * k) * norm;
A1 = 2 * (k * k - 1) * norm;
A2 = A0;
B1 = A1;
B2 = (1 - k / Q + k * k) * norm;
}
}
/// <summary>
/// Used to apply a lowshelf-filter to a signal.
/// </summary>
public class LowShelfFilter : BiQuad
{
/// <summary>
/// Initializes a new instance of the <see cref="LowShelfFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The filter's corner frequency.</param>
/// <param name="gainDB">Gain value in dB.</param>
public LowShelfFilter(int sampleRate, double frequency, double gainDB)
: base(sampleRate, frequency)
{
GainDB = gainDB;
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
const double sqrt2 = 1.4142135623730951;
double k = Math.Tan(Math.PI * Frequency / SampleRate);
double v = Math.Pow(10, Math.Abs(GainDB) / 20.0);
double norm;
if (GainDB >= 0)
{ // boost
norm = 1 / (1 + sqrt2 * k + k * k);
A0 = (1 + Math.Sqrt(2 * v) * k + v * k * k) * norm;
A1 = 2 * (v * k * k - 1) * norm;
A2 = (1 - Math.Sqrt(2 * v) * k + v * k * k) * norm;
B1 = 2 * (k * k - 1) * norm;
B2 = (1 - sqrt2 * k + k * k) * norm;
}
else
{ // cut
norm = 1 / (1 + Math.Sqrt(2 * v) * k + v * k * k);
A0 = (1 + sqrt2 * k + k * k) * norm;
A1 = 2 * (k * k - 1) * norm;
A2 = (1 - sqrt2 * k + k * k) * norm;
B1 = 2 * (v * k * k - 1) * norm;
B2 = (1 - Math.Sqrt(2 * v) * k + v * k * k) * norm;
}
}
}
/// <summary>
/// Used to apply a highshelf-filter to a signal.
/// </summary>
public class HighShelfFilter : BiQuad
{
/// <summary>
/// Initializes a new instance of the <see cref="HighShelfFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="frequency">The filter's corner frequency.</param>
/// <param name="gainDB">Gain value in dB.</param>
public HighShelfFilter(int sampleRate, double frequency, double gainDB)
: base(sampleRate, frequency)
{
GainDB = gainDB;
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
const double sqrt2 = 1.4142135623730951;
double k = Math.Tan(Math.PI * Frequency / SampleRate);
double v = Math.Pow(10, Math.Abs(GainDB) / 20.0);
double norm;
if (GainDB >= 0)
{ // boost
norm = 1 / (1 + sqrt2 * k + k * k);
A0 = (v + Math.Sqrt(2 * v) * k + k * k) * norm;
A1 = 2 * (k * k - v) * norm;
A2 = (v - Math.Sqrt(2 * v) * k + k * k) * norm;
B1 = 2 * (k * k - 1) * norm;
B2 = (1 - sqrt2 * k + k * k) * norm;
}
else
{ // cut
norm = 1 / (v + Math.Sqrt(2 * v) * k + k * k);
A0 = (1 + sqrt2 * k + k * k) * norm;
A1 = 2 * (k * k - 1) * norm;
A2 = (1 - sqrt2 * k + k * k) * norm;
B1 = 2 * (k * k - v) * norm;
B2 = (v - Math.Sqrt(2 * v) * k + k * k) * norm;
}
}
}
/// <summary>
/// Used to apply an peak-filter to a signal.
/// </summary>
public class PeakFilter : BiQuad
{
/// <summary>
/// Gets or sets the bandwidth.
/// </summary>
public double BandWidth
{
get { return Q; }
set
{
if (value <= 0)
throw new ArgumentOutOfRangeException("value");
Q = value;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PeakFilter"/> class.
/// </summary>
/// <param name="sampleRate">The sampleRate of the audio data to process.</param>
/// <param name="frequency">The center frequency to adjust.</param>
/// <param name="bandWidth">The bandWidth.</param>
/// <param name="peakGainDB">The gain value in dB.</param>
public PeakFilter(int sampleRate, double frequency, double bandWidth, double peakGainDB)
: base(sampleRate, frequency, bandWidth)
{
GainDB = peakGainDB;
}
/// <summary>
/// Calculates all coefficients.
/// </summary>
protected override void CalculateBiQuadCoefficients()
{
double norm;
double v = Math.Pow(10, Math.Abs(GainDB) / 20.0);
double k = Math.Tan(Math.PI * Frequency / SampleRate);
double q = Q;
if (GainDB >= 0) //boost
{
norm = 1 / (1 + 1 / q * k + k * k);
A0 = (1 + v / q * k + k * k) * norm;
A1 = 2 * (k * k - 1) * norm;
A2 = (1 - v / q * k + k * k) * norm;
B1 = A1;
B2 = (1 - 1 / q * k + k * k) * norm;
}
else //cut
{
norm = 1 / (1 + v / q * k + k * k);
A0 = (1 + 1 / q * k + k * k) * norm;
A1 = 2 * (k * k - 1) * norm;
A2 = (1 - 1 / q * k + k * k) * norm;
B1 = A1;
B2 = (1 - v / q * k + k * k) * norm;
}
}
}
}
看看OpenCV/EmguCV。
它们都是开源的,所以你可以有"代码",如果这是你正在寻找的。
你可以在另一个stackoverflow问题上查看Butterworth Low Pass过滤器的源代码。正如其他人指出的那样,EmguCV附带了许多高效编码的过滤器,并且可以开箱即用
下面是一些使用NMath的fft的butterworth和chebyshev过滤器的c#代码示例。