Features.cpp

Go to the documentation of this file.
00001 /*
00002  * This program is free software; you can redistribute it and/or modify
00003  * it under the terms of the GNU General Public License as published by
00004  * the Free Software Foundation; either version 3 of the License, or
00005  * (at your option) any later version.
00006  *
00007  * Written (W) 1999-2009 Soeren Sonnenburg
00008  * Written (W) 1999-2008 Gunnar Raetsch
00009  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
00010  */
00011 
00012 #include "features/Features.h"
00013 #include "preproc/PreProc.h"
00014 #include "lib/io.h"
00015 
00016 #include <string.h>
00017 
00018 
00019 #ifdef HAVE_BOOST_SERIALIZATION
00020 #include "kernel/Kernel.h"
00021 #include <boost/serialization/export.hpp>
00022 BOOST_CLASS_EXPORT(shogun::CFeatures);
00023 #endif //HAVE_BOOST_SERIALIZATION
00024 
00025 
00026 using namespace shogun;
00027 
00028 CFeatures::CFeatures(int32_t size)
00029 : CSGObject(), properties(FP_NONE), cache_size(size), preproc(NULL), num_preproc(0),
00030     preprocessed(NULL)
00031 {
00032     SG_INFO("Feature object created (%p)\n",this);
00033 }
00034 
00035 CFeatures::CFeatures(const CFeatures& orig)
00036 : CSGObject(orig), preproc(orig.preproc),
00037     num_preproc(orig.num_preproc), preprocessed(orig.preprocessed)
00038 {
00039     preprocessed=new bool[orig.num_preproc];
00040     memcpy(preprocessed, orig.preprocessed, sizeof(bool)*orig.num_preproc);
00041 }
00042 
00043 CFeatures::CFeatures(CFile* loader)
00044 : CSGObject(), cache_size(0), preproc(NULL), num_preproc(0),
00045     preprocessed(false)
00046 {
00047     load(loader);
00048     SG_INFO("Feature object loaded (%p)\n",this) ;
00049 }
00050 
00051 CFeatures::~CFeatures()
00052 {
00053     SG_INFO("Feature object destroyed (%p)\n", this);
00054     clean_preprocs();
00055 }
00056 
00058 int32_t CFeatures::add_preproc(CPreProc* p)
00059 {
00060     SG_INFO( "%d preprocs currently, new preproc list is\n", num_preproc);
00061     ASSERT(p);
00062 
00063     bool* preprocd=new bool[num_preproc+1];
00064     CPreProc** pps=new CPreProc*[num_preproc+1];
00065     for (int32_t i=0; i<num_preproc; i++)
00066     {
00067         pps[i]=preproc[i];
00068         preprocd[i]=preprocessed[i];
00069     }
00070     delete[] preproc;
00071     delete[] preprocessed;
00072     preproc=pps;
00073     preprocessed=preprocd;
00074     preproc[num_preproc]=p;
00075     preprocessed[num_preproc]=false;
00076 
00077     num_preproc++;
00078 
00079     for (int32_t i=0; i<num_preproc; i++)
00080         SG_INFO( "preproc[%d]=%s %ld\n",i, preproc[i]->get_name(), preproc[i]) ;
00081 
00082     SG_REF(p);
00083 
00084     return num_preproc;
00085 }
00086 
00088 CPreProc* CFeatures::get_preproc(int32_t num)
00089 {
00090     if (num<num_preproc)
00091     {
00092         SG_REF(preproc[num]);
00093         return preproc[num];
00094     }
00095     else
00096         return NULL;
00097 }
00098 
00100 int32_t CFeatures::get_num_preprocessed()
00101 {
00102     int32_t num=0;
00103 
00104     for (int32_t i=0; i<num_preproc; i++)
00105     {
00106         if (preprocessed[i])
00107             num++;
00108     }
00109 
00110     return num;
00111 }
00112 
00114 void CFeatures::clean_preprocs()
00115 {
00116     while (del_preproc(0));
00117 }
00118 
00120 CPreProc* CFeatures::del_preproc(int32_t num)
00121 {
00122     CPreProc** pps=NULL;
00123     bool* preprocd=NULL;
00124     CPreProc* removed_preproc=NULL;
00125 
00126     if (num_preproc>0 && num<num_preproc)
00127     {
00128         removed_preproc=preproc[num];
00129 
00130         if (num_preproc>1)
00131         {
00132             pps= new CPreProc*[num_preproc-1];
00133             preprocd= new bool[num_preproc-1];
00134 
00135             if (pps && preprocd)
00136             {
00137                 int32_t j=0;
00138                 for (int32_t i=0; i<num_preproc; i++)
00139                 {
00140                     if (i!=num)
00141                     {
00142                         pps[j]=preproc[i];
00143                         preprocd[j]=preprocessed[i];
00144                         j++;
00145                     }
00146                 }
00147             }
00148         }
00149 
00150         delete[] preproc;
00151         preproc=pps;
00152         delete[] preprocessed;
00153         preprocessed=preprocd;
00154 
00155         num_preproc--;
00156 
00157         for (int32_t i=0; i<num_preproc; i++)
00158             SG_INFO( "preproc[%d]=%s\n",i, preproc[i]->get_name()) ;
00159     }
00160 
00161     SG_UNREF(removed_preproc);
00162     return removed_preproc;
00163 }
00164 
00165 void CFeatures::list_feature_obj()
00166 {
00167     SG_INFO( "%p - ", this);
00168     switch (get_feature_class())
00169     {
00170         case C_UNKNOWN:
00171             SG_INFO( "C_UNKNOWN ");
00172             break;
00173         case C_SIMPLE:
00174             SG_INFO( "C_SIMPLE ");
00175             break;
00176         case C_SPARSE:
00177             SG_INFO( "C_SPARSE ");
00178             break;
00179         case C_STRING:
00180             SG_INFO( "C_STRING ");
00181             break;
00182         case C_COMBINED:
00183             SG_INFO( "C_COMBINED ");
00184             break;
00185         case C_COMBINED_DOT:
00186             SG_INFO( "C_COMBINED_DOT ");
00187             break;
00188         case C_WD:
00189             SG_INFO( "C_WD ");
00190             break;
00191         case C_SPEC:
00192             SG_INFO( "C_SPEC ");
00193             break;
00194         case C_WEIGHTEDSPEC:
00195             SG_INFO( "C_WEIGHTEDSPEC ");
00196             break;
00197         case C_ANY:
00198             SG_INFO( "C_ANY ");
00199             break;
00200         default:
00201          SG_ERROR( "ERROR UNKNOWN FEATURE CLASS");
00202     }
00203 
00204     switch (get_feature_type())
00205     {
00206         case F_UNKNOWN:
00207             SG_INFO( "F_UNKNOWN \n");
00208             break;
00209         case F_CHAR:
00210             SG_INFO( "F_CHAR \n");
00211             break;
00212         case F_BYTE:
00213             SG_INFO( "F_BYTE \n");
00214             break;
00215         case F_SHORT:
00216             SG_INFO( "F_SHORT \n");
00217             break;
00218         case F_WORD:
00219             SG_INFO( "F_WORD \n");
00220             break;
00221         case F_INT:
00222             SG_INFO( "F_INT \n");
00223             break;
00224         case F_UINT:
00225             SG_INFO( "F_UINT \n");
00226             break;
00227         case F_LONG:
00228             SG_INFO( "F_LONG \n");
00229             break;
00230         case F_ULONG:
00231             SG_INFO( "F_ULONG \n");
00232             break;
00233         case F_SHORTREAL:
00234             SG_INFO( "F_SHORTEAL \n");
00235             break;
00236         case F_DREAL:
00237             SG_INFO( "F_DREAL \n");
00238             break;
00239         case F_LONGREAL:
00240             SG_INFO( "F_LONGREAL \n");
00241             break;
00242         case F_ANY:
00243             SG_INFO( "F_ANY \n");
00244             break;
00245         default:
00246          SG_ERROR( "ERROR UNKNOWN FEATURE TYPE\n");
00247     }
00248 }
00249 
00250 bool CFeatures::check_feature_compatibility(CFeatures* f)
00251 {
00252     bool result=false;
00253 
00254     if (f)
00255         result= ( (this->get_feature_class() == f->get_feature_class()) &&
00256                 (this->get_feature_type() == f->get_feature_type()));
00257     return result;
00258 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation