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 #include "base/Parameter.h"
00016 
00017 #include <string.h>
00018 
00019 using namespace shogun;
00020 
00021 CFeatures::CFeatures(int32_t size)
00022 : CSGObject()
00023 {
00024     init();
00025     cache_size = size;
00026 }
00027 
00028 CFeatures::CFeatures(const CFeatures& orig)
00029 : CSGObject(orig)
00030 {
00031     init();
00032 
00033     preproc = orig.preproc;
00034     num_preproc = orig.num_preproc;
00035 
00036     preprocessed=new bool[orig.num_preproc];
00037     memcpy(preprocessed, orig.preprocessed, sizeof(bool)*orig.num_preproc);
00038 }
00039 
00040 CFeatures::CFeatures(CFile* loader)
00041 : CSGObject()
00042 {
00043     init();
00044 
00045     load(loader);
00046     SG_INFO("Feature object loaded (%p)\n",this) ;
00047 }
00048 
00049 CFeatures::~CFeatures()
00050 {
00051     clean_preprocs();
00052 }
00053 
00054 void
00055 CFeatures::init(void)
00056 {
00057     m_parameters->add(&properties, "properties",
00058                       "Feature properties.");
00059     m_parameters->add(&cache_size, "cache_size",
00060                       "Size of cache in MB.");
00061 
00062     m_parameters->add_vector((CSGObject***) &preproc,
00063                              &num_preproc, "preproc",
00064                              "List of preprocessors.");
00065     m_parameters->add_vector(&preprocessed,
00066                              &num_preproc, "preprocessed",
00067                              "Feature[i] is already preprocessed.");
00068 
00069     properties = FP_NONE;
00070     cache_size = 0;
00071     preproc = NULL;
00072     num_preproc = 0;
00073     preprocessed = NULL;
00074 }
00075 
00077 int32_t CFeatures::add_preproc(CPreProc* p)
00078 {
00079     SG_INFO( "%d preprocs currently, new preproc list is\n", num_preproc);
00080     ASSERT(p);
00081 
00082     bool* preprocd=new bool[num_preproc+1];
00083     CPreProc** pps=new CPreProc*[num_preproc+1];
00084     for (int32_t i=0; i<num_preproc; i++)
00085     {
00086         pps[i]=preproc[i];
00087         preprocd[i]=preprocessed[i];
00088     }
00089     delete[] preproc;
00090     delete[] preprocessed;
00091     preproc=pps;
00092     preprocessed=preprocd;
00093     preproc[num_preproc]=p;
00094     preprocessed[num_preproc]=false;
00095 
00096     num_preproc++;
00097 
00098     for (int32_t i=0; i<num_preproc; i++)
00099         SG_INFO( "preproc[%d]=%s %ld\n",i, preproc[i]->get_name(), preproc[i]) ;
00100 
00101     SG_REF(p);
00102 
00103     return num_preproc;
00104 }
00105 
00107 CPreProc* CFeatures::get_preproc(int32_t num)
00108 {
00109     if (num<num_preproc)
00110     {
00111         SG_REF(preproc[num]);
00112         return preproc[num];
00113     }
00114     else
00115         return NULL;
00116 }
00117 
00119 int32_t CFeatures::get_num_preprocessed()
00120 {
00121     int32_t num=0;
00122 
00123     for (int32_t i=0; i<num_preproc; i++)
00124     {
00125         if (preprocessed[i])
00126             num++;
00127     }
00128 
00129     return num;
00130 }
00131 
00133 void CFeatures::clean_preprocs()
00134 {
00135     while (del_preproc(0));
00136 }
00137 
00139 CPreProc* CFeatures::del_preproc(int32_t num)
00140 {
00141     CPreProc** pps=NULL;
00142     bool* preprocd=NULL;
00143     CPreProc* removed_preproc=NULL;
00144 
00145     if (num_preproc>0 && num<num_preproc)
00146     {
00147         removed_preproc=preproc[num];
00148 
00149         if (num_preproc>1)
00150         {
00151             pps= new CPreProc*[num_preproc-1];
00152             preprocd= new bool[num_preproc-1];
00153 
00154             if (pps && preprocd)
00155             {
00156                 int32_t j=0;
00157                 for (int32_t i=0; i<num_preproc; i++)
00158                 {
00159                     if (i!=num)
00160                     {
00161                         pps[j]=preproc[i];
00162                         preprocd[j]=preprocessed[i];
00163                         j++;
00164                     }
00165                 }
00166             }
00167         }
00168 
00169         delete[] preproc;
00170         preproc=pps;
00171         delete[] preprocessed;
00172         preprocessed=preprocd;
00173 
00174         num_preproc--;
00175 
00176         for (int32_t i=0; i<num_preproc; i++)
00177             SG_INFO( "preproc[%d]=%s\n",i, preproc[i]->get_name()) ;
00178     }
00179 
00180     SG_UNREF(removed_preproc);
00181     return removed_preproc;
00182 }
00183 
00184 void CFeatures::list_feature_obj()
00185 {
00186     SG_INFO( "%p - ", this);
00187     switch (get_feature_class())
00188     {
00189         case C_UNKNOWN:
00190             SG_INFO( "C_UNKNOWN ");
00191             break;
00192         case C_SIMPLE:
00193             SG_INFO( "C_SIMPLE ");
00194             break;
00195         case C_SPARSE:
00196             SG_INFO( "C_SPARSE ");
00197             break;
00198         case C_STRING:
00199             SG_INFO( "C_STRING ");
00200             break;
00201         case C_COMBINED:
00202             SG_INFO( "C_COMBINED ");
00203             break;
00204         case C_COMBINED_DOT:
00205             SG_INFO( "C_COMBINED_DOT ");
00206             break;
00207         case C_WD:
00208             SG_INFO( "C_WD ");
00209             break;
00210         case C_SPEC:
00211             SG_INFO( "C_SPEC ");
00212             break;
00213         case C_WEIGHTEDSPEC:
00214             SG_INFO( "C_WEIGHTEDSPEC ");
00215             break;
00216         case C_ANY:
00217             SG_INFO( "C_ANY ");
00218             break;
00219         default:
00220          SG_ERROR( "ERROR UNKNOWN FEATURE CLASS");
00221     }
00222 
00223     switch (get_feature_type())
00224     {
00225         case F_UNKNOWN:
00226             SG_INFO( "F_UNKNOWN \n");
00227             break;
00228         case F_CHAR:
00229             SG_INFO( "F_CHAR \n");
00230             break;
00231         case F_BYTE:
00232             SG_INFO( "F_BYTE \n");
00233             break;
00234         case F_SHORT:
00235             SG_INFO( "F_SHORT \n");
00236             break;
00237         case F_WORD:
00238             SG_INFO( "F_WORD \n");
00239             break;
00240         case F_INT:
00241             SG_INFO( "F_INT \n");
00242             break;
00243         case F_UINT:
00244             SG_INFO( "F_UINT \n");
00245             break;
00246         case F_LONG:
00247             SG_INFO( "F_LONG \n");
00248             break;
00249         case F_ULONG:
00250             SG_INFO( "F_ULONG \n");
00251             break;
00252         case F_SHORTREAL:
00253             SG_INFO( "F_SHORTEAL \n");
00254             break;
00255         case F_DREAL:
00256             SG_INFO( "F_DREAL \n");
00257             break;
00258         case F_LONGREAL:
00259             SG_INFO( "F_LONGREAL \n");
00260             break;
00261         case F_ANY:
00262             SG_INFO( "F_ANY \n");
00263             break;
00264         default:
00265          SG_ERROR( "ERROR UNKNOWN FEATURE TYPE\n");
00266     }
00267 }
00268 
00269 bool CFeatures::check_feature_compatibility(CFeatures* f)
00270 {
00271     bool result=false;
00272 
00273     if (f)
00274         result= ( (this->get_feature_class() == f->get_feature_class()) &&
00275                 (this->get_feature_type() == f->get_feature_type()));
00276     return result;
00277 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation