Features.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 1999-2009 Soeren Sonnenburg
 * Written (W) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _CFEATURES__H__
#define _CFEATURES__H__

#include "lib/common.h"
#include "lib/File.h"
#include "base/SGObject.h"
#include "preproc/PreProc.h"
#include "features/FeatureTypes.h"

namespace shogun
{
    class CFile;
    class CPreProc;
    class CKernel;
    enum EFeatureType;
    enum EFeatureClass;
    enum EFeatureProperty;
}

namespace shogun
{

class CFeatures : public CSGObject
{
    public:
        CFeatures(int32_t size=0);

        CFeatures(const CFeatures& orig);

        CFeatures(CFile* loader);

        virtual CFeatures* duplicate() const=0 ;

        virtual ~CFeatures();

        virtual EFeatureType get_feature_type()=0;

        virtual EFeatureClass get_feature_class()=0;

        virtual int32_t add_preproc(CPreProc* p);

        virtual CPreProc* del_preproc(int32_t num);

        CPreProc* get_preproc(int32_t num);

        inline void set_preprocessed(int32_t num) { preprocessed[num]=true; }

        inline bool is_preprocessed(int32_t num) { return preprocessed[num]; }

        int32_t get_num_preprocessed();

        inline int32_t get_num_preproc() { return num_preproc; }

        void clean_preprocs();

        inline int32_t get_cache_size() { return cache_size; };

        virtual int32_t get_num_vectors()=0 ;

        virtual bool reshape(int32_t num_features, int32_t num_vectors) { return false; }

        virtual int32_t get_size()=0;

        void list_feature_obj();

        virtual void load(CFile* loader)
        {
            SG_NOTIMPLEMENTED;
        }

        virtual void save(CFile* writer)
        {
            SG_NOTIMPLEMENTED;
        }

        bool check_feature_compatibility(CFeatures* f);

        inline bool has_property(EFeatureProperty p) { return (properties & p) != 0; }

        inline void set_property(EFeatureProperty p)
        {
            properties |= p;
        }

        inline void unset_property(EFeatureProperty p)
        {
            properties &= (properties | p) ^ p;
        }
#ifdef HAVE_BOOST_SERIALIZATION
    private:

        friend class ::boost::serialization::access;
        template<class Archive>
            void save(Archive & ar, const unsigned int archive_version) const
            {

                SG_DEBUG("archiving Features\n");

                ar & ::boost::serialization::base_object<CSGObject>(*this);

                ar & properties;
                ar & cache_size;
                ar & num_preproc;

                //TODO
                //ar & preproc;
                for (int i=0; i < num_preproc; ++i) {
                    ar & preprocessed[i];
                }

                SG_DEBUG("done archiving Features\n");

            }

        template<class Archive>
            void load(Archive & ar, const unsigned int archive_version)
            {

                SG_DEBUG("archiving Features\n");

                ar & ::boost::serialization::base_object<CSGObject>(*this);

                ar & properties;
                ar & cache_size;
                ar & num_preproc;

                //TODO
                //ar & preproc;

                if (num_preproc > 0)
                {
                    preprocessed = new bool[num_preproc];
                    for (int i=0; i< num_preproc; ++i){
                        ar & preprocessed[i];
                    }

                }

                SG_DEBUG("done archiving Features\n");

            }

        GLOBAL_BOOST_SERIALIZATION_SPLIT_MEMBER();


#endif //HAVE_BOOST_SERIALIZATION

    private:
        uint64_t  properties;

        int32_t cache_size;

        CPreProc** preproc;

        int32_t num_preproc;

        bool* preprocessed;
};
}
#endif