DataSet.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 _DATA_SET_H
#define _DATA_SET_H

#include <vector>
#include "Types.h"
#include "Pattern/Aggregator.h"

// fwd
template<class Aggregator>
struct DataSet;

template<class Aggregator >
struct DataSetHandle: public Aggregator::ParamType {

public:
    typedef DataSetHandle<Aggregator> ViewType;

    typedef DataSet<Aggregator> StoreType;
    
    // additional Typedef
    DECLARE_AGGREGATOR

    typedef typename std::vector<PatternType> ListType;
    
public:

    unsigned int n_patternP, n_patternN;

    ListType templates;

public:

    DataSetHandle() : n_patternP(0), n_patternN(0) { }

    template<class SrcAggregator>
    explicit DataSetHandle( const DataSetHandle<SrcAggregator> & src) :n_patternP(src.n_patternP), n_patternN(src.n_patternN)
    { 
        static_cast<ParamType&>(*this) = static_cast<const ParamType&>(src);
        templates.reserve(src.templates.size() );
        for(typename DataSetHandle<SrcAggregator>::ListType::const_iterator i = src.templates.begin(); i!=src.templates.end(); ++i)
            templates.push_back( PatternType ( *i ) ); // convert      
    }

    // do nothing
    ~DataSetHandle() { }

    void Clear()
    {
        n_patternP = n_patternN = 0;
        templates.clear();
    }

    inline unsigned int Size() const {
        return templates.size();
    }

    void SetParams(const ParamType & src) {
        static_cast<ParamType &>(*this) = src;
    }

    const ParamType & GetParams() const {
        return static_cast<const ParamType &>(*this);
    }

    void Insert(const PatternType & p)
    {
        if(p.category == 1)
            n_patternP++;
        else
            n_patternN++;
        templates.push_back(p);
    }

    void Release()
    {
        // release pattern data memory
        for(typename ListType::iterator i = templates.begin(); i!=templates.end(); ++i)
            i->release();
    }

    template<class SrcAggregator>
    void operator=( const DataSetHandle<SrcAggregator> & src) {
        static_cast<ParamType&>(*this) = static_cast<const ParamType&>(src);
        n_patternP=src.n_patternP;
        n_patternN=src.n_patternN;
        templates.clear();
        templates.reserve(src.templates.size() );
        for( typename DataSetHandle<SrcAggregator>::ListType::const_iterator i = src.templates.begin(); i!=src.templates.end(); ++i)
            templates.push_back( PatternType ( *i ) ); // convert
    }

    void Import(const DataType & data, int category);

};

template<class Aggregator>
struct DataSet: public DataSetHandle<Aggregator> {
public:

    typedef DataSetHandle<Aggregator> ViewType;
    typedef DataSet<Aggregator> StoreType;

private:

    // uncopiable
    DataSet(const DataSet & src) { }

public:

    DataSet() { }

    ~DataSet()
    {
        // on destruction, memory is released:
        this->Release();
    }

};



template<class Aggregator >
void DataSetHandle<Aggregator>::Import(const DataType & data, int category)
{
    // update stats:
    if(category == 1)
        n_patternP++;
    else
        n_patternN++;

    // add the data to the set
    templates.push_back(PatternType(data, category));
}


#endif