BoostClassifier.h

Go to the documentation of this file.

/* XBoost: Ada-Boost and Friends on Haar/ICF/HOG Features, Library and ToolBox
 *
 * Copyright (c) 2008-2014 Paolo Medici <medici@ce.unipr.it>
 *
 * This library 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 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 this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef _BOOST_CLASSIFIER_H
#define _BOOST_CLASSIFIER_H

#include <string>
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <algorithm>// sort

#include "BoostableClassifier.h"

namespace detail {

template<ClassifierType type, class T>
struct traits;

template<class T>
struct traits<DicreteClassifier, T>
{
    typedef BoostableClassifier<T> Boosted;
};

template<class T>
struct traits<RealClassifier, T>
{
    typedef T Boosted;
};

}

template<class Classifier >
struct BoostClassifier {

public:

    typedef typename detail::traits<Classifier::Type, Classifier>::Boosted BoostedClassifierType;

    typedef std::vector< BoostedClassifierType > ClassifierListType;

    typedef BoostClassifier< typename Classifier::OptimizedType > OptimizedType;

private:

    ClassifierListType m_weak_classifiers;

public:

    BoostClassifier();
    BoostClassifier(std::istream & in);

    template<class R, class P0, class P1, class P2>
    explicit BoostClassifier(const BoostClassifier<R> & src, P0 scale, P1 p1, P2 p2)
    {
        m_weak_classifiers.reserve(src.size() );
        for(typename BoostClassifier<R>::ClassifierListType::const_iterator i = src.list().begin(); i!= src.list().end(); ++i)
        {
            m_weak_classifiers.push_back( BoostedClassifierType(*i, scale, p1, p2) );
        }
    }

    template<class R, class P1, class P2>
    explicit BoostClassifier(const BoostClassifier<R> & src, P1 p1, P2 p2)
    {
        m_weak_classifiers.reserve(src.size() );
        for(typename BoostClassifier<R>::ClassifierListType::const_iterator i = src.list().begin(); i!= src.list().end(); ++i)
            m_weak_classifiers.push_back( BoostedClassifierType(*i, p1, p2) );
    }

    template<class R, class P1>
    explicit BoostClassifier(const BoostClassifier<R> & src, const P1 & p1)
    {
        m_weak_classifiers.reserve(src.size() );
        for(typename BoostClassifier<R>::ClassifierListType::const_iterator i = src.list().begin(); i!= src.list().end(); ++i)
            m_weak_classifiers.push_back( BoostedClassifierType(*i, p1) );
    }

    ~BoostClassifier();

    inline int size() const {
        return m_weak_classifiers.size();
    };

    
    inline ClassifierListType & list() {
        return m_weak_classifiers;
    }
    inline const ClassifierListType & list() const {
        return m_weak_classifiers;
    }

    static std::string signature() {
        return "additive-" + BoostedClassifierType::signature();
    }

    template<class DataType>
    inline float operator()(const DataType data) const {
        // return compute(pIntImage, &m_weak_classifiers[0], m_weak_classifiers.size());
        float acc = 0.0;
        for(typename ClassifierListType::const_iterator i = m_weak_classifiers.begin(); i != m_weak_classifiers.end(); i++)
            acc += (*i)(data);
        return acc;
    }

    template<class DataType, class Param1>
    inline float operator()(const DataType data, Param1 p1) const {
        // return compute(pIntImage, &m_weak_classifiers[0], m_weak_classifiers.size());
        float acc = 0.0;
        for(typename ClassifierListType::const_iterator i = m_weak_classifiers.begin(); i != m_weak_classifiers.end(); i++)
            acc += (*i)(data, p1);
        return acc;
    }

    template<class FeatureType>
    void export_features(std::vector<FeatureType> & out) const
    {
        for(typename ClassifierListType::const_iterator i = m_weak_classifiers.begin(); i != m_weak_classifiers.end(); i++)
            i->export_features(out);
    }

    void load(std::istream & in);

    void save(std::ostream & out) const;

    void sort();

    void resize(int size);

    float max_response() const {
        float sum=0.0f;
        for(typename ClassifierListType::const_iterator i = m_weak_classifiers.begin(); i != m_weak_classifiers.end(); i++)
            sum+=i->getAlpha();
        return sum;
    }

    inline void insert(const BoostedClassifierType & classifier)
    {
        m_weak_classifiers.push_back(classifier);
    }

};

template<class T>
std::istream & operator >>(std::istream & in, BoostClassifier<T> & dst);

template<class T>
std::ostream & operator << (std::ostream & out, const BoostClassifier<T> & src);


// IO
template<class T>
std::istream & operator >>(std::istream & in, BoostClassifier<T> & dst)
{
    dst.load(in);
    return in;
}

// IO
template<class T>
std::ostream & operator << (std::ostream & out, const BoostClassifier<T> & src)
{
    src.save(out);
    return out;
}

template<class T>
BoostClassifier<T>::BoostClassifier() { }

template<class T>
BoostClassifier<T>::~BoostClassifier() { }

template<class T>
BoostClassifier<T>::BoostClassifier(std::istream & in)
{
    load(in);
}

template<class T>
void BoostClassifier<T>::load(std::istream & in)
{
    while(in)
    {
        BoostedClassifierType h;
        in >> h;
        if(in)
        {
            m_weak_classifiers.push_back(h);
        }
    }
}

template<class T>
void BoostClassifier<T>::save(std::ostream & out) const
{
    for(typename  BoostClassifier<T>::ClassifierListType::const_iterator i = list().begin(); i != list().end(); i++)
        out << *i << '\n';
}

// detail: sort policy
template<class T>
inline bool sort_by_alpha(const BoostableClassifier<T> & a, const BoostableClassifier<T> & b)
{
    return a.alpha > b.alpha;
}

template<class T>
void BoostClassifier<T>::sort()
{
    std::sort(m_weak_classifiers.begin(), m_weak_classifiers.end(), sort_by_alpha<T> );
}

template<class T>
void BoostClassifier<T>::resize(int size)
{
    m_weak_classifiers.resize(size);
}


#endif