WFIR Class Reference

#include <wfir.h>

Public Types
enum	TPassTypeName { LPF, HPF, BPF, NOTCH }
enum	TWindowType {   wtNONE, wtKAISER, wtSINC, wtHANNING,   wtHAMMING, wtBLACKMAN, wtFLATTOP, wtBLACKMAN_HARRIS,   wtBLACKMAN_NUTTALL, wtNUTTALL, wtKAISER_BESSEL, wtTRAPEZOID,   wtGAUSS, wtSINE, wtTEST }

Static Public Member Functions
static void	BasicFIR (double *FirCoeff, int NumTaps, TPassTypeName PassType, double OmegaC, double BW, TWindowType WindowType, double WinBeta)

Static Private Member Functions
static void	WindowData (double *Data, int N, TWindowType WindowType, double Alpha, double Beta, bool UnityGain)
static double	Bessel (double x)
static double	Sinc (double x)

Detailed Description

Definition at line 58 of file wfir.h.

Member Enumeration Documentation

TPassTypeName

enum WFIR::TPassTypeName

Enumerator
LPF
HPF
BPF
NOTCH

Definition at line 61 of file wfir.h.

    {
        LPF, HPF, BPF, NOTCH
    };

TWindowType

enum WFIR::TWindowType

Enumerator
wtNONE
wtKAISER
wtSINC
wtHANNING
wtHAMMING
wtBLACKMAN
wtFLATTOP
wtBLACKMAN_HARRIS
wtBLACKMAN_NUTTALL
wtNUTTALL
wtKAISER_BESSEL
wtTRAPEZOID
wtGAUSS
wtSINE
wtTEST

Definition at line 66 of file wfir.h.

    {
        wtNONE,
        wtKAISER,
        wtSINC,
        wtHANNING,
        wtHAMMING,
        wtBLACKMAN,
        wtFLATTOP,
        wtBLACKMAN_HARRIS,
        wtBLACKMAN_NUTTALL,
        wtNUTTALL,
        wtKAISER_BESSEL,
        wtTRAPEZOID,
        wtGAUSS,
        wtSINE,
        wtTEST
    };

Member Function Documentation

BasicFIR()

void WFIR::BasicFIR ( double *  FirCoeff, int  NumTaps, TPassTypeName  PassType, double  OmegaC, double  BW, TWindowType  WindowType, double  WinBeta  )

static

Definition at line 19 of file wfir.cpp.

References BPF, cos(), HPF, LPF, M_PI, NOTCH, Sinc(), and WindowData().

Referenced by DevicePlutoSDRBox::formatFIRCoefficients().

{
    int j;
    double Arg, OmegaLow, OmegaHigh;

    switch (PassType)
    {
    case LPF:
        for (j = 0; j < NumTaps; j++)
        {
            Arg = (double) j - (double) (NumTaps - 1) / 2.0;
            FirCoeff[j] = OmegaC * Sinc(OmegaC * Arg * M_PI);
        }
        break;

    case HPF:
        if (NumTaps % 2 == 1) // Odd tap counts
        {
            for (j = 0; j < NumTaps; j++)
            {
                Arg = (double) j - (double) (NumTaps - 1) / 2.0;
                FirCoeff[j] = Sinc(Arg * M_PI)
                        - OmegaC * Sinc(OmegaC * Arg * M_PI);
            }
        }

        else  // Even tap counts
        {
            for (j = 0; j < NumTaps; j++)
            {
                Arg = (double) j - (double) (NumTaps - 1) / 2.0;
                if (Arg == 0.0)
                    FirCoeff[j] = 0.0;
                else
                    FirCoeff[j] = cos(OmegaC * Arg * M_PI) / M_PI / Arg
                            + cos(Arg * M_PI);
            }
        }
        break;

    case BPF:
        OmegaLow = OmegaC - BW / 2.0;
        OmegaHigh = OmegaC + BW / 2.0;
        for (j = 0; j < NumTaps; j++)
        {
            Arg = (double) j - (double) (NumTaps - 1) / 2.0;
            if (Arg == 0.0)
                FirCoeff[j] = 0.0;
            else
                FirCoeff[j] = (cos(OmegaLow * Arg * M_PI)
                        - cos(OmegaHigh * Arg * M_PI)) / M_PI / Arg;
        }
        break;

    case NOTCH: // If NumTaps is even for Notch filters, the response at Pi is attenuated.
        OmegaLow = OmegaC - BW / 2.0;
        OmegaHigh = OmegaC + BW / 2.0;
        for (j = 0; j < NumTaps; j++)
        {
            Arg = (double) j - (double) (NumTaps - 1) / 2.0;
            FirCoeff[j] = Sinc(Arg * M_PI)
                    - OmegaHigh * Sinc(OmegaHigh * Arg * M_PI)
                    - OmegaLow * Sinc(OmegaLow * Arg * M_PI);
        }
        break;
    }

    // WindowData can be used to window data before an FFT. When used for FIR filters we set
    // Alpha = 0.0 to prevent a flat top on the window and
    // set UnityGain = false to prevent the window gain from getting set to unity.
    WindowData(FirCoeff, NumTaps, WindowType, 0.0, WinBeta, false);

}

Here is the call graph for this function:

Here is the caller graph for this function:

Bessel()

double WFIR::Bessel ( double  x )

staticprivate

Definition at line 97 of file wfir.cpp.

References i.

Referenced by WindowData().

{
    double Sum = 0.0, XtoIpower;
    int i, j, Factorial;
    for (i = 1; i < 10; i++)
    {
        XtoIpower = pow(x / 2.0, (double) i);
        Factorial = 1;
        for (j = 1; j <= i; j++)
            Factorial *= j;
        Sum += pow(XtoIpower / (double) Factorial, 2.0);
    }
    return (1.0 + Sum);
}

Here is the caller graph for this function:

Sinc()

double WFIR::Sinc ( double  x )

staticprivate

Definition at line 115 of file wfir.cpp.

References sin().

Referenced by BasicFIR(), and WindowData().

{
    if (x > -1.0E-5 && x < 1.0E-5)
        return (1.0);
    return (sin(x) / x);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WindowData()

void WFIR::WindowData ( double *  Data, int  N, TWindowType  WindowType, double  Alpha, double  Beta, bool  UnityGain  )

staticprivate

Definition at line 173 of file wfir.cpp.

References Bessel(), cos(), exp(), M_2PI, M_PI, sin(), Sinc(), sqrt(), wtBLACKMAN, wtBLACKMAN_HARRIS, wtBLACKMAN_NUTTALL, wtFLATTOP, wtGAUSS, wtHAMMING, wtHANNING, wtKAISER, wtKAISER_BESSEL, wtNONE, wtNUTTALL, wtSINC, wtSINE, and wtTRAPEZOID.

Referenced by BasicFIR().

{
    if (WindowType == wtNONE)
        return;

    int j, M, TopWidth;
    double dM, *WinCoeff;

    if (WindowType == wtKAISER || WindowType == wtFLATTOP)
        Alpha = 0.0;

    if (Alpha < 0.0)
        Alpha = 0.0;
    if (Alpha > 1.0)
        Alpha = 1.0;

    if (Beta < 0.0)
        Beta = 0.0;
    if (Beta > 10.0)
        Beta = 10.0;

    WinCoeff = new (std::nothrow) double[N + 2];
    if (WinCoeff == 0)
    {
        std::cerr
                << "Failed to allocate memory in FFTFunctions::WindowFFTData() "
                << std::endl;
        return;
    }

    TopWidth = (int) (Alpha * (double) N);
    if (TopWidth % 2 != 0)
        TopWidth++;
    if (TopWidth > N)
        TopWidth = N;
    M = N - TopWidth;
    dM = M + 1;

    // Calculate the window for N/2 points, then fold the window over (at the bottom).
    // TopWidth points will be set to 1.
    if (WindowType == wtKAISER)
    {
        double Arg;
        for (j = 0; j < M; j++)
        {
            Arg = Beta * sqrt(1.0 - pow(((double) (2 * j + 2) - dM) / dM, 2.0));
            WinCoeff[j] = Bessel(Arg) / Bessel(Beta);
        }
    }

    else if (WindowType == wtSINC)  // Lanczos
    {
        for (j = 0; j < M; j++)
            WinCoeff[j] = Sinc((double) (2 * j + 1 - M) / dM * M_PI);
        for (j = 0; j < M; j++)
            WinCoeff[j] = pow(WinCoeff[j], Beta);
    }

    else if (WindowType == wtSINE)  // Hanning if Beta = 2
    {
        for (j = 0; j < M / 2; j++)
            WinCoeff[j] = sin((double) (j + 1) * M_PI / dM);
        for (j = 0; j < M / 2; j++)
            WinCoeff[j] = pow(WinCoeff[j], Beta);
    }

    else if (WindowType == wtHANNING)
    {
        for (j = 0; j < M / 2; j++)
            WinCoeff[j] = 0.5 - 0.5 * cos((double) (j + 1) * M_2PI / dM);
    }

    else if (WindowType == wtHAMMING)
    {
        for (j = 0; j < M / 2; j++)
            WinCoeff[j] = 0.54 - 0.46 * cos((double) (j + 1) * M_2PI / dM);
    }

    else if (WindowType == wtBLACKMAN)
    {
        for (j = 0; j < M / 2; j++)
        {
            WinCoeff[j] = 0.42 - 0.50 * cos((double) (j + 1) * M_2PI / dM)
                    + 0.08 * cos((double) (j + 1) * M_2PI * 2.0 / dM);
        }
    }

    // See: http://www.bth.se/fou/forskinfo.nsf/0/130c0940c5e7ffcdc1256f7f0065ac60/$file/ICOTA_2004_ttr_icl_mdh.pdf
    else if (WindowType == wtFLATTOP)
    {
        for (j = 0; j <= M / 2; j++)
        {
            WinCoeff[j] = 1.0
                    - 1.93293488969227 * cos((double) (j + 1) * M_2PI / dM)
                    + 1.28349769674027
                            * cos((double) (j + 1) * M_2PI * 2.0 / dM)
                    - 0.38130801681619
                            * cos((double) (j + 1) * M_2PI * 3.0 / dM)
                    + 0.02929730258511
                            * cos((double) (j + 1) * M_2PI * 4.0 / dM);
        }
    }

    else if (WindowType == wtBLACKMAN_HARRIS)
    {
        for (j = 0; j < M / 2; j++)
        {
            WinCoeff[j] = 0.35875 - 0.48829 * cos((double) (j + 1) * M_2PI / dM)
                    + 0.14128 * cos((double) (j + 1) * M_2PI * 2.0 / dM)
                    - 0.01168 * cos((double) (j + 1) * M_2PI * 3.0 / dM);
        }
    }

    else if (WindowType == wtBLACKMAN_NUTTALL)
    {
        for (j = 0; j < M / 2; j++)
        {
            WinCoeff[j] = 0.3535819
                    - 0.4891775 * cos((double) (j + 1) * M_2PI / dM)
                    + 0.1365995 * cos((double) (j + 1) * M_2PI * 2.0 / dM)
                    - 0.0106411 * cos((double) (j + 1) * M_2PI * 3.0 / dM);
        }
    }

    else if (WindowType == wtNUTTALL)
    {
        for (j = 0; j < M / 2; j++)
        {
            WinCoeff[j] = 0.355768
                    - 0.487396 * cos((double) (j + 1) * M_2PI / dM)
                    + 0.144232 * cos((double) (j + 1) * M_2PI * 2.0 / dM)
                    - 0.012604 * cos((double) (j + 1) * M_2PI * 3.0 / dM);
        }
    }

    else if (WindowType == wtKAISER_BESSEL)
    {
        for (j = 0; j <= M / 2; j++)
        {
            WinCoeff[j] = 0.402 - 0.498 * cos(M_2PI * (double) (j + 1) / dM)
                    + 0.098 * cos(2.0 * M_2PI * (double) (j + 1) / dM)
                    + 0.001 * cos(3.0 * M_2PI * (double) (j + 1) / dM);
        }
    }

    else if (WindowType == wtTRAPEZOID) // Rectangle for Alpha = 1  Triangle for Alpha = 0
    {
        int K = M / 2;
        if (M % 2)
            K++;
        for (j = 0; j < K; j++)
            WinCoeff[j] = (double) (j + 1) / (double) K;
    }

    // This definition is from http://en.wikipedia.org/wiki/Window_function (Gauss Generalized normal window)
    // We set their p = 2, and use Alpha in the numerator, instead of Sigma in the denominator, as most others do.
    // Alpha = 2.718 puts the Gauss window response midway between the Hanning and the Flattop (basically what we want).
    // It also gives the same BW as the Gauss window used in the HP 89410A Vector Signal Analyzer.
    // Alpha = 1.8 puts it quite close to the Hanning.
    else if (WindowType == wtGAUSS)
    {
        for (j = 0; j < M / 2; j++)
        {
            WinCoeff[j] = ((double) (j + 1) - dM / 2.0) / (dM / 2.0) * 2.7183;
            WinCoeff[j] *= WinCoeff[j];
            WinCoeff[j] = exp(-WinCoeff[j]);
        }
    }

    else // Error.
    {
        std::cerr << "Incorrect window type in WindowFFTData" << std::endl;
        delete[] WinCoeff;
        return;
    }

    // Fold the coefficients over.
    for (j = 0; j < M / 2; j++)
        WinCoeff[N - j - 1] = WinCoeff[j];

    // This is the flat top if Alpha > 0. Cannot be applied to a Kaiser or Flat Top.
    if (WindowType != wtKAISER && WindowType != wtFLATTOP)
    {
        for (j = M / 2; j < N - M / 2; j++)
            WinCoeff[j] = 1.0;
    }

    // This will set the gain of the window to 1. Only the Flattop window has unity gain by design.
    if (UnityGain)
    {
        double Sum = 0.0;
        for (j = 0; j < N; j++)
            Sum += WinCoeff[j];
        Sum /= (double) N;
        if (Sum != 0.0)
            for (j = 0; j < N; j++)
                WinCoeff[j] /= Sum;
    }

    // Apply the window to the data.
    for (j = 0; j < N; j++)
        Data[j] *= WinCoeff[j];

    delete[] WinCoeff;

}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• sdrbase/dsp/wfir.h
• sdrbase/dsp/wfir.cpp