MultiClassDataSet.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 _MULTICLASS_DATA_SET_H
#define _MULTICLASS_DATA_SET_H

#include <vector>
#include <_stdint.h>
#include <fstream>
#include <iostream>
#include <map>      // multimap
#include <cmath>
#include <stdlib.h> // rand

#include "bitset.h"

// fwd
template<class PatternType>
struct MultiClassDataSet;

template<class _PatternType, class DataParams>
struct MultiClassDataSetHandle: public DataParams {

public:

    typedef typename _PatternType::DataType DataType;

    typedef _PatternType PatternType;
    typedef DataSetHandle<PatternType> ViewType;
    typedef DataSet<PatternType> StoreType;

public:
    unsigned int width, height;

    std::vector<unsigned int> n_pattern;

    std::vector<PatternType> templates;

public:

    MultiClassDataSetHandle(int n_classes) : width(0), height(0), n_pattern(n_classes) { }

    template<class R>
    explicit MultiClassDataSetHandle( const MultiClassDataSetHandle<R> & src) : width(src.width), height(src.height),  n_pattern(src.n_pattern), templates(src.templates) { }

    // do nothing
    ~MultiClassDataSetHandle() { }

    void Clear()
    {
        width = height = 0;
        for(int i =0;i<n_pattern.size();++i)
          n_pattern[i] = 0;
        templates.clear();
    }

    inline unsigned int Width() const  {
        return width;
    }
    inline unsigned int Height() const {
        return height;
    }
    
    inline unsigned int Size() const {
        return templates.size();
    }

    void SetGeometry(unsigned int width, unsigned int height) {
        this->width = width;
        this->height = height;
    }

    void Insert(const PatternType & p)
    {
      // NOTE: not boundary check
      n_pattern[p.category] ++;
      templates.push_back(p);
    }

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

    template<class R>
    void operator=( const DataSetHandle<R> & src) {
        width=src.width;
        height=src.height;
        n_pattern=src.n_pattern;
        templates.clear();
        templates.reserve(src.templates.size() );
        for(typename  std::vector<R>::const_iterator i = src.templates.begin(); i!=src.templates.end(); ++i)
            templates.push_back( *i );
    }

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

};

template<class PatternType>
struct MultiClassDataSet: public MultiClassDataSetHandle<PatternType> {
public:

    typedef MultiClassDataSetHandle<PatternType> ViewType;
    typedef MultiClassDataSet<PatternType> StoreType;

public:
    ~MultiClassDataSet()
    {
        this->Release();
    }

};



template<class PatternType>
void MultiClassDataSetHandle<PatternType>::Import(const DataType & data, int sign)
{
    Insert( PatternType(data,sign) );
}


#endif