Tại sao tôi lại có tiếng ồn chói tai này khi loại bỏ tần suất cao?

Gần đây tôi đã bắt đầu chơi với biến đổi Fourier (sau khi dành vài tuần để tìm hiểu về toán học đằng sau nó). Tôi đã quyết định thử hack cùng một bộ lọc thông thấp trên vết cắn âm thanh sau:

Cụ thể, tôi lấy biến đổi Fourier, lấy ra 1/2 tần số cao nhất và sau đó lấy biến đổi Fourier ngược. Đây là những gì tôi có

Tại sao có tiếng ồn ào?

Hai vấn đề tiềm năng:

1. Việc lọc trong miền tần số (sử dụng FFT) yêu cầu thêm chồng chéo, lưu chồng lấp hoặc thuật toán liên quan. Điều này được gây ra bởi sự khác biệt giữa tích chập tuyến tính và tròn. Nếu không, bạn có được bí danh miền thời gian
2. Một số tiếng ồn như cắt đơn giản. Lọc thực sự có thể tăng biên độ miền thời gian cho một số mẫu và nếu vượt quá phạm vi có sẵn, nó có thể là clip hoặc kết thúc xung quanh.

Đầu tiên chỉ là một lưu ý, biến đổi fourier không lý tưởng cho các bộ lọc thông thấp / cao. Bộ lọc Butterworth là một nơi tốt để bắt đầu và theo dõi bộ lọc Ch Quashev / Elliptical nếu bạn có nhiều tham vọng hơn.

Có vẻ như bạn đang cố gắng thực hiện một bộ lọc lý tưởng. Không có cách nào chúng ta có thể thực hiện các bộ lọc 'tường gạch' này khi chúng ta cắt bỏ tất cả các tần số trên / dưới một giá trị nhất định. Tất cả các bộ lọc được phát triển tốt sẽ giảm dần từ 1 đến 0 xung quanh tần số giới hạn của chúng tôi.

Các bộ lọc lý tưởng chỉ có thể là lý thuyết và nếu bạn có Chuyển đổi Fourier liên tục, phương pháp của bạn ở trên sẽ hoạt động.

Nhưng chúng tôi đang thực hiện các Biến đổi Fourier rời rạc nên có nhiều điều phải lo lắng hơn. Vì tôi không chắc chắn về phương thức triển khai của bạn, tôi sẽ đoán rằng bạn đang thực hiện việc mở cửa sổ vì chỉ cần rút tần số là một cách chắc chắn để có được tiếng kêu trong DFT cửa sổ.

Khi cửa sổ trong DFT, người ta có thể nghĩ rằng biên độ tần số giữa các cửa sổ là tương đối liên tục. ví dụ: nếu tần số 400Hz có biên độ 0,5 trong cửa sổ hiện tại thì ở cửa sổ tiếp theo, biên độ sẽ gần 0,5. Thật không may, điều này không đúng, vì vậy nếu chúng ta chỉ cần loại bỏ tần số 400Hz khỏi DFT, chúng ta có thể nghe thấy tiếng bật hoặc vết nứt lớn giữa các cửa sổ.

Một ví dụ nhỏ: Tốc độ cắt là 600Hz Cửa sổ 1 đang phát một hình sin 800Hz Cửa sổ 2 kết nối 'liên tục' với cửa sổ 1 và phát 400Hz. Sau đó, chúng ta sẽ nghe thấy một cửa sổ bật lên giữa cửa sổ vì cửa sổ 1 sẽ im lặng và cửa sổ 2 sẽ bật ngay lập tức.

Một lưu ý khác là chúng ta chỉ có thể biểu thị một lượng tần số hữu hạn bằng DFT. Nếu chúng ta có một tệp âm thanh có sóng hình sin có tần số nằm giữa hai tần số riêng biệt trong DFT của chúng ta, thì chúng ta thực sự biểu thị nó với rất nhiều tần số riêng biệt. Vì vậy, mặc dù một tệp âm thanh mẫu có thể chứa sóng hình sin thấp hơn mức cắt của chúng tôi, nếu tần số của nó nằm trong tần số DFT của chúng tôi thì chúng tôi có thể cắt một phần của nó ra và làm biến dạng nó bằng phương pháp ở trên, vì tần số cao hơn là cần thiết để thể hiện âm thanh tập tin.

Mong rằng sẽ giúp

$s(t) = s_\mathrm{low}(t) + s_\mathrm{high}(t)$

$f_0,f_1$$f_\mathrm{cut}$$f_0 < f_1 < f_\mathrm{cut}$$f_2 > f_\mathrm{cut}$

$N$$f_\mathrm{s} > 2\cdot f_2$$f_\mathrm{s} \gg 2\cdot f_2$

Tôi đã kết hợp một chương trình Python nhỏ để minh họa một số khái niệm - mã này khá khủng khiếp nhưng tôi chỉ lấy một số mã cũ mà tôi gặp phải cho các vấn đề tương tự. Mặc dù hầu như không có bất kỳ bình luận nào, nhưng nó khá dễ theo dõi do các mô-đun nhỏ. Hai hàm dft / idft ; hai chức năng fshiftn / fshiftp để thay đổi tần số tín hiệu i miền DFT để lọc; một dftlpass chức năng để thực hiện lọc trong miền DFT; một hàm zpblpass để thực hiện quá trình lọc bằng cách sử dụng bộ lọc Butterworth; một hàm bbdraftig để tạo tín hiệu kiểm tra và thực hiện lọc; và cuối cùng là một lô nhỏ chức năngđể vẽ các tín hiệu. Ở cuối tập lệnh, các tham số khác nhau được đặt và các số liệu khác nhau được thực hiện.

"""
   Test of DFT versus scipy.signal.butter filtering with respect to
   signal reconstruction.

"""

# import ############################################################ import #
import matplotlib as mpl;   mpl.rcParams['backend'] = 'Agg'
import matplotlib.pyplot as mplpp
import matplotlib.mlab as mplml
import numpy as np
import scipy.signal as sps


# initialize #################################################### initialize #
try:
    mpl.rc('text', usetex=False)
    mpl.rc('font', family='serif')
    mpl.rc('font', serif='STIXGeneral')
    mpl.rc('font', size=8)
except AttributeError:
    None


# dft ################################################################## dft #
def dft(xt, fs, t0):
    N, d = len(xt), -2j*np.pi/len(xt)
    w = np.arange(N, dtype=np.float).reshape((N,1))
    c = np.exp(d*t0*fs*w)
    W = np.exp(d*np.dot(w,np.transpose(w)))
    xf = np.multiply(c,np.dot(W,xt)) / float(N)
    f = w*fs/float(N)
    return xf, f


# idft ################################################################ idft #
def idft( X, FS, T0 ):
    N, d = len(X), 2j*np.pi/len(X)
    w = np.arange(N, dtype=float).reshape((N,1))
    cc = np.exp(d*T0*FS*w)
    Wc = np.exp(d*np.dot(w, np.transpose(w)))
    Y = np.dot(Wc, np.multiply(cc, X))
    return Y



# fshiftn ########################################################## fshiftn #
def fshiftn( xf, f ):
    assert type(f) == np.ndarray, "f must be a np.ndarray"
    assert f.shape[1] == 1, "f must be a column array"
    assert xf.shape[1] == 1, "xf must be a column array"
    assert sum(f<0) == 0, "All frequency components must be 0 or positive"

    # Determine sampling rate, tolerance, and allocate output array
    fs, tol = len(f)*(np.abs(f[1,0]-f[0,0])), 1.E-2
    fshift = np.zeros((len(f),1), dtype=float)
    xfshift = np.zeros((len(f),1), dtype=complex)

    # Determine index where f > fs/2
    Nm = np.floor(len(f)/2.0)
    Np = np.floor((len(f)-1.0)/2.0)

    # Compute output frequency array such that -fs/2 <= f < fs/2 and the
    # corresponding Fourier coefficients
    fshift[:Nm,0] = f[Np+1:,0] - fs
    fshift[Nm,0] = f[0,0]
    fshift[Nm+1:,0] = f[1:Np+1,0]

    xfshift[:Nm,0] = xf[Np+1:,0]
    xfshift[Nm,0] = xf[0,0]
    xfshift[Nm+1:,0] = xf[1:Np+1,0]

    return xfshift, fshift


# fshiftp ########################################################## fshiftp #
def fshiftp(xf, f):
    assert type(f) == np.ndarray, "f must be a np.ndarray"
    assert f.shape[1] == 1, "f must be a column array"
    assert xf.shape[1] == 1, "xf must be a column array"
    assert sum(f<0) > 0, "Some input frequencies must be negative"

    # Determine sampling rate, tolerance, and allocate output array
    fs, tol = len(f)*(np.abs(f[1,0]-f[0,0])), 1.E-2
    fshift = np.zeros((len(f),1), dtype=float)
    xfshift = np.zeros((len(f),1), dtype=complex)

    # Determine index where f > fs/2
    #Nx = np.floor((len(f)+1+tol)/2)
    Nm = np.floor(len(f)/2.0)
    Np = np.floor((len(f)-1.0)/2.0)

    # Compute output frequency array such that -fs/2 <= f < fs/2 and the
    # corresponding Fourier coefficients
    fshift[Np+1:,0] = f[:Nm:,0] + fs
    fshift[0,0] = f[Nm,0]
    fshift[1:Np+1:,0] = f[Nm+1:,0]

    xfshift[Np+1:,0] = xf[:Nm:,0]
    xfshift[0,0] = xf[Nm,0]
    xfshift[1:Np+1:,0] = xf[Nm+1:,0]

    return xfshift, fshift


# dftlpass ######################################################## dftlpass #
def dftlpass(xt, fs, fcut):
    # Perform Discrete Fourier Transform
    xf, f = dft(xt, fs, 0.0)

    # Shift frequencies to -fs/2 <= f < fs/2 ... and coefficients
    xfshift, fshift = fshiftn(xf, f)

    # Perform filtration
    xfshift = xfshift * (np.abs(fshift) <= fcut)

    # Re-shift frequencies to 0 <= f < fs ... and coefficients
    xfrecon, frecon = fshiftp(xfshift, fshift)

    # Perform inverse Discrete Fourier Transform
    yt = idft(xfrecon, fs, 0.0)
    return yt.real


# zpblpass ######################################################## zpblpass #
def zpblpass(xn, fcal, fs, fcut):
    bz, az = sps.butter(5, fcut/(fs/2))

    # Gain calibration
    Ncal = np.max([np.int(20*fs/fcal), 30000])
    Nguard = np.int(0.1*Ncal)    
    t = np.arange(Ncal) / fs
    x0_cal = 1.0 * np.cos(2*np.pi*fcal*t)
    yi_cal = sps.filtfilt(bz, az, 2.0*x0_cal*np.cos(2*np.pi*fcal*t))
    k = 1.0/np.mean(yi_cal[Nguard:Ncal-Nguard])

    # Scaled output
    yn = k * sps.filtfilt(bz, az, xn)
    return yn


# bbdftsig ######################################################## bbdftsig #
def bbdftsig(f0, f1, f2, fcut, fs, N):
    t = np.arange(N).reshape((N,1)) / fs
    s0 = np.sin(2*np.pi*f0*t)
    s1 = np.sin(2*np.pi*f1*t + 0.2)
    s2 = 0.7 * np.sin(2*np.pi*f2*t + np.pi/3.0)
    slow = s0 + s1
    s = slow + s2

    sf = dftlpass(s, fs, fcut)
    sfdftv = sf.reshape((N))
    sv = s.reshape((N))
    slowv = slow.reshape((N))

    sv = s.reshape((N))
    sfzpbv = zpblpass(sv, f1, fs, fcut)
    #sfzpbv = sfzpb.reshape((N))
    return sv, slowv, sfdftv, sfzpbv


# plotsigs ######################################################## plotsigs #
def plotsigs(s, slow, sfdft, sfzpb, Nstart, Nstop, fname):
    n = np.arange(s.shape[0])

    # Plot results
    mplpp.figure(1, (5.0,2.25))
    mplpp.clf()
    mplpp.plot(n[Nstart:Nstop], s[Nstart:Nstop], 'm-',
               n[Nstart:Nstop:4], s[Nstart:Nstop:4], 'mx',
               n[Nstart:Nstop], slow[Nstart:Nstop], 'g-',
               n[Nstart:Nstop:10], slow[Nstart:Nstop:10], 'gx',
               n[Nstart:Nstop], sfdft[Nstart:Nstop], 'r-',
               n[Nstart:Nstop:15], sfdft[Nstart:Nstop:15], 'rx',
               n[Nstart:Nstop], sfzpb[Nstart:Nstop], 'b-',
               linewidth=1.5)
    mplpp.legend([r'$s$', r'$s$', r'$s_{\rm low}$', r'$s_{\rm low}$',
                  r'DFT', r'DFT', r'ZPB'], loc='upper right')
    mplpp.ylabel(r'Signal')
    mplpp.xlabel(r'$n$')
    #mplpp.axis([-10.0, 10.0, 1.0E-2, 1.0E2])
    mplpp.grid(True)
    mplpp.savefig(fname, dpi=600,
                bbox_inches='tight', pad_inches=0.05)
    mplpp.close()


# __main__ ######################################################## __main__ #
if __name__ == '__main__':
    # Initialize
    f0 = 3.0
    f1 = 11.5
    f2 = 20.0
    fcut = 15.0
    fs = 1000.0
    N = 5000

    s, slow, sfdft, sfzpb = bbdftsig(f0, f1, f2, fcut, fs, N)
    n = np.arange(s.shape[0])

    # Fig. 1: full data set
    Nstart = 0
    Nstop = N
    fname = 'full.pdf'
    plotsigs(s, slow, sfdft, sfzpb, Nstart, Nstop, fname)

    # Fig. 2: beginning
    Nstart = 0
    Nstop = 150
    fname = 'beginning.pdf'
    plotsigs(s, slow, sfdft, sfzpb, Nstart, Nstop, fname)

    # Fig. 3: middle
    Nstart = np.floor(N/2.0) - 75
    Nstop = Nstart + 100
    fname = 'middle.pdf'
    plotsigs(s, slow, sfdft, sfzpb, Nstart, Nstop, fname)

    # Fig. 4: ending
    Nstart = N - 150
    Nstop = N
    fname = 'ending.pdf'
    plotsigs(s, slow, sfdft, sfzpb, Nstart, Nstop, fname)

$N=5000$$f_\mathrm{s} = 1000$$f_\mathrm{s}/N = 0.2\:$$f_0,f_1,f_2$$f_0=3$$f_1=11$$f_2=21$$f_\mathrm{cut}=15$

$s$$s_\mathrm{low}$$s_\mathrm{low}$$f_1$. Vì khá điển hình cho kiểu xử lý này, chúng tôi có một số khác biệt ở đầu và cuối chuỗi do hiệu ứng cạnh và thỏa thuận hợp lý tốt giữa cả hai loại lọc trong phần giữa.

$f_1$$f_1=11.5$

$s_\mathrm{low}$

Vì vậy, để kết luận, có thể sử dụng lọc trực tiếp bằng cách buộc các hệ số Fourier về 0, đôi khi cũng được thực hiện trong cảm biến nén để giảm sự hỗ trợ của tín hiệu để buộc độ thưa của tín hiệu. Tuy nhiên, có những hậu quả của điều này khi các lỗi gia tăng đặc biệt ở các cạnh của tín hiệu. Hơn nữa, ở trên là trường hợp tốt nhất trong đó toàn bộ tín hiệu được coi là một chuỗi. Nếu tín hiệu phải được phân chia trong các khung thời gian thì nó trở nên phức tạp vì khi đó chúng ta cần xem xét một số kỹ thuật cửa sổ hoặc kỹ thuật khác để đảm bảo tính liên tục của tín hiệu giữa các khung. Vì vậy, lời khuyên của tôi tương tự như một số bài đăng khác trong việc khuyến nghị sử dụng bình thường Butterworth / Elliptic / .. hoặc bất kỳ bộ lọc nào.

Các thùng zeroing trong FFT thực sự có thể làm tăng biên độ của các tần số khác gần nhưng không tập trung ở thùng zero-ed hoặc các thùng liền kề của nó. Sự gia tăng này có thể gây ra cắt.

Hơn nữa, nếu bạn đang thực hiện FFT bằng cách sử dụng các khối không đệm (và không được thêm chồng chéo) (trái ngược với toàn bộ bài hát trong một FFT lớn), mọi sửa đổi dữ liệu FFT sẽ bao quanh từ phía sau ra phía trước trình tự miền thời gian trong mỗi khối, do đó thêm các điểm gián đoạn kỳ lạ khác ở những vị trí sai.

Đây là bộ lọc băng thông FFT bin-zeroing nhanh và bẩn, với mã FFT là tốt.

void FFT(int n, int inverse, double *gRe, double *gIm, double *GRe, double *GIm)
{

    int m = 0;
    int p = 1;
    int j = 0;
    int i1=0;
    int k=0;
    double ca=0;
    double sa=0;
    int l1,l2,l3;
    double u1,u2;
    double t1 = 0;
    double t2 = 0;
    int i2=0;
    double z;
    /* Calculate m=log_2(n) */
    while(p < n)
    {
        p *= 2;
        m++;
    }
    /* Bit reversal */
    GRe[n - 1] = gRe[n - 1];
    GIm[n - 1] = gIm[n - 1];
    for(i1 = 0; i1 < n - 1; i1++)
    {
        GRe[i1] = gRe[j];
        GIm[i1] = gIm[j];
        k = n / 2;
        while(k <= j)
        {
            j -= k;
            k /= 2;
        }
        j += k;
    }
    /* Calculate the FFT */
    ca = -1.0;
    sa = 0.0;
    l1 = 1;
    l2 = 1;
    l3=0;
    for(l3 = 0; l3 < m; l3++)
    {
        l1 = l2;
        l2 *= 2;
        u1 = 1.0;
        u2 = 0.0;       
    for(j = 0; j < l1; j++)
        {
            i2=j;
            for(i2 = j; i2 < n; i2 += l2)
            {
                i1 = i2 + l1;
                t1 = u1 * GRe[i1] - u2 * GIm[i1];
                t2 = u1 * GIm[i1] + u2 * GRe[i1];
                GRe[i1] = GRe[i2] - t1;
                GIm[i1] = GIm[i2] - t2;
                GRe[i2] += t1;
                GIm[i2] += t2;
            }
            z =  u1 * ca - u2 * sa;
            u2 = u1 * sa + u2 * ca;
            u1 = z;
        }
        sa = sqrt((1.0 - ca) / 2.0);
        if(!inverse) sa =- sa;
        ca = sqrt((1.0 + ca) / 2.0);

    }
    /* Divide through n if it isn't the IDFT */
    if(!inverse)
    {
        int i3=0;
        for(i3 = 0; i3 < n; i3++)
        {
            GRe[i3] /= n;
            GIm[i3] /= n;
        }
    }
}


void mainfftBandPass(double *insamples, double *outsamples, unsigned long fftsize, long lowfreq, long highfreq, long srate)
{
    static double *inbuf=NULL;
    static double *realn=NULL;
    static double *imags=NULL;
    static double *spectr=NULL;
    static double *zer0=NULL;
    static double *olds=NULL;
    static double *infader=NULL;
    static double *outfader=NULL;
    int notched=(highfreq<lowfreq) ? 1 : 0;
    long incounter=0;
    /* treble is the highest baseband frequency */
    /* bass the the lowest baseband frequency */
    /* this function is called twice per FFT block */
    long midcounter=0;
    long outcounter=0;
    long bass=lowfreq*(fftsize/(double)srate);
    long treble=(highfreq)*(fftsize/(double)srate);
    static long halffft=2;
    static long old_fftsize=0;
    static short first=1;
    if(first==1 || fftsize!=old_fftsize)
    {
        if(inbuf)
             free(inbuf);
        if(realn)
            free(realn);
        if(imags)
            free(imags);
        if(spectr)
            free(spectr);
        if(zer0)
            free(zer0);
        if(olds)
            free(olds);
        if(infader)
            free(infader);
        if(outfader)
            free(outfader);
        infader=(double*)malloc(fftsize*sizeof(double));
        outfader=(double*)malloc(fftsize*sizeof(double));
        inbuf=(double*)malloc(fftsize*sizeof(double));
        realn=(double*)malloc(fftsize*sizeof(double));
        imags=(double*)malloc(fftsize*sizeof(double));
        spectr=(double*)malloc(fftsize*sizeof(double));
        zer0=(double*)malloc(fftsize*sizeof(double));
        olds=(double*)malloc(fftsize*sizeof(double));
        if((!inbuf) || (!realn) ||(!imags) ||(!spectr)||(!zer0)||(!ol   ds))
        {
            printf("Not enough memory for FFT!\n");
                    exit(1);
        }
        halffft=fftsize/2;
        long infade=0;
        long outfade=halffft;
        for(infade=0;infade<halffft;infade++)
        {
            outfade--;
            outfader[infade]=(0.5 * cos((infade) *  M_PI/(double)(halffft))+0.5);
            infader[outfade]=outfader[infade];
        }
        first=0;
    }
    memset(realn,0,sizeof(double)*fftsize);
    for(incounter=0;incounter<halffft;incounter++)
    {
        inbuf[incounter]=inbuf[incounter+halffft];
    }
    for(incounter=0;incounter<halffft;incounter++)
    {
        inbuf[incounter+halffft]=insamples[incounter];
    }
    for(incounter=0;incounter<fftsize;incounter++)
    {
        realn[incounter]=inbuf[incounter];
    }   
    memset(imags,0,sizeof(double)*fftsize);
    FFT(fftsize, 0, realn,imags, spectr,zer0);
    memset(realn,0,sizeof(double)*fftsize);
    memset(imags,0,sizeof(double)*fftsize);
    if(notched==0)
    {
        for(midcounter=bass;midcounter<treble;midcounter++)
        {
            realn[midcounter]=spectr[midcounter] * 2.0;
            imags[midcounter]= zer0[midcounter] * 2.0;
        }
        if(bass==0)
            realn[0]=spectr[0];

    }
    else if(notched==1)
    {
        for(midcounter=0;midcounter<halffft;midcounter++)
        {
            if((midcounter<treble) ||(midcounter>bass))
            {
                realn[midcounter]=spectr[midcounter] * 2.0;
                imags[midcounter]= zer0[midcounter] * 2.0;
            }
        }
        if(bass==0)
        {
            realn[0]=0;
        }
        else
        {
            realn[0]=spectr[0];
        }
    }
    FFT(fftsize, 1, realn, imags,spectr,zer0);
    for(outcounter=0;outcounter<halffft;outcounter++)
    {
        outsamples[outcounter]=(((spectr[outcounter] )*infader[outcounter])+(olds[outcounter+halffft]*outfader[outcounter])) ;
    }
    for(outcounter=0;outcounter<fftsize;outcounter++)
    {
        olds[outcounter]=spectr[outcounter];
    }
    memset(spectr,0,fftsize*sizeof(double));
    memset(zer0,0,fftsize*sizeof(double));
    old_fftsize=fftsize;
}

signed short mainbandpass(signed short input, double lowcut, double highcut,long rate,long fftsize)
{
    double retvalue=0;
    static double *insamp=NULL;
    static double *outsamp=NULL;
    static int first=1;
    static int q=0;
    if(first==1)
    {
            insamp=(double*)malloc(fftsize * sizeof(double));
            outsamp=(double*)malloc(fftsize * sizeof(double));
            if(insamp==NULL || outsamp==NULL)
            {
                   printf("Not enough memory for FFT buffers.\n");
                   exit(1);
            }
        memset(insamp,0,fftsize * sizeof(double));
        memset(outsamp,0,fftsize * sizeof(double));
        first=0;
    }

    insamp[q]=input;
    retvalue=outsamp[q];
    if(retvalue> 32767)
        retvalue=32767;
    if(retvalue <-32768)
        retvalue=-32768;
    q++;
    if(q>(fftsize/2)-1)
    {
        mainfftBandPass(insamp,outsamp, fftsize, lowcut,highcut,rate);
        q=0;
    }
    return (signed short)retvalue;
}

đối với mỗi mẫu của âm thanh đầu vào, hãy gọi mainbandpass với mẫu đầu vào và dải tần số bạn muốn giữ ở mức thấp và mức cao. Nếu lowcut lớn hơn highcut, kết quả sẽ là bộ lọc loại bỏ băng tần. Có sự tích chập tuần hoàn đang diễn ra, nhưng sẽ không có sự phát thải của dải nào tốt cho modem.