Changeset 85


Ignore:
Timestamp:
05/29/2009 04:12:50 PM (11 years ago)
Author:
dave
Message:

started writing the LDA classifier

Location:
foam/trunk/vision
Files:
3 added
4 edited

Legend:

Unmodified
Added
Removed
  • foam/trunk/vision/Makefile

    r81 r85  
    3333        -rm -f *~ src/*.o ${TARGET}  
    3434 
     35cleandeps:: clean 
     36        -rm -f src/*.dep 
     37 
    3538distclean:: clean 
    3639 
  • foam/trunk/vision/src/Image.cpp

    r80 r85  
    3030{ 
    3131        m_Image=cvLoadImage(filename.c_str()); 
    32 } 
    33  
    34 Image::Image(const Image *other) 
    35 { 
    36         m_Image=cvCloneImage(other->m_Image); 
     32        assert(m_Image); 
     33} 
     34 
     35Image::Image(const Image &other) 
     36{ 
     37        m_Image=cvCloneImage(other.m_Image); 
     38} 
     39 
     40Image::Image(const IplImage *other) 
     41{ 
     42        m_Image=cvCloneImage(other); 
    3743} 
    3844 
     
    4046{ 
    4147        cvReleaseImage(&m_Image); 
     48} 
     49 
     50void Image::Clear() 
     51{ 
     52    for(int y=0; y<m_Image->height; y++) 
     53        { 
     54        for(int x=0; x<m_Image->width; x++) 
     55                { 
     56                        CvScalar v; 
     57                         
     58                        for (int c=0; c<m_Image->nChannels; c++) 
     59                        { 
     60                                v.val[c]=0; 
     61                        } 
     62                                                 
     63                        cvSet2D(m_Image,y,x,v); 
     64                } 
     65        } 
     66} 
     67 
     68Image Image::operator-(const Image &other) 
     69{ 
     70        assert(other.m_Image->width == m_Image->width); 
     71        assert(other.m_Image->height == m_Image->height); 
     72        assert(other.m_Image->nChannels == m_Image->nChannels); 
     73 
     74        Image ret(*this); 
     75 
     76    for(int y=0; y<m_Image->height; y++) 
     77        { 
     78        for(int x=0; x<m_Image->width; x++) 
     79                { 
     80                        CvScalar v; 
     81                        v.val[0]=0;v.val[1]=0;v.val[2]=0;v.val[3]=0; 
     82                        for (int c=0; c<m_Image->nChannels; c++) 
     83                        { 
     84                                v.val[c]=abs((int)(cvGet2D(m_Image,y,x).val[c] -  
     85                                                   cvGet2D(other.m_Image,y,x).val[c]));          
     86                        } 
     87                        cvSet2D(ret.m_Image,y,x,v); 
     88                } 
     89        } 
     90        return ret; 
     91} 
     92 
     93Image Image::operator+(const Image &other) 
     94{ 
     95        assert(other.m_Image->width == m_Image->width); 
     96        assert(other.m_Image->height == m_Image->height); 
     97        assert(other.m_Image->nChannels == m_Image->nChannels); 
     98 
     99        Image ret(*this); 
     100 
     101    for(int y=0; y<m_Image->height; y++) 
     102        { 
     103        for(int x=0; x<m_Image->width; x++) 
     104                { 
     105                        CvScalar v; 
     106                        for (int c=0; c<m_Image->nChannels; c++) 
     107                        { 
     108                                v.val[c]=cvGet2D(m_Image,y,x).val[c] +  
     109                                         cvGet2D(other.m_Image,y,x).val[c];              
     110                        } 
     111                        cvSet2D(&ret,y,x,v); 
     112                } 
     113        } 
     114         
     115        return ret; 
    42116} 
    43117 
     
    106180} 
    107181 
    108 void Image::Blit(const Image &image, CvPoint pos) 
     182void Image::Blit(const Image &image, int px, int py) 
    109183{        
    110184        for(int y=0; y<image.m_Image->height; y++) 
     
    112186        for(int x=0; x<image.m_Image->width; x++) 
    113187                { 
    114                         if (x+pos.x>0 && x+pos.x<m_Image->width && 
    115                                 y+pos.y>0 && y+pos.y<m_Image->height) 
    116                         { 
    117                 cvSet2D(m_Image,y+pos.y,x+pos.x,cvGet2D(image.m_Image,y,x)); 
     188                        if (x+px>0 && x+px<m_Image->width && 
     189                                y+py>0 && y+py<m_Image->height) 
     190                        { 
     191                cvSet2D(m_Image,y+py,x+px,cvGet2D(image.m_Image,y,x)); 
    118192                        } 
    119193                } 
  • foam/trunk/vision/src/Image.h

    r80 r85  
    2626        Image(int w, int h, int d, int c); 
    2727        Image(const std::string &filename); 
    28         Image(const Image *other); 
     28        Image(const Image &other); 
     29        Image(const IplImage *other); // copies the given image 
    2930        ~Image(); 
     31 
     32        void Clear(); 
     33 
     34        Image operator-(const Image &other); 
     35        Image operator+(const Image &other); 
    3036 
    3137        void PrintInfo(); 
     
    3541 
    3642        // Paste an image into this one 
    37         void Blit(const Image &image, CvPoint pos); 
     43        void Blit(const Image &image, int x, int y); 
    3844         
    3945        // Return a sum of squared differences, for giving a similarity metric  
  • foam/trunk/vision/src/main.cpp

    r83 r85  
    1313#include <time.h> 
    1414#include <ctype.h> 
     15#include <vector> 
    1516 
    1617#ifdef _EiC 
     
    1920 
    2021#include "Image.h" 
     22#include "Matrix.h" 
     23#include "Vector.h" 
     24#include "LDAClassifier.h" 
     25 
     26using namespace std; 
    2127 
    2228static CvMemStorage* storage = 0; 
     
    167173void detect_and_draw( IplImage* img ) 
    168174{ 
    169     IplImage *gray, *small_img; 
    170     int i, j; 
    171  
    172     gray = cvCreateImage( cvSize(img->width,img->height), 8, 1 ); 
    173     small_img = cvCreateImage( cvSize( cvRound (img->width/scale), 
    174                          cvRound (img->height/scale)), 8, 1 ); 
    175  
    176     cvCvtColor( img, gray, CV_BGR2GRAY ); 
    177     cvResize( gray, small_img, CV_INTER_LINEAR ); 
    178     cvEqualizeHist( small_img, small_img ); 
    179     cvClearMemStorage( storage ); 
    180          
     175        Image camera(img); 
     176        CvFont font; 
     177        cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, 0.5, 0.5, 0, 1, CV_AA ); 
     178 
     179        ////////////////////////////////// 
     180        // Matrix tests 
     181        Matrix<float>::RunTests(); 
     182 
     183        ////////////////////////////////// 
    181184        // test the debayering 
    182         Image im("data/bayer.pgm"); 
     185        /*Image im("data/bayer.pgm"); 
    183186        im.Crop(300,300,320,240); 
    184187        im.RGB2GRAY(); 
    185         //im.PrintInfo(); 
    186         im.BayerGB2RGB(); 
    187     cvShowImage( "result", im.m_Image ); 
    188          
    189 /*  
    190         IplImage *li = cvLoadImage("test3-0.png"); 
    191         lpbhist(0, 0, li, gray); 
    192         cvReleaseImage( &li ); 
     188        im.BayerGB2RGB();*/ 
     189         
     190        ////////////////////////////////// 
     191        // image differencing 
     192         
     193        vector<Image> imagevec; 
     194        //imagevec.push_back(Image("data/audrey.png")); 
     195        imagevec.push_back(Image("data/dave-1.png")); 
     196        imagevec.push_back(Image("data/dave-2.png")); 
     197        imagevec.push_back(Image("data/amber-1.png")); 
     198        imagevec.push_back(Image("data/amber-2.png")); 
     199        //imagevec.push_back(Image("data/false.png")); 
     200 
     201        for(unsigned int x=0; x<imagevec.size(); x++) 
     202        { 
     203                //cvSobel(imagevec[x].m_Image, imagevec[x].m_Image, 2, 2); 
     204                //cvSmooth(imagevec[x].m_Image, imagevec[x].m_Image, CV_GAUSSIAN, 7); 
     205                //imagevec[x].SubMean(); 
     206        } 
     207 
     208        camera.Clear(); 
     209 
     210        for(unsigned int x=0; x<imagevec.size(); x++) 
     211        { 
     212                camera.Blit(imagevec[x],100+50*x,50); 
     213        } 
     214 
     215        for(unsigned int x=0; x<imagevec.size(); x++) 
     216        { 
     217                camera.Blit(imagevec[x],50, 100+50*x); 
     218        } 
     219         
     220        for(unsigned int x=0; x<imagevec.size(); x++) 
     221        { 
     222                for(unsigned int y=0; y<imagevec.size(); y++) 
     223                { 
     224                        Image diff=imagevec[x]-imagevec[y]; 
     225                        camera.Blit(diff,100+50*x,100+50*y); 
     226                        char s[32]; 
     227                        sprintf(s,"%0.5f",1-imagevec[x].SSD(imagevec[y])); 
     228                        cvPutText(camera.m_Image, s, cvPoint(100+50*x,150+50*y), &font, colors[0]);              
     229                } 
     230        } 
     231         
     232        //camera.Blit(dave1,100,100); 
     233        //camera.Blit(dave2,140,100); 
     234        //camera.Blit(other,180,100); 
     235         
     236         
     237 
     238     cvShowImage("result", camera.m_Image); 
    193239  
    194         li = cvLoadImage("test3-1.png"); 
    195         lpbhist(100, 0, li, gray); 
    196         cvReleaseImage( &li ); 
    197   
    198         li = cvLoadImage("test3-3.png"); 
    199         lpbhist(200, 0, li, gray); 
    200         cvReleaseImage( &li ); 
    201 */ 
    202     cvReleaseImage( &gray ); 
    203     cvReleaseImage( &small_img ); 
    204240} 
    205241 
Note: See TracChangeset for help on using the changeset viewer.