ApplyFilter.cpp

Go to the documentation of this file.

#include "ApplyFilter.h"
#include <boost/progress.hpp>

ApplyFilter::ApplyFilter(AdaptiveFilter &TheFilter, bool keephistory):
showprogress(false),
wanthistory(keephistory),
shift(0),
Filter(TheFilter),
weightsaveintervall(TheFilter.GetOutputLength())
{
}

ApplyFilter::~ApplyFilter()
{
}

/*! Return a matrix with the values of the weights at iterations specified by weightsaveintervall.
 * Internally we use a std::vector of ublas::vector and we construct the matrix in this routine.
 * Therefore we return a copy and the access is computationally reasonably expensive. Mostly
 * needed for final display of weights.
 */
gplib::rmat ApplyFilter::GetWeightHistory()
{
        if (WeightHistory.empty())
                throw CFatalException("Trying to access empty Weight History");
        const size_t xsize =WeightHistory.size();
        const size_t ysize = WeightHistory.front().size();
        gplib::rmat temp(xsize,ysize);
        for (size_t i = 0; i < xsize; ++i)
                for (size_t j = 0; j < ysize; ++j)
                        temp(i,j) = WeightHistory.at(i)(j);
        return temp;    
}

void ApplyFilter::AddInputChannel(TimeSeriesComponent &Channel)
{
        if (!InputChannels.empty() && Channel.GetData().size() != InputChannels.front()->GetData().size())
                        throw CFatalException("Input channel has incompatible size to first channel");
        InputChannels.push_back(&Channel);
}

void ApplyFilter::AddReferenceChannel(TimeSeriesComponent &Channel)
{
        if (RefChannels.size() >= Filter.GetOutputLength()) // if we already have enough reference channels
                throw CFatalException("Trying to add more reference channels than  permitted by Adaptive Filter class");
        if (!RefChannels.empty() && Channel.GetData().size() != RefChannels.front()->GetData().size())
                        throw CFatalException("Ref channel has incompatible size to first channel");
        RefChannels.push_back(&Channel);
}

void ApplyFilter::FilterData()
{
        const int ninputchannels = InputChannels.size();
        const int datalength = InputChannels.front()->GetData().size();
        const int inputsize = Filter.GetInputLength();
        const int outputsize = Filter.GetOutputLength();
        const int pointsperchannel = inputsize/ninputchannels;
        
        gplib::rvec currentinput(inputsize), currdesired(outputsize), currout(outputsize);
        //std::vector<double> eps;
        //EpsValues.assign(outputsize,eps);
        
        if (!EpsValues.empty()) // if we have run this routine before
        {
                EpsValues.clear(); //clear errors 
                OutChannels.clear(); // and output channels, but not weights
        }
        
        for (int i = 0; i < outputsize; ++i)
        {
                std::vector<double> temp;
                EpsValues.push_back(temp);       
                OutChannels.push_back(boost::shared_ptr<TimeSeriesComponent>(new TimeSeriesComponent));
                OutChannels.at(i)->GetData().reserve(RefChannels.at(i)->GetData().size());
                EpsValues.at(i).reserve(RefChannels.at(i)->GetData().size());
                //if (shift > 2)
                OutChannels.at(i)->GetData().insert(OutChannels.at(i)->GetData().begin(),shift,0.0);
                EpsValues.at(i).insert(EpsValues.at(i).begin(),shift,0.0);
        }        
        const int maxindex = datalength-pointsperchannel-shift; 
        boost::progress_display *progressbar = NULL;
        if (showprogress) // the constructor already displays something, so we use a pointer and only construct when needed
        {
                progressbar = new boost::progress_display(maxindex); // init progress bar
        }
        for (int i = 0; i < maxindex; ++i)
        {
                
                for (int j = 0; j < ninputchannels; ++j)
                {
                        copy(InputChannels.at(j)->GetData().begin()+i,InputChannels.at(j)->GetData().begin()+pointsperchannel+i,
                                currentinput.begin()+j*pointsperchannel);
                }
                for (int j = 0; j < outputsize;++j)
                        currdesired(j) = RefChannels.at(j)->GetData().at(i+shift);
                
                Filter.CalcOutput(currentinput,currout);
                Filter.AdaptFilter(currentinput,currdesired);
                if (showprogress)
                {
                        ++(*progressbar); // make sure progress bar progresses
                }
                for (int j = 0; j < outputsize; ++j)
                {       
                        OutChannels.at(j)->GetData().push_back(currout(j));
                }
                if (wanthistory && ((i-shift) % weightsaveintervall== 0))
                {
                        WeightHistory.push_back(Filter.GetWeightsAsVector());
                }
                for (int j = 0; j < outputsize; ++j)
                {
                        EpsValues.at(j).push_back(Filter.GetEpsilon()(j));
                } 
        } // end of main loop
        for (int i = 0; i < outputsize; ++i)
        {
                OutChannels.at(i)->GetData().insert(OutChannels.at(i)->GetData().end(),pointsperchannel,0.0);
                EpsValues.at(i).insert(EpsValues.at(i).end(),pointsperchannel,0.0);
        }
        delete progressbar;
}

---