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-2008 Soeren Sonnenburg
00008  * Written (W) 1999-2008 Gunnar Raetsch
00009  * Copyright (C) 1999-2008 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 CFeatures::CFeatures(int32_t size)
00019 : CSGObject(), cache_size(size), preproc(NULL), num_preproc(0),
00020     preprocessed(NULL)
00021 {
00022     SG_INFO("Feature object created (%p)\n",this);
00023 }
00024 
00025 CFeatures::CFeatures(const CFeatures& orig)
00026 : CSGObject(orig), preproc(orig.preproc),
00027     num_preproc(orig.num_preproc), preprocessed(orig.preprocessed)
00028 {
00029     preprocessed=new bool[orig.num_preproc];
00030     memcpy(preprocessed, orig.preprocessed, sizeof(bool)*orig.num_preproc);
00031 }
00032 
00033 CFeatures::CFeatures(char* fname)
00034 : CSGObject(), cache_size(0), preproc(NULL), num_preproc(0),
00035     preprocessed(false)
00036 {
00037     load(fname);
00038     SG_INFO("Feature object loaded (%p)\n",this) ;
00039 }
00040 
00041 CFeatures::~CFeatures()
00042 {
00043     SG_INFO("Feature object destroyed (%p)\n", this);
00044     clean_preprocs();
00045 }
00046 
00048 int32_t CFeatures::add_preproc(CPreProc* p)
00049 { 
00050     SG_INFO( "%d preprocs currently, new preproc list is\n", num_preproc);
00051     int32_t i;
00052 
00053     bool* preprocd=new bool[num_preproc+1];
00054     CPreProc** pps=new CPreProc*[num_preproc+1];
00055     for (i=0; i<num_preproc; i++)
00056     {
00057         pps[i]=preproc[i];
00058         preprocd[i]=preprocessed[i];
00059     }
00060     delete[] preproc;
00061     delete[] preprocessed;
00062     preproc=pps;
00063     preprocessed=preprocd;
00064     preproc[num_preproc]=p;
00065     preprocessed[num_preproc]=false;
00066 
00067     num_preproc++;
00068 
00069     for (i=0; i<num_preproc; i++)
00070         SG_INFO( "preproc[%d]=%s %ld\n",i, preproc[i]->get_name(), preproc[i]) ;
00071 
00072     SG_REF(p);
00073 
00074     return num_preproc;
00075 }
00076 
00078 CPreProc* CFeatures::get_preproc(int32_t num)
00079 { 
00080     if (num<num_preproc)
00081         return preproc[num];
00082     else
00083         return NULL;
00084 }
00085 
00087 int32_t CFeatures::get_num_preprocessed()
00088 {
00089     int32_t num=0;
00090 
00091     for (int32_t i=0; i<num_preproc; i++)
00092     {
00093         if (preprocessed[i])
00094             num++;
00095     }
00096 
00097     return num;
00098 }
00099 
00101 void CFeatures::clean_preprocs()
00102 {
00103     while (del_preproc(0));
00104 }
00105 
00107 CPreProc* CFeatures::del_preproc(int32_t num)
00108 {
00109     CPreProc** pps=NULL; 
00110     bool* preprocd=NULL; 
00111     CPreProc* removed_preproc=NULL;
00112 
00113     if (num_preproc>0 && num<num_preproc)
00114     {
00115         removed_preproc=preproc[num];
00116 
00117         if (num_preproc>1)
00118         {
00119             pps= new CPreProc*[num_preproc-1];
00120             preprocd= new bool[num_preproc-1];
00121 
00122             if (pps && preprocd)
00123             {
00124                 int32_t j=0;
00125                 for (int32_t i=0; i<num_preproc; i++)
00126                 {
00127                     if (i!=num)
00128                     {
00129                         pps[j]=preproc[i];
00130                         preprocd[j]=preprocessed[i];
00131                         j++;
00132                     }
00133                 }
00134             }
00135         }
00136 
00137         delete[] preproc;
00138         preproc=pps;
00139         delete[] preprocessed;
00140         preprocessed=preprocd;
00141 
00142         num_preproc--;
00143 
00144         for (int32_t i=0; i<num_preproc; i++)
00145             SG_INFO( "preproc[%d]=%s\n",i, preproc[i]->get_name()) ;
00146     }
00147 
00148     SG_UNREF(removed_preproc);
00149     return removed_preproc;
00150 }
00151 
00152 void CFeatures::list_feature_obj()
00153 {
00154     SG_INFO( "0x%p - ", this);
00155     switch (get_feature_class())
00156     {
00157         case C_UNKNOWN:
00158             SG_INFO( "C_UNKNOWN ");
00159             break;
00160         case C_SIMPLE:
00161             SG_INFO( "C_SIMPLE ");
00162             break;
00163         case C_SPARSE:
00164             SG_INFO( "C_SPARSE ");
00165             break;
00166         case C_STRING:
00167             SG_INFO( "C_STRING ");
00168             break;
00169         case C_COMBINED:
00170             SG_INFO( "C_COMBINED ");
00171             break;
00172         case C_ANY:
00173             SG_INFO( "C_ANY ");
00174             break;
00175         default:
00176          SG_ERROR( "ERROR UNKNOWN FEATURE CLASS");
00177     }
00178 
00179     switch (get_feature_type())
00180     {
00181         case F_UNKNOWN:
00182             SG_INFO( "F_UNKNOWN \n");
00183             break;
00184         case F_DREAL:
00185             SG_INFO( "F_REAL \n");
00186             break;
00187         case F_SHORT:
00188             SG_INFO( "F_SHORT \n");
00189             break;
00190         case F_CHAR:
00191             SG_INFO( "F_CHAR \n");
00192             break;
00193         case F_INT:
00194             SG_INFO( "F_INT \n");
00195             break;
00196         case F_BYTE:
00197             SG_INFO( "F_BYTE \n");
00198             break;
00199         case F_WORD:
00200             SG_INFO( "F_WORD \n");
00201             break;
00202         case F_ULONG:
00203             SG_INFO( "F_ULONG ");
00204             break;
00205         case F_ANY:
00206             SG_INFO( "F_ANY \n");
00207             break;
00208         default:
00209          SG_ERROR( "ERROR UNKNOWN FEATURE TYPE\n");
00210     }
00211 }
00212 
00213 bool CFeatures::load(char* fname)
00214 {
00215     return false;
00216 }
00217 
00218 bool CFeatures::save(char* fname)
00219 {
00220     return false;
00221 }
00222 
00223 bool CFeatures::check_feature_compatibility(CFeatures* f)
00224 {
00225     bool result=false;
00226 
00227     if (f)
00228         result= ( (this->get_feature_class() == f->get_feature_class()) &&
00229                 (this->get_feature_type() == f->get_feature_type()));
00230     return result;
00231 }

SHOGUN Machine Learning Toolbox - Documentation