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

SHOGUN Machine Learning Toolbox - Documentation