Nsound::FilterIIR Class Reference

#include <Nsound/FilterIIR.h>

Inheritance diagram for Nsound::FilterIIR:

[legend]

List of all members.

Public Member Functions
	FilterIIR (const float64 &sample_rate, uint32 n_poles)
	FilterIIR (const FilterIIR &copy)
virtual	~FilterIIR ()
Buffer	designFrequencyResponse (const Buffer &frequency_response, const float64 &max_error=0.01, const int32 max_iterations=1000)
Buffer	designImpulseResponse (const Buffer &impulse_response, const float64 &max_error=0.01, const int32 max_iterations=1000)
AudioStream	filter (const AudioStream &x)
AudioStream	filter (const AudioStream &x, const Buffer &frequencies)
Buffer	filter (const Buffer &x)
Buffer	filter (const Buffer &x, const Buffer &frequencies)
float64	filter (const float64 &x)
float64	filter (const float64 &x, const float64 &frequency)
uint32	getKernelSize () const
Buffer	getImpulseResponse (const uint32 n_samples=8192)
FilterIIR &	operator= (const FilterIIR &rhs)
void	reset ()
AudioStream	filter (const AudioStream &x, const float64 &frequency)
Buffer	filter (const Buffer &x, const float64 &frequency)
Buffer	getFrequencyAxis (const uint32 n_fft=8192)
Buffer	getFrequencyResponse (const uint32 n_fft=8192)
Buffer	getPhaseResponse ()
float64	getSampleRate () const
void	plot (boolean show_phase=false)
Protected Types
enum	SignalType { FREQUENCY_RESSPONSE = 0, IMPULSE_RESPONSE }
Protected Member Functions
Buffer	designKernel (const Buffer &response, const float64 &max_rms_error, const int32 max_iterations, const SignalType type)
float64	getRMS (const Kernel &kernel, const Buffer &response, const SignalType type)
void	savePlot (const Kernel &k, const Buffer &response, uint32 n, const float64 &error)
Protected Attributes
uint32	n_poles_
Kernel *	kernel_
float64 *	x_history_
float64 *	x_ptr_
float64 *	x_end_ptr_
float64 *	y_history_
float64 *	y_ptr_
float64 *	y_end_ptr_
RngTausworthe *	rng_
float64	sample_rate_
float64	two_pi_over_sample_rate_
uint32	kernel_size_
Friends
std::ostream &	operator<< (std::ostream &out, const FilterIIR &rhs)

---

Detailed Description

WARNING: This is Experimental, you should not use this class as it may not be working or will change in future releases of Nsound.

Definition at line 52 of file FilterIIR.h.

---

Member Enumeration Documentation

enum Nsound::FilterIIR::SignalType [protected]

Enumerator:

FREQUENCY_RESSPONSE
IMPULSE_RESPONSE

Definition at line 149 of file FilterIIR.h.

    {
        FREQUENCY_RESSPONSE = 0,
        IMPULSE_RESPONSE
    };

---

Constructor & Destructor Documentation

FilterIIR::FilterIIR	(	const float64 &	sample_rate,
		uint32	n_poles
	)

Definition at line 58 of file FilterIIR.cc.

References kernel_, n_poles_, reset(), rng_, x_end_ptr_, x_history_, x_ptr_, y_end_ptr_, y_history_, and y_ptr_.

00062     :
00063     Filter(sample_rate),
00064     n_poles_(n_poles),
00065     kernel_(NULL),
00066     x_history_(NULL),
00067     x_ptr_(NULL),
00068     x_end_ptr_(NULL),
00069     y_history_(NULL),
00070     y_ptr_(NULL),
00071     y_end_ptr_(NULL),
00072     rng_(NULL)
00073 {
00074     kernel_ = new Kernel(n_poles_, n_poles_);
00075 
00076     x_history_ = new float64 [n_poles_ + 1];
00077     x_ptr_     = x_history_;
00078     x_end_ptr_ = x_history_ + n_poles_ + 1;
00079 
00080     y_history_ = new float64 [n_poles_ + 1];
00081     y_ptr_     = y_history_;
00082     y_end_ptr_ = y_history_ + n_poles_ + 1;
00083 
00084     rng_ = new RngTausworthe();
00085 
00086     reset();
}

FilterIIR::FilterIIR

(

const FilterIIR &

copy

)

Definition at line 90 of file FilterIIR.cc.

References n_poles_, reset(), rng_, x_history_, and y_history_.

00092     :
00093     Filter(copy.sample_rate_),
00094     n_poles_(copy.n_poles_),
00095     kernel_(NULL),
00096     x_history_(NULL),
00097     x_ptr_(NULL),
00098     x_end_ptr_(NULL),
00099     y_history_(NULL),
00100     y_ptr_(NULL),
00101     y_end_ptr_(NULL),
00102     rng_(NULL)
00103 {
00104     x_history_ = new float64 [n_poles_];
00105     y_history_ = new float64 [n_poles_];
00106 
00107     rng_ = new RngTausworthe();
00108 
00109     *this = copy;
00110 
00111     reset();
}

FilterIIR::~FilterIIR

(

)

[virtual]

Definition at line 115 of file FilterIIR.cc.

References kernel_, rng_, x_history_, and y_history_.

{
    delete kernel_;
    delete [] x_history_;
    delete [] y_history_;

    delete rng_;
}

---

Member Function Documentation

Buffer FilterIIR::designFrequencyResponse	(	const Buffer &	frequency_response,
		const float64 &	max_error = 0.01,
		const int32	max_iterations = 1000
	)

Designs a filter kernel using a genetic algorithm that trys to match the provided frequency response. Designs a filter kernel that trys to match the provide frequency response. The method uses a genetic algorithm to arrive at a fit solution and retuns the error per generation. The error signal is nice to plot to get an idea of how quickly the solution was found.

Definition at line 127 of file FilterIIR.cc.

References designKernel(), and FREQUENCY_RESSPONSE.

Referenced by main().

{
    return designKernel(
        frequency_response,
        max_error,
        max_iterations,
        FREQUENCY_RESSPONSE);
}

Buffer FilterIIR::designImpulseResponse	(	const Buffer &	impulse_response,
		const float64 &	max_error = 0.01,
		const int32	max_iterations = 1000
	)

Designs a filter kernel using a genetic algorithm that trys to match the provided impulse response. Designs a filter kernel that trys to match the provide impulse response The method uses a genetic algorithm to arrive at a fit solution and retuns the error per generation. The error signal is nice to plot to get an idea of how quickly the solution was found.

Definition at line 142 of file FilterIIR.cc.

References designKernel(), and IMPULSE_RESPONSE.

{
    return designKernel(
        impulse_response,
        max_error,
        max_iterations,
        IMPULSE_RESPONSE);
}

AudioStream Nsound::FilterIIR::filter

(

const AudioStream &

x

)

[inline]

Reimplemented from Nsound::Filter.

Definition at line 95 of file FilterIIR.h.

Referenced by filter().

    { return Filter::filter(x);};

AudioStream Nsound::FilterIIR::filter	(	const AudioStream &	x,
		const Buffer &	frequencies
	)			[inline]

Reimplemented from Nsound::Filter.

Definition at line 100 of file FilterIIR.h.

References filter().

    { return Filter::filter(x);};

Buffer Nsound::FilterIIR::filter

(

const Buffer &

x

)

[inline]

Reimplemented from Nsound::Filter.

Definition at line 105 of file FilterIIR.h.

References filter().

    {return Filter::filter(x);};

Buffer Nsound::FilterIIR::filter	(	const Buffer &	x,
		const Buffer &	frequencies
	)			[inline]

Reimplemented from Nsound::Filter.

Definition at line 110 of file FilterIIR.h.

References filter().

Referenced by filter().

    {return filter(x);};

float64 FilterIIR::filter

(

const float64 &

x

)

[virtual]

Implements Nsound::Filter.

Definition at line 629 of file FilterIIR.cc.

References Nsound::Kernel::getA(), Nsound::Kernel::getB(), kernel_, n_poles_, x_end_ptr_, x_history_, x_ptr_, y_end_ptr_, y_history_, and y_ptr_.

{
    // Write x to history
    *x_ptr_ = x;

    // Increment history pointer
    ++x_ptr_;

    // Bounds check
    if(x_ptr_ >= x_end_ptr_)
    {
        x_ptr_ = x_history_;
    }

    float64 y = 0.0;
    float64 * x_hist = x_ptr_;
    const float64 * bb = kernel_->getB();
    const float64 * b_end = bb + n_poles_;
    for(const float64 * b = bb; b < b_end; ++b)
    {
        // When we enter this loop, x_hist is pointing at x[n + 1]
        --x_hist;

        // Bounds check
        if(x_hist < x_history_)
        {
            x_hist = x_end_ptr_ - 1;
        }

        y += *b * *x_hist;
    }

    float64 * y_hist = y_ptr_;
    const float64 * aa = kernel_->getA();
    const float64 * a_end = aa + n_poles_;
    for(const float64 * a = aa + 1; a < a_end; ++a)
    {
        // When we enter this loop, y_hist is pointing at y[n + 1]
        --y_hist;

        // Bounds check
        if(y_hist < y_history_)
        {
            y_hist = y_end_ptr_ - 1;
        }

        y += *a * *y_hist;
    }

    // insert output into history buffer
    *y_ptr_ = y;

    // Increment history pointer
    ++y_ptr_;

    // Bounds check
    if(y_ptr_ >= y_end_ptr_)
    {
        y_ptr_ = y_history_;
    }

    return y;
}

float64 FilterIIR::filter	(	const float64 &	x,
		const float64 &	frequency
	)			[virtual]

Implements Nsound::Filter.

Definition at line 696 of file FilterIIR.cc.

References filter().

{
    return FilterIIR::filter(x);
}

uint32 Nsound::FilterIIR::getKernelSize

(

)

const [inline, virtual]

Reimplemented from Nsound::Filter.

Definition at line 123 of file FilterIIR.h.

References n_poles_.

{return n_poles_;};

Buffer Nsound::FilterIIR::getImpulseResponse

(

const uint32

n_samples = 8192

)

[inline]

Reimplemented from Nsound::Filter.

Definition at line 127 of file FilterIIR.h.

References reset().

Referenced by getRMS().

    { reset(); return Filter::getImpulseResponse(n_samples); };

FilterIIR & FilterIIR::operator=

(

const FilterIIR &

rhs

)

Definition at line 704 of file FilterIIR.cc.

References kernel_, n_poles_, rng_, Nsound::Filter::sample_rate_, x_history_, and y_history_.

{
    if(this == &rhs)
    {
        return *this;
    }

    sample_rate_ = rhs.sample_rate_;

    if(n_poles_ != rhs.n_poles_)
    {
        delete [] x_history_;
        delete [] y_history_;

        n_poles_ = rhs.n_poles_;

        x_history_ = new float64 [n_poles_];
        y_history_ = new float64 [n_poles_];
    }

    memcpy(x_history_, rhs.x_history_, sizeof(float64) * n_poles_);
    memcpy(y_history_, rhs.y_history_, sizeof(float64) * n_poles_);

    *kernel_ = *rhs.kernel_;
    *rng_ = *rhs.rng_;

    return *this;
}

void FilterIIR::reset

(

)

[virtual]

Implements Nsound::Filter.

Definition at line 746 of file FilterIIR.cc.

References n_poles_, x_history_, x_ptr_, y_history_, and y_ptr_.

Referenced by FilterIIR(), getImpulseResponse(), getRMS(), and savePlot().

{
    memset(x_history_, 0, sizeof(float64) * (n_poles_ + 1));
    memset(y_history_, 0, sizeof(float64) * (n_poles_ + 1));

    x_ptr_ = x_history_;
    y_ptr_ = y_history_;
}

Buffer FilterIIR::designKernel	(	const Buffer &	ref_response,
		const float64 &	max_rms_error,
		const int32	max_iterations,
		const SignalType	type
	)			[protected]

Designs a filter kernel that trys to match the provide frequency response. Designs a filter kernel that trys to match the provide frequency response. The method uses a genetic algorithm to arrive at a fit solution and retuns the error per generation. The error signal is nice to plot to get an idea of how quickly the solution was found.

This method is VERY EXPERMENTAL! Use at your own risk!

Definition at line 251 of file FilterIIR.cc.

References Nsound::Kernel::ga_interleave(), Nsound::Kernel::ga_swap_ab(), Nsound::RngTausworthe::get(), Nsound::Kernel::getA(), Nsound::Kernel::getB(), Nsound::Buffer::getLength(), getRMS(), Nsound::Kernel::getSum(), kernel_, n_poles_, PRINT_LINE, Nsound::Kernel::randomize(), rng_, Nsound::Kernel::setA(), and Nsound::Kernel::setB().

Referenced by designFrequencyResponse(), and designImpulseResponse().

{
    // The reference response curve must be a power of two to guarentee correct
    // comparision to the designed kernel response.

    uint32 p2 = 2;
    uint32 ref_size = ref_response.getLength();

    while( p2 < ref_size )
    {
        p2 <<= 1;
    }

    if(ref_size != p2)
    {
        cerr << PRINT_LINE
             << "The reference response Buffer length must be a power of 2"
             << " (" << ref_size << " != " << p2 << ")"
             << endl
             << "Aborting kernel design."
             << endl;
        ::exit(1);
    }

    // Create the initial 2 parents
    Kernel * mom = new Kernel(n_poles_, n_poles_);

    float64 LARGE_RMS = 1.0;
    float64 STALE_RMS = 0.001;

    float64 rms_error = LARGE_RMS;
    int32 dead_count = 0;
    while(rms_error > LARGE_RMS && dead_count < 1000)
    {
        mom->randomize(-0.1, 0.1);
        rms_error = getRMS(*mom, ref_response, type);
        dead_count++;
    }

    if(rms_error > LARGE_RMS)
    {
        cerr << PRINT_LINE
             << "RMS = " << rms_error << endl;

        cerr << "Could not find a stable random kernel, aborting kernel design."
             << endl;

        delete mom;

        ::exit(1);
    }

    Kernel * dad = new Kernel(n_poles_, n_poles_);

    dad->randomize(-0.1, 0.1);

    int32 N_CHILDREN = 14;

    // Allocate N children
    Kernel * child[N_CHILDREN];

    for(int32 i = 0; i < N_CHILDREN; ++i)
    {
        child[i] = new Kernel(n_poles_, n_poles_);
    }

    Buffer rms_history;

    rms_history << rms_error;

    float64 dad_rms_error = getRMS(*dad, ref_response, type);

    cout << std::setprecision(10)
         << "mom's RMS = " << rms_error << endl
         << "dad's RMS = " << dad_rms_error << endl;

    float64 rms_error1 = LARGE_RMS;
    float64 rms_error2 = LARGE_RMS;

    Kernel * low1 = NULL;
    Kernel * low2 = NULL;

    float64 last_rms_error = rms_error;
    int32 stale_count = 0;
    int32 major_stale_count = 0;
    int32 count = 0;

    while(count < max_iterations && rms_error > max_rms_error)
    {
        ++count;

        // First two children just swap mom & dads a & b coeffs;
        *child[0] = *mom;
        *child[1] = *dad;
        child[0]->ga_swap_ab(*child[1]);

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // Next two children interleave coeffs
        *child[2] = *mom;
        *child[3] = *dad;

        child[2]->ga_interleave(*child[3]);

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // The next two children randomly mutate one coeff from mom & dad
        *child[4] = *mom;
        *child[5] = *dad;

        for(uint32 i = 4; i < 6; ++i)
        {
            float64 delta = rng_->get(-0.1f, 0.1f);

            uint32 index = rng_->get(0, n_poles_);

            child[i]->setB(child[i]->getB(index) + delta, index);

            delta = rng_->get(-0.1f, 0.1f);

            index = rng_->get(0, n_poles_);

            child[i]->setA(child[i]->getA(index) + delta, index);
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // The next two children randomly mutate sign
        *child[6] = *mom;
        *child[7] = *dad;

        for(uint32 i = 6; i < 8; ++i)
        {
            uint32 index = rng_->get(0, n_poles_);

            float64 a_or_b = rng_->get(-1.0f, 1.0f);

            if(a_or_b > 0.0)
            {
                child[i]->setB(child[i]->getB(index) * -1.0, index);
            }
            else
            {
                child[i]->setA(child[i]->getA(index) * -1.0, index);
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // These two children randomly multiply one coef.
        *child[8] = *mom;
        *child[9] = *dad;

        for(uint32 i = 8; i < 10; ++i)
        {
            uint32 index = rng_->get(0, n_poles_);

            float64 a_or_b = rng_->get(-1.0f, 1.0f);

            float64 delta = rng_->get(-0.1f, 0.1f);

            if(a_or_b > 0.0)
            {
                child[i]->setB(child[i]->getB(index) * delta, index);
            }
            else
            {
                child[i]->setA(child[i]->getA(index) * delta, index);
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // These two children randomly swap mom & dad coeffs
        *child[10] = *mom;
        *child[11] = *dad;

        uint32 start_index = rng_->get(0, n_poles_);
        uint32 stop_index  = rng_->get(0, n_poles_);

        if(start_index < 0) start_index = 0;
        if(stop_index >= n_poles_) stop_index = n_poles_ - 1;

        if(start_index > stop_index)
        {
            uint32 temp = start_index;
            start_index = stop_index;
            stop_index = temp;
        }

        for(uint32 j = start_index; j < stop_index; ++j)
        {
            child[10]->setB(dad->getB(j), j);
            child[11]->setB(mom->getB(j), j);
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        start_index = rng_->get(0, n_poles_);
        stop_index  = rng_->get(0, n_poles_);

        if(start_index < 0) start_index = 0;
        if(stop_index >= n_poles_) stop_index = n_poles_ - 1;

        if(start_index > stop_index)
        {
            int32 temp = start_index;
            start_index = stop_index;
            stop_index = temp;
        }

        for(uint32 j = start_index; j < stop_index; ++j)
        {
            child[10]->setA(dad->getA(j), j);
            child[11]->setA(mom->getA(j), j);
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // These two children randomly add mom & dad coeffs
        *child[12] = *mom;
        *child[13] = *dad;

        for(uint32 i = 12; i < 14; ++i)
        {
            for(uint32 j = 0; j < n_poles_; ++j)
            {
                child[i]->setB(child[i]->getB(j) + rng_->get(-0.1f, 0.1f), j);
                child[i]->setA(child[i]->getA(j) + rng_->get(-0.1f, 0.1f), j);
            }
        }

        // Score the kiddies.

        rms_error1 = getRMS(*mom, ref_response, type);
        rms_error2 = getRMS(*dad, ref_response, type);

        low1 = mom;
        low2 = dad;

        for(int32 i = 0; i < N_CHILDREN; ++i)
        {
            float64 rms = getRMS(*child[i], ref_response, type);

            if(rms > LARGE_RMS) continue;

            if(rms < rms_error1)
            {
                rms_error1 = rms;
                low1 = child[i];
            }
            else if(rms < rms_error2)
            {
                rms_error2 = rms;
                low2 = child[i];
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        *mom = *low1;
        *dad = *low2;

        rms_error     = getRMS(*mom, ref_response, type);
        dad_rms_error = getRMS(*dad, ref_response, type);

        rms_history << rms_error;

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl;
        #endif

        // Check if dad is unstable.
        if(dad_rms_error > LARGE_RMS)
        {
            cout << PRINT_LINE << "dad's RMS > 10, ballistic!" << endl;
            dad->randomize(-0.01f, 0.01f);
        }

        // Check if our evolution is getting stale
        if(std::fabs(rms_error - last_rms_error) < STALE_RMS)
        {
            ++stale_count;
        }
        else
        {
            stale_count = 0;
        }

        last_rms_error = rms_error;

        if(count % 200 == 0)
        {
            cout << "Generation " << count << endl
                 << "    1st maximum RMS = " << rms_error     << endl
                 << "    2nd maximum RMS = " << dad_rms_error << endl;
//~                  << "    major_stale_count = " << major_stale_count << endl;
        }

        if(stale_count > 6)
        {
            for(uint32 i = 0; i < n_poles_; ++i)
            {
                dad->setB(dad->getB(i) + rng_->get(-0.10501f, 0.10501f), i);
                dad->setA(dad->getA(i) + rng_->get(-0.10501f, 0.10501f), i);
            }

            stale_count = 0;
            ++major_stale_count;

            if(major_stale_count > 1)
            {
                for(uint32 i = 0; i < n_poles_; ++i)
                {
                    dad->setB(dad->getB(i) * rng_->get(-0.501f, 0.501f), i);
                    dad->setA(dad->getA(i) * rng_->get(-0.501f, 0.501f), i);
                }

                major_stale_count = 0;
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl;
        #endif

    }

    cout << "count = " << count << "  RMS = " << rms_error << endl;

    // copy mom into the filter.
    *kernel_ = *mom;

    for(int32 i = 0; i < N_CHILDREN; ++i)
    {
        delete child[i];
    }

    delete mom;
    delete dad;

    return rms_history;
}

float64 FilterIIR::getRMS	(	const Kernel &	kernel,
		const Buffer &	response,
		const SignalType	type
	)			[protected]

Definition at line 213 of file FilterIIR.cc.

References FREQUENCY_RESSPONSE, Nsound::Filter::getFrequencyResponse(), getImpulseResponse(), Nsound::Buffer::getLength(), Nsound::Buffer::getSum(), kernel_, and reset().

Referenced by designKernel().

{
    Kernel * orig_k = kernel_;

    kernel_ = const_cast<Kernel *>(&k);

    reset();

    Buffer r;

    if(type == FREQUENCY_RESSPONSE)
    {
        r = getFrequencyResponse(ref_response.getLength() * 2);
    }
    else
    {
        r = getImpulseResponse(ref_response.getLength() * 2);
    }

    kernel_ = orig_k;

    Buffer delta = ref_response - r;
    delta *= delta;

    float64 rms = delta.getSum() / static_cast<float64>(delta.getLength());

    rms = ::sqrt(rms);

    return rms;
}

void FilterIIR::savePlot	(	const Kernel &	k,
		const Buffer &	response,
		uint32	n,
		const float64 &	error
	)			[protected]

Definition at line 758 of file FilterIIR.cc.

References Nsound::Plotter::figure(), Nsound::Filter::getFrequencyAxis(), Nsound::Filter::getFrequencyResponse(), Nsound::Buffer::getLength(), Nsound::Buffer::getMax(), kernel_, Nsound::Plotter::plot(), reset(), Nsound::Plotter::text(), Nsound::Plotter::title(), Nsound::Plotter::xlabel(), Nsound::Plotter::xlim(), Nsound::Plotter::ylabel(), and Nsound::Plotter::ylim().

{
    Kernel * orig_k = kernel_;

    kernel_ = const_cast<Kernel *>(&k);

    Buffer fr_ref = fr_reference;
    Buffer fr = getFrequencyResponse();
    Buffer faxis = getFrequencyAxis();

    while(fr_ref.getLength() < fr.getLength())
    {
        fr_ref << 0.0;
    }

    float64 max = fr_ref.getMax();

    Plotter pylab;

    pylab.figure();
    pylab.plot(faxis, fr_ref);
    pylab.plot(faxis, fr);

    pylab.xlabel("Frequency Hz");
    pylab.ylabel("Frequency Response");

    char buffer[256];

    sprintf(buffer, "Generation %06d", n);

    pylab.title(std::string(buffer));

    pylab.xlim(0.0, faxis[fr_reference.getLength() - 1]);
    pylab.ylim(0.0, 1.1 * max);

    sprintf(buffer, "Error = %5.2f", error);

    pylab.text(
        faxis[static_cast<uint32>(faxis.getLength() * 0.66)],
        0.66,
        std::string(buffer));

    sprintf(buffer, "generation_%06d.png", n);

//~    pylab.savefig(std::string(buffer));

    kernel_ = orig_k;

    reset();
}

AudioStream Filter::filter	(	const AudioStream &	x,
		const float64 &	frequency
	)			[inherited]

Reimplemented in Nsound::FilterAllPass, Nsound::FilterBandPassIIR, Nsound::FilterBandRejectIIR, Nsound::FilterDelay, Nsound::FilterFlanger, Nsound::FilterHighPassFIR, Nsound::FilterHighPassIIR, Nsound::FilterLeastSquaresFIR, Nsound::FilterLowPassFIR, Nsound::FilterLowPassIIR, and Nsound::FilterStageIIR.

Definition at line 72 of file Filter.cc.

References Nsound::Filter::filter(), Nsound::AudioStream::getNChannels(), Nsound::AudioStream::getSampleRate(), and Nsound::Filter::reset().

{
    reset();

    uint32 n_channels = x.getNChannels();

    AudioStream y(x.getSampleRate(), n_channels);

    for(uint32 channel = 0; channel < n_channels; ++channel)
    {
        y[channel] = filter(x[channel], frequency);
    }

    return y;
}

Buffer Filter::filter	(	const Buffer &	x,
		const float64 &	frequency
	)			[inherited]

Reimplemented in Nsound::FilterAllPass, Nsound::FilterBandPassIIR, Nsound::FilterBandRejectIIR, Nsound::FilterDelay, Nsound::FilterFlanger, Nsound::FilterHighPassFIR, Nsound::FilterHighPassIIR, Nsound::FilterLeastSquaresFIR, Nsound::FilterLowPassFIR, Nsound::FilterLowPassIIR, and Nsound::FilterStageIIR.

Definition at line 129 of file Filter.cc.

References Nsound::Buffer::begin(), Nsound::Buffer::end(), Nsound::Filter::filter(), Nsound::Buffer::getLength(), and Nsound::Filter::reset().

{
    reset();

    Buffer::const_iterator itor = x.begin();
    Buffer::const_iterator end = x.end();

    Buffer y(x.getLength());

    while(itor != end)
    {
        y << filter(*itor, frequency);

        ++itor;
    }

    return y;
}

Buffer Filter::getFrequencyAxis

(

const uint32

n_fft = 8192

)

[inherited]

Definition at line 176 of file Filter.cc.

References Nsound::FFTransform::roundUp2(), and Nsound::Filter::sample_rate_.

Referenced by main(), Nsound::Filter::plot(), and savePlot().

{
    uint32 fft_chunk_size = FFTransform::roundUp2(
        static_cast<int32>(n_fft));

    uint32 n_samples = fft_chunk_size / 2 + 1;

    float64 f_step = (1.0 / (static_cast<float64>(fft_chunk_size) / 2.0))
                   * (sample_rate_ / 2.0);

    Buffer f_axis;

    float64 f = 0.0;

    for(uint32 i = 0; i < n_samples; ++i)
    {
        f_axis << f;
        f += f_step;
    }

    return f_axis;
};

Buffer Filter::getFrequencyResponse

(

const uint32

n_fft = 8192

)

[inherited]

Definition at line 202 of file Filter.cc.

References Nsound::FFTransform::fft(), Nsound::Filter::getImpulseResponse(), and Nsound::Filter::sample_rate_.

Referenced by Nsound::FilterBandPassIIR::FilterBandPassIIR(), FilterLeastSquaresFIR_UnitTest(), getRMS(), main(), Nsound::Filter::plot(), and savePlot().

{
    FFTransform fft(sample_rate_);

//~    fft.setWindow(HANNING);

    FFTChunkVector vec;

    vec = fft.fft(getImpulseResponse(), n_fft);

    return vec[0].getMagnitude();
}

Buffer Filter::getPhaseResponse

(

)

[inherited]

Definition at line 239 of file Filter.cc.

References Nsound::FFTransform::fft(), Nsound::Filter::getImpulseResponse(), Nsound::Buffer::getLength(), Nsound::Filter::sample_rate_, and Nsound::Buffer::subbuffer().

Referenced by Nsound::Filter::plot().

{
    uint32 n_samples = static_cast<uint32>(sample_rate_ * 2);

    FFTransform fft(n_samples);

    FFTChunkVector vec;

    vec = fft.fft(getImpulseResponse(), n_samples);

    Buffer phase = vec[0].getPhase();

    return phase.subbuffer(0, phase.getLength() / 2 + 1);
}

float64 Nsound::Filter::getSampleRate

(

)

const [inline, inherited]

Definition at line 117 of file Filter.h.

References Nsound::Filter::sample_rate_.

{ return sample_rate_; };

void Filter::plot

(

boolean

show_phase = false

)

[inherited]

Definition at line 257 of file Filter.cc.

References Nsound::Plotter::figure(), Nsound::Buffer::getdB(), Nsound::Filter::getFrequencyAxis(), Nsound::Filter::getFrequencyResponse(), Nsound::Buffer::getMax(), Nsound::Filter::getPhaseResponse(), Nsound::Plotter::plot(), Nsound::Plotter::subplot(), Nsound::Plotter::xlabel(), Nsound::Plotter::ylabel(), and Nsound::Plotter::ylim().

Referenced by main().

{
    Buffer x = getFrequencyAxis();
    Buffer fr = getFrequencyResponse().getdB();

    Plotter pylab;

    pylab.figure();

    int subplot_int = 111;

    if(show_phase)
    {
        subplot_int = 211;
    }

    pylab.subplot(subplot_int);

    // Frequency response
    pylab.plot(x,fr, "blue");

    pylab.xlabel("Frequency (Hz)");
    pylab.ylabel("Frequency Response (dB)");

    // Phase response
    if(show_phase)
    {
        pylab.subplot(subplot_int + 1);

        Buffer pr = getPhaseResponse().getdB();

        pylab.plot(x,pr);

        pylab.xlabel("Frequency (Hz)");
        pylab.ylabel("Phase Response (dB)");
    }

    float64 ymax = fr.getMax();
    float64 height = ymax - -60.0;

    pylab.ylim(-60.0, ymax + 0.05 * height);

}

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	out,
		const FilterIIR &	rhs
	)			[friend]

Prints the coeffents.

---

Member Data Documentation

uint32 Nsound::FilterIIR::n_poles_ [protected]

Definition at line 184 of file FilterIIR.h.

Referenced by designKernel(), filter(), FilterIIR(), getKernelSize(), operator=(), and reset().

Kernel* Nsound::FilterIIR::kernel_ [protected]

Definition at line 186 of file FilterIIR.h.

Referenced by designKernel(), filter(), FilterIIR(), getRMS(), Nsound::operator<<(), operator=(), savePlot(), and ~FilterIIR().

float64* Nsound::FilterIIR::x_history_ [protected]

Definition at line 188 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), operator=(), reset(), and ~FilterIIR().

float64* Nsound::FilterIIR::x_ptr_ [protected]

Definition at line 189 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), and reset().

float64* Nsound::FilterIIR::x_end_ptr_ [protected]

Definition at line 190 of file FilterIIR.h.

Referenced by filter(), and FilterIIR().

float64* Nsound::FilterIIR::y_history_ [protected]

Definition at line 192 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), operator=(), reset(), and ~FilterIIR().

float64* Nsound::FilterIIR::y_ptr_ [protected]

Definition at line 193 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), and reset().

float64* Nsound::FilterIIR::y_end_ptr_ [protected]

Definition at line 194 of file FilterIIR.h.

Referenced by filter(), and FilterIIR().

RngTausworthe* Nsound::FilterIIR::rng_ [protected]

Definition at line 196 of file FilterIIR.h.

Referenced by designKernel(), FilterIIR(), operator=(), and ~FilterIIR().

float64 Nsound::Filter::sample_rate_ [protected, inherited]

Definition at line 131 of file Filter.h.

Referenced by Nsound::FilterPhaser::filter(), Nsound::FilterDelay::filter(), Nsound::FilterCombLowPassFeedback::filter(), Nsound::FilterAllPass::FilterAllPass(), Nsound::FilterCombLowPassFeedback::FilterCombLowPassFeedback(), Nsound::FilterDelay::FilterDelay(), Nsound::FilterFlanger::FilterFlanger(), Nsound::FilterPhaser::FilterPhaser(), Nsound::FilterSlinky::FilterSlinky(), Nsound::Filter::getFrequencyAxis(), Nsound::Filter::getFrequencyResponse(), Nsound::Filter::getPhaseResponse(), Nsound::Filter::getSampleRate(), Nsound::FilterStageIIR::makeIIRKernelHelper(), Nsound::FilterStageIIR::makeKernel(), Nsound::FilterParametricEqualizer::makeKernel(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::FilterHighPassFIR::makeKernel(), Nsound::FilterBandPassVocoder::makeKernel(), Nsound::FilterPhaser::operator=(), Nsound::FilterLeastSquaresFIR::operator=(), operator=(), Nsound::FilterFlanger::operator=(), Nsound::FilterTone::plot(), Nsound::FilterPhaser::plot(), Nsound::FilterParametricEqualizer::plot(), Nsound::FilterLowPassIIR::plot(), Nsound::FilterLowPassFIR::plot(), Nsound::FilterLeastSquaresFIR::plot(), Nsound::FilterHighPassIIR::plot(), Nsound::FilterHighPassFIR::plot(), Nsound::FilterFlanger::plot(), Nsound::FilterCombLowPassFeedback::plot(), Nsound::FilterBandRejectIIR::plot(), Nsound::FilterBandRejectFIR::plot(), Nsound::FilterBandPassIIR::plot(), Nsound::FilterBandPassFIR::plot(), Nsound::FilterAllPass::plot(), Nsound::FilterLowPassIIR::setCutoff(), and Nsound::FilterLeastSquaresFIR::setWindow().

float64 Nsound::Filter::two_pi_over_sample_rate_ [protected, inherited]

Definition at line 132 of file Filter.h.

Referenced by Nsound::FilterTone::makeKernel(), Nsound::FilterParametricEqualizer::makeKernel(), and Nsound::FilterLowPassFIR::makeKernel().

uint32 Nsound::Filter::kernel_size_ [protected, inherited]

Definition at line 133 of file Filter.h.

Referenced by Nsound::FilterLowPassFIR::filter(), Nsound::FilterLeastSquaresFIR::filter(), Nsound::FilterBandPassFIR::FilterBandPassFIR(), Nsound::FilterBandPassIIR::FilterBandPassIIR(), Nsound::FilterBandRejectIIR::FilterBandRejectIIR(), Nsound::FilterHighPassIIR::FilterHighPassIIR(), Nsound::FilterLeastSquaresFIR::FilterLeastSquaresFIR(), Nsound::FilterLowPassFIR::FilterLowPassFIR(), Nsound::FilterLowPassIIR::FilterLowPassIIR(), Nsound::FilterLeastSquaresFIR::getKernel(), Nsound::Filter::getKernelSize(), Nsound::FilterLowPassFIR::makeKernel(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::FilterHighPassFIR::makeKernel(), Nsound::FilterBandRejectFIR::makeKernel(), Nsound::FilterLeastSquaresFIR::operator=(), Nsound::FilterLowPassFIR::plot(), Nsound::FilterLeastSquaresFIR::plot(), Nsound::FilterHighPassFIR::plot(), Nsound::FilterBandRejectFIR::plot(), Nsound::FilterLowPassFIR::reset(), Nsound::FilterLeastSquaresFIR::reset(), Nsound::FilterHighPassFIR::reset(), Nsound::FilterLeastSquaresFIR::setKernel(), Nsound::FilterLeastSquaresFIR::setWindow(), and Nsound::FilterHighPassFIR::spectraReversal_().

---

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

• Nsound/FilterIIR.h
• Nsound/FilterIIR.cc