Changeset 86


Ignore:
Timestamp:
06/02/2009 11:15:10 AM (11 years ago)
Author:
dave
Message:

lots of code added - pca implementation for eigenfaces and lda started

Location:
foam/trunk/vision/src
Files:
9 added
6 edited

Legend:

Unmodified
Added
Removed
  • foam/trunk/vision/src/Image.cpp

    r85 r86  
    2424Image::Image(int w, int h, int d, int c) 
    2525{ 
    26         cvCreateImage(cvSize(w, h), d, c); 
     26        m_Image=cvCreateImage(cvSize(w, h), d, c); 
    2727} 
    2828 
     
    4141{ 
    4242        m_Image=cvCloneImage(other); 
     43} 
     44 
     45Image::Image(int w, int h, int c, const Vector<float> &v) 
     46{ 
     47        m_Image=cvCreateImage(cvSize(w, h), 8, c); 
     48        unsigned int pos=0; 
     49        for(int y=0; y<m_Image->height; y++) 
     50        { 
     51        for(int x=0; x<m_Image->width; x++) 
     52                { 
     53                        CvScalar s; 
     54                        for (int c=0; c<m_Image->nChannels; c++) 
     55                        { 
     56                                s.val[c]=v[pos++]*256.0f; 
     57                        } 
     58                        cvSet2D(m_Image,y,x,s); 
     59                } 
     60        } 
    4361} 
    4462 
     
    148166} 
    149167 
    150 void Image::GRAY2RGB() 
     168Image Image::GRAY2RGB() 
    151169{ 
    152170        IplImage *newimage = cvCreateImage(cvGetSize(m_Image), 8, 3); 
    153171    cvCvtColor(m_Image, newimage, CV_GRAY2RGB); 
    154         cvReleaseImage(&m_Image); 
    155         m_Image=newimage; 
    156 } 
    157  
    158 void Image::RGB2GRAY() 
     172        return Image(newimage); 
     173} 
     174 
     175Image Image::RGB2GRAY() 
    159176{ 
    160177        IplImage *newimage = cvCreateImage(cvGetSize(m_Image), 8, 1); 
    161178    cvCvtColor(m_Image, newimage, CV_RGB2GRAY); 
    162         cvReleaseImage(&m_Image); 
    163         m_Image=newimage; 
    164 } 
    165  
    166 void Image::BayerGB2RGB() 
     179        return Image(newimage); 
     180} 
     181 
     182Image Image::BayerGB2RGB() 
    167183{ 
    168184        IplImage *newimage = cvCreateImage(cvGetSize(m_Image), 8, 3); 
    169185    cvCvtColor(m_Image, newimage, CV_BayerGB2RGB); 
    170         cvReleaseImage(&m_Image); 
    171         m_Image=newimage; 
    172 } 
    173  
    174 void Image::Scale(int w, int h) 
     186        return Image(newimage); 
     187} 
     188 
     189Image Image::Scale(int w, int h) 
    175190{ 
    176191        IplImage *newimage = cvCreateImage(cvSize(w,h), m_Image->depth, m_Image->nChannels); 
    177192        cvResize( m_Image, newimage, CV_INTER_LINEAR ); 
    178         cvReleaseImage(&m_Image); 
    179         m_Image=newimage; 
     193        return Image(newimage); 
    180194} 
    181195 
     
    330344        for(int x=0; x<m_Image->width; x++) 
    331345                { 
    332                          
    333346                        h[(unsigned char)cvGet2D(m_Image,y,x).val[channel]]++; 
    334347                } 
     
    338351} 
    339352 
     353Vector<float> Image::ToFloatVector() 
     354{ 
     355        Vector<float> v(m_Image->width*m_Image->height*m_Image->nChannels); 
     356    // for each pixel 
     357        unsigned int pos=0; 
     358    for(int y=0; y<m_Image->height; y++) 
     359        { 
     360        for(int x=0; x<m_Image->width; x++) 
     361                { 
     362                        for (int c=0; c<m_Image->nChannels; c++) 
     363                        { 
     364                                v[pos++]=cvGet2D(m_Image,y,x).val[c]/256.0f; 
     365                        } 
     366                } 
     367        } 
     368        return v; 
     369} 
  • foam/trunk/vision/src/Image.h

    r85 r86  
    1616 
    1717#include "cv.h" 
     18#include "Vector.h" 
    1819#include <string> 
    1920 
     
    2829        Image(const Image &other); 
    2930        Image(const IplImage *other); // copies the given image 
     31        Image(int w, int h, int c, const Vector<float> &v); 
    3032        ~Image(); 
    3133 
     
    3840         
    3941        void Crop(int x, int y, int w, int h); 
    40         void Scale(int w, int h); 
     42        Image Scale(int w, int h); 
    4143 
    4244        // Paste an image into this one 
     
    5355         
    5456        // Convert to different colour spaces 
    55         void GRAY2RGB(); 
    56         void RGB2GRAY(); 
    57         void BayerGB2RGB(); 
     57        Image GRAY2RGB(); 
     58        Image RGB2GRAY(); 
     59        Image BayerGB2RGB(); 
    5860         
    5961        // Calculate a histogram for a given channel 
    6062        unsigned int *Hist(int channel); 
     63         
     64        Vector<float> ToFloatVector(); 
     65        unsigned int NumElements() { return m_Image->width*m_Image->height*m_Image->nChannels; } 
    6166         
    6267        IplImage *m_Image; 
  • foam/trunk/vision/src/LDAClassifier.h

    r85 r86  
    2020#include "Vector.h" 
    2121#include "Matrix.h" 
     22#include "Classifier.h" 
    2223 
    2324#ifndef FOAM_LDA_CLASSIFIER 
     
    2627// A linear discriminant analysis classifier for arbitrary data sets 
    2728 
    28 template<class T> 
    29 class LDAClassifier 
     29class LDAClassifier : public Classifier 
    3030{ 
    3131public: 
     
    3333        ~LDAClassifier(); 
    3434 
    35         class Feature 
    36         { 
    37         public: 
    38                 Vector<T> m_Data; 
    39                 int m_Class; 
    40         }; 
    41  
    42         void AddFeature(const Feature &f); 
    43         int Classify(const Feature &f); 
     35        virtual int Classify(const Vector<float> &f); 
    4436 
    4537private: 
    4638 
    47         void CalcClasses(); 
    48         void CalcGlobalMean(); 
    49         void CalcClassMeans(); 
     39        void CalcGroupMeans(); 
    5040        void CalcMeanCorrected(); 
    5141        void CalcCovariance(); 
    5242        void CalcPooledCovariance(); 
    5343        void CalcPriorProbablity(); 
    54  
    55         unsigned int m_FeatureSize; 
    56         std::vector<Feature > m_Features; 
    5744         
    58         std::set<int> m_Classes; 
    59         Vector<T> m_GlobalMean; 
    60         std::map<int,Vector<T> > m_ClassMeans; 
    61         std::map<int,Matrix<T> > m_MeanCorrected; 
    62         std::map<int,Matrix<T> > m_Covariance; 
    63         Matrix<T> m_PooledCovariance; 
    64         Vector<T> m_PriorProbability; 
     45        std::map<int,Vector<float> > m_GroupMean; 
     46        std::map<int,Matrix<float> > m_MeanCorrected; 
     47        std::map<int,Matrix<float> > m_Covariance; 
     48        //Matrix<T> m_PooledCovariance; 
     49        //Vector<T> m_PriorProbability; 
    6550 
    6651}; 
    6752 
    68 template<class T> 
    69 LDAClassifier<T>::LDAClassifier(unsigned int FeatureSize) 
    70 { 
    71 } 
    72  
    73 template<class T> 
    74 LDAClassifier<T>::~LDAClassifier() 
    75 { 
    76 } 
    77  
    78 template<class T> 
    79 void LDAClassifier<T>::AddFeature(const Feature &f)  
    80 {  
    81         m_Features.push_back(f);  
    82 } 
    83  
    84 template<class T> 
    85 int LDAClassifier<T>::Classify(const Feature &f) 
    86 { 
    87         return 0; 
    88 } 
    89  
    90 template<class T> 
    91 void LDAClassifier<T>::CalcClasses() 
    92 { 
    93         m_Classes.clear(); 
    94         for (typename std::vector<Feature >::iterator i=m_Features.begin(); 
    95                 i!=m_Features.end(); ++i) 
    96         { 
    97                 m_Classes.insert(i->m_Class); 
    98         } 
    99 } 
    100  
    101 template<class T> 
    102 void LDAClassifier<T>::CalcGlobalMean() 
    103 { 
    104  
    105 } 
    106  
    107 template<class T> 
    108 void LDAClassifier<T>::CalcClassMeans() 
    109 { 
    110 } 
    111  
    112 template<class T> 
    113 void LDAClassifier<T>::CalcMeanCorrected() 
    114 { 
    115 } 
    116  
    117 template<class T> 
    118 void LDAClassifier<T>::CalcCovariance() 
    119 { 
    120 } 
    121  
    122 template<class T> 
    123 void LDAClassifier<T>::CalcPooledCovariance() 
    124 { 
    125 } 
    126  
    127 template<class T> 
    128 void LDAClassifier<T>::CalcPriorProbablity() 
    129 { 
    130 } 
    131  
    13253#endif 
  • foam/trunk/vision/src/Matrix.h

    r85 r86  
    1717#include <assert.h> 
    1818#include <iostream> 
     19#include "Vector.h" 
    1920 
    2021#ifndef FOAM_MATRIX 
    2122#define FOAM_MATRIX 
    2223 
    23 template<class T> 
     24template<class T>  
    2425class Matrix 
    2526{ 
    2627public: 
     28        Matrix(); 
    2729        Matrix(unsigned int r, unsigned int c); 
    2830        ~Matrix(); 
    2931        Matrix(const Matrix &other); 
    30          
     32        Matrix(unsigned int r, unsigned int c, float *data); 
     33 
    3134        // Row proxy classes to allow matrix[r][c] notation 
    3235        class Row 
     
    8790        T *GetRawData() { return m_Data; } 
    8891        const T *GetRawDataConst() const { return m_Data; } 
     92        Vector<T> GetRowVector(unsigned int r) const;  
     93        Vector<T> GetColVector(unsigned int c) const;  
    8994          
    9095        void Print() const; 
    9196        void SetAll(T s); 
     97        void Zero() { SetAll(0); } 
     98        bool IsInf(); 
    9299        Matrix Transposed(); 
    93100 
     
    120127 
    121128template<class T> 
     129Matrix<T>::Matrix() : 
     130m_Rows(0), 
     131m_Cols(0), 
     132m_Data(NULL) 
     133{ 
     134} 
     135 
     136template<class T> 
     137Matrix<T>::Matrix(unsigned int r, unsigned int c, float *data) : 
     138m_Rows(r), 
     139m_Cols(c), 
     140m_Data(data) 
     141{ 
     142} 
     143 
     144template<class T> 
    122145Matrix<T>::~Matrix() 
    123146{ 
     
    173196                } 
    174197        } 
     198} 
     199 
     200template<class T> 
     201bool Matrix<T>::IsInf() 
     202{ 
     203        for (unsigned int i=0; i<m_Rows; i++) 
     204        { 
     205                for (unsigned int j=0; j<m_Cols; j++) 
     206                { 
     207                        if (isinf((*this)[i][j])) return true; 
     208                        if (isnan((*this)[i][j])) return true; 
     209                } 
     210        } 
     211        return false; 
    175212} 
    176213 
     
    266303} 
    267304 
     305template<class T> 
     306Vector<T> Matrix<T>::GetRowVector(unsigned int r) const 
     307{ 
     308        assert(r<m_Rows); 
     309        Vector<T> ret(m_Cols); 
     310        for (unsigned int j=0; j<m_Cols; j++) 
     311        { 
     312                ret[j]=(*this)[r][j]; 
     313        } 
     314        return ret; 
     315} 
     316 
     317template<class T> 
     318Vector<T> Matrix<T>::GetColVector(unsigned int c) const 
     319{ 
     320        assert(c<m_Cols); 
     321        Vector<T> ret(m_Rows); 
     322        for (unsigned int i=0; i<m_Rows; i++) 
     323        { 
     324                ret[i]=(*this)[i][c]; 
     325        } 
     326        return ret; 
     327} 
    268328 
    269329template<class T> 
  • foam/trunk/vision/src/Vector.h

    r85 r86  
    1616 
    1717#include <assert.h> 
     18#include <math.h> 
    1819#include <iostream> 
    1920 
     
    2526{ 
    2627public: 
     28        Vector(); 
    2729        Vector(unsigned int s); 
    2830        ~Vector(); 
     
    3032         
    3133        T &operator[](unsigned int i)  
     34        { 
     35                assert(i<m_Size); 
     36                return m_Data[i]; 
     37        } 
     38 
     39        const T &operator[](unsigned int i) const 
    3240        { 
    3341                assert(i<m_Size); 
     
    4149        void Print() const; 
    4250        void SetAll(T s); 
     51        void Zero() { SetAll(0); } 
     52        bool IsInf(); 
    4353 
    4454        Vector &operator=(const Vector &other); 
     
    6171 
    6272template<class T> 
     73Vector<T>::Vector() : 
     74m_Size(0) 
     75{ 
     76        m_Data=NULL; 
     77} 
     78 
     79template<class T> 
    6380Vector<T>::Vector(unsigned int s) : 
    6481m_Size(s) 
     
    113130                (*this)[i]=s; 
    114131        } 
     132} 
     133 
     134template<class T> 
     135bool Vector<T>::IsInf() 
     136{ 
     137        for (unsigned int i=0; i<m_Size; i++) 
     138        { 
     139                if (isinf((*this)[i])) return true; 
     140                if (isnan((*this)[i])) return true; 
     141        } 
     142        return false; 
    115143} 
    116144 
  • foam/trunk/vision/src/main.cpp

    r85 r86  
    2222#include "Matrix.h" 
    2323#include "Vector.h" 
    24 #include "LDAClassifier.h" 
     24#include "PCA.h" 
    2525 
    2626using namespace std; 
     
    3232double scale = 1; 
    3333 
     34PCA pca(Image("data/a-id0001-image0000.png").RGB2GRAY().NumElements()); 
     35int tw=Image("data/a-id0001-image0000.png").RGB2GRAY().m_Image->width; 
     36int th=Image("data/a-id0001-image0000.png").RGB2GRAY().m_Image->height; 
     37int tc=Image("data/a-id0001-image0000.png").RGB2GRAY().m_Image->nChannels; 
     38 
     39void TestPCA() 
     40{ 
     41        pca.AddFeature(Image("data/a-id0001-image0000.png").RGB2GRAY().ToFloatVector()); 
     42        pca.AddFeature(Image("data/a-id0001-image0001.png").RGB2GRAY().ToFloatVector()); 
     43        pca.AddFeature(Image("data/a-id0002-image0000.png").RGB2GRAY().ToFloatVector()); 
     44        pca.AddFeature(Image("data/a-id0002-image0001.png").RGB2GRAY().ToFloatVector()); 
     45        cerr<<"pre calc"<<endl; 
     46        pca.Calculate(); 
     47        cerr<<"post calc"<<endl; 
     48} 
     49 
     50 
    3451int main( int argc, char** argv ) 
    3552{ 
     53 
     54        PCA::RunTests(); 
     55        TestPCA(); 
     56 
    3657    CvCapture* capture = 0; 
    3758    IplImage *frame, *frame_copy = 0; 
     
    190211        ////////////////////////////////// 
    191212        // image differencing 
    192          
     213        /* 
    193214        vector<Image> imagevec; 
    194215        //imagevec.push_back(Image("data/audrey.png")); 
     
    233254        //camera.Blit(dave2,140,100); 
    234255        //camera.Blit(other,180,100); 
    235          
    236          
    237  
    238      cvShowImage("result", camera.m_Image); 
     256        */ 
     257         
     258        /////////////////////////////////// 
     259        // PCA display 
     260         
     261        for (int i=0; i<10; i++) 
     262        { 
     263                camera.Blit(Image(tw,th,tc,pca.GetEigenTransform().GetRowVector(i)),i*50,100); 
     264        } 
     265 
     266    cvShowImage("result", camera.m_Image); 
    239267  
    240268} 
Note: See TracChangeset for help on using the changeset viewer.