Filter.h

Go to the documentation of this file.

/*
 * This file is part of ALVAR, A Library for Virtual and Augmented Reality.
 *
 * Copyright 2007-2012 VTT Technical Research Centre of Finland
 *
 * Contact: VTT Augmented Reality Team <alvar.info@vtt.fi>
 *          <http://www.vtt.fi/multimedia/alvar.html>
 *
 * ALVAR is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with ALVAR; if not, see
 * <http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html>.
 */

#ifndef FILTER_H
#define FILTER_H

#include "Alvar.h"
#include <algorithm>
#include <deque>
#include <vector>
#include <cmath>

namespace alvar {

class ALVAR_EXPORT Filter {
protected:
        double value;
public:
        Filter();
        double get() const { return value; }
        operator double () { return get(); }
        virtual double next(double y) = 0;
        virtual void reset() = 0;
};

class ALVAR_EXPORT FilterAverage : public Filter {
protected:
        unsigned int count;
        unsigned int window_size;
        std::deque<double> buffer;
        void push_to_buffer(double y);
public:
        FilterAverage(int size=3) { setWindowSize(size); }
        void setWindowSize(int size) { window_size=size; count=0; }
        int getWindowSize() { return window_size; }
        int getCurrentSize() { return (int) buffer.size(); }
        double operator= (double _value) { return next(_value); }
        virtual double next(double y);
        virtual void reset();
        double deviation() const;
};

class ALVAR_EXPORT FilterMedian : public FilterAverage {
        std::vector<double> sort_buffer;
public:
        FilterMedian(int size=3) { setWindowSize(size); }
        void setWindowSize(int size) { 
                FilterAverage::setWindowSize(size);
                sort_buffer.resize(size);
        }
        double operator= (double _value) { return next(_value); }
        virtual double next(double y);
};

class ALVAR_EXPORT FilterRunningAverage : public Filter {
protected:
        double alpha;
        bool breset;
public:
        FilterRunningAverage(double _alpha=0.5) { breset=true; setAlpha(_alpha); }
        void setAlpha(double _alpha) { alpha=std::max(std::min(_alpha,1.0),0.0); }
        double getAlpha() { return alpha; }
        double operator= (double _value) { return next(_value); }
        virtual double next(double y);
        virtual void reset();
};

class ALVAR_EXPORT FilterDoubleExponentialSmoothing : public FilterRunningAverage {
protected:
        double gamma;
        double slope;
public:
        FilterDoubleExponentialSmoothing(double _alpha=0.5, double _gamma=1.0) : FilterRunningAverage(_alpha) {
                setGamma(_gamma);
        }
        void setGamma(double _gamma) { gamma=std::max(std::min(_gamma,1.0),0.0); }
        double getGamma() { return gamma; }
        double operator= (double _value) { return next(_value); }
        virtual double next(double y);
};

template <class F>
class ALVAR_EXPORT FilterArray {
protected:
        double *tmp;
        std::vector<F> arr;
public:
        FilterArray(int size) {
                tmp = NULL;
                SetSize(size);
        }
        ~FilterArray() {
                delete [] tmp;
        }
        size_t GetSize() {
                return arr.size();
        }
        void SetSize(size_t size) {
                if (tmp) delete [] tmp;
                tmp = new double[size];
                arr.resize(size);
        }
        F &operator[](size_t i) {
                return arr[i];
        }
        const double *as_double_array(size_t start_i=0) {
                for (size_t i=0; i<arr.size(); i++) {
                        tmp[i] = arr[i];
                }
                return &(tmp[start_i]);
        }
};

} // namespace alvar

#endif