The Machine Perception Toolbox

[Introduction]- [News]- [Download]- [Screenshots]- [Manual (pdf)]- [Forums]- [API Reference]- [Repository ]

 

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

mp_eyefinderMex.cc File Reference

#include "mp_eyefinderMex.h"
#include "loadstruct.h"
#include <iostream>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include "mex.h"
#include "matrix.h"

Include dependency graph for mp_eyefinderMex.cc:

Include dependency graph

Go to the source code of this file.

Functions

double difftv (const struct timeval &t1, const struct timeval &t0)
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])


Function Documentation

double difftv const struct timeval &  t1,
const struct timeval &  t0
[inline, static]
 

Definition at line 91 of file mp_eyefinderMex.cc.

00092 { return( (t1.tv_sec -t0.tv_sec )*1.0 +(t1.tv_usec-t0.tv_usec)*1e-6); }

void mexFunction int  nlhs,
mxArray *  plhs[],
int  nrhs,
const mxArray *  prhs[]
 

Definition at line 98 of file mp_eyefinderMex.cc.

References VisualObject::activation, RImage::array, ObjectList::begin(), c, combine_mode, difftv(), ObjectList::end(), FaceObject::eyes, f(), faces, MPEyeFinder::findEyes(), EyeObject::flag, RImage::height, i, img, MPEyeFinder::initStream(), k, FaceObject::leftEyes, mode_strings, modestr, r, FaceObject::rightEyes, VisualObject::scale, VisualObject::size(), ObjectList::size(), RImage::width, VisualObject::x, bEyesObject::xLeft, bEyesObject::xRight, VisualObject::xSize, VisualObject::y, bEyesObject::yLeft, and bEyesObject::yRight.

00099 {
00100   //[boxes, detects] = MPEyeFinderMex(ci, ci2, img, get_detects)
00101   // check and get input / output
00102   if (nlhs < 1 )
00103     mexErrMsgTxt("mp_eyefinderMex: requires at least one output");
00104   if (nrhs < 5)
00105         mexErrMsgTxt("mp_eyefinderMex: requires at least 5 inputs");
00106 
00107   const mxArray ** leftCI = &(prhs[0]);
00108   const mxArray ** rightCI = &(prhs[1]);
00109   double * img = mxGetPr(prhs[2]);
00110   int rows = static_cast<int>(mxGetM(prhs[2]));
00111   int cols = static_cast<int>(mxGetN(prhs[2]));
00112   int get_detects = static_cast<int>(mxGetScalar(prhs[3]));
00113         int modestrlen = 256;
00114   char modestr[255];
00115   mxGetString(prhs[4],modestr,modestrlen);
00116   combine_mode themode;
00117   cout << "Using mode "<<modestr<<endl;
00118         for(int i = 0; i < num_modes; ++i){
00119                 if(!strcmp(modestr,mode_strings[i])){
00120                         themode = static_cast<combine_mode>(i);
00121       break;
00122     }
00123   }
00124         cout << "The enum we got was " << themode << endl;
00125 
00126   // create image and make upright (i.e., transpose)
00127   RImage<MPISEARCH_PIXEL_TYPE> pixels(cols, rows);
00128   // cout << "Image: "
00129   //     << pixels.width
00130   //     << "x" << pixels.height
00131   //     << endl;
00132   int ct = 0;
00133   for (int c = 0; c < cols; c++){
00134     for(int r = 0; r < rows; r++){
00135       pixels.array[cols*r+c] = static_cast<MPISEARCH_PIXEL_TYPE>(*(img++));
00136     }
00137   }
00138 
00139   // Initialize the MPEyeFinderMex object
00140   struct timeval tv_now, last;
00141   gettimeofday(&last,0);
00142   MPEyeFinderMex *mpeyefinder = new MPEyeFinderMex(leftCI, rightCI);
00143   gettimeofday(&tv_now,0);
00144   // cout << "Loading the data took " << difftv(tv_now, last) << " seconds" << endl;
00145   mpeyefinder->initStream(pixels.width, pixels.height);
00146 
00147   // Search
00148   VisualObject faces;
00149   // cout << "Starting Search" << endl;
00150   gettimeofday(&last,0);
00151   mpeyefinder->findEyes(pixels, faces, 1.0f, themode);
00152   gettimeofday(&tv_now,0);
00153   cout << "   The search took "<< difftv(tv_now, last) << " seconds" << endl;
00154 
00155   // Write results into matlab struct array
00156 
00157   int dims[2];
00158   dims[0] = faces.size(); dims[1] = 1;
00159 
00160   if(faces.size()){
00161     // initialize field names
00162     // stupid, but matlab crashes if I just pass field_names in directly
00163     const int nfields = 17;
00164     const char field_names[nfields][25] = {"x","y","size","xLeft","yLeft","xRight","yRight",
00165                                 "left_eye_x","left_eye_y","left_eye_size","left_eye_activation","left_eye_flag",
00166                                                 "right_eye_x","right_eye_y","right_eye_size","right_eye_activation","right_eye_flag"};
00167     const char **fnames;       /* pointers to field names */
00168     fnames = (const char **)mxCalloc(nfields, sizeof(*fnames));
00169     for(int i = 0; i < nfields; ++i){
00170       fnames[i] = (char *)malloc(25 * sizeof(char));
00171       strcpy((char *)fnames[i],field_names[i]);
00172     }
00173     // cout << "Creating struct matrix" << endl;
00174     plhs[0] = mxCreateStructArray(2, dims, nfields, fnames);
00175     mxFree(fnames);
00176     if(plhs[0] == NULL)
00177       mexErrMsgTxt("could not allocate space for struct");
00178     int xfield = mxGetFieldNumber(plhs[0],"x");
00179     int yfield = mxGetFieldNumber(plhs[0],"y");
00180     int sizefield = mxGetFieldNumber(plhs[0],"size");
00181     int xLeftfield = mxGetFieldNumber(plhs[0],"xLeft");
00182     int yLeftfield = mxGetFieldNumber(plhs[0],"yLeft");
00183     int xRightfield = mxGetFieldNumber(plhs[0],"xRight");
00184     int yRightfield = mxGetFieldNumber(plhs[0],"yRight");
00185     int left_eye_xfield = mxGetFieldNumber(plhs[0],"left_eye_x");
00186     int left_eye_yfield = mxGetFieldNumber(plhs[0],"left_eye_y");
00187     int left_eye_sizefield = mxGetFieldNumber(plhs[0],"left_eye_size");
00188     int left_eye_activationfield = mxGetFieldNumber(plhs[0],"left_eye_activation");
00189     int left_eye_flagfield = mxGetFieldNumber(plhs[0],"left_eye_flag");
00190     int right_eye_xfield = mxGetFieldNumber(plhs[0],"right_eye_x");
00191     int right_eye_yfield = mxGetFieldNumber(plhs[0],"right_eye_y");
00192     int right_eye_sizefield = mxGetFieldNumber(plhs[0],"right_eye_size");
00193     int right_eye_activationfield = mxGetFieldNumber(plhs[0],"right_eye_activation");
00194     int right_eye_flag = mxGetFieldNumber(plhs[0],"right_eye_flag");
00195 
00196     list<VisualObject *>::iterator face = faces.begin();
00197     list<VisualObject *>::iterator last_face = faces.end();
00198     // cout << "Num Faces: " << faces.size() << endl;
00199     for(int i = 0; face != last_face; ++face, ++i){
00200       // cout << "Setting fields for face " << i << endl; 
00201       FaceObject *f = static_cast<FaceObject*>(*face);
00202       // cout << "f->x: " << f->x << endl;
00203       mxArray *facex = mxCreateDoubleScalar(f->x);
00204       mxSetFieldByNumber(plhs[0],i,xfield,facex);
00205       mxArray *facey = mxCreateDoubleScalar(f->y);
00206       mxSetFieldByNumber(plhs[0],i,yfield,facey);
00207       mxArray *facesize = mxCreateDoubleScalar(f->xSize);
00208       mxSetFieldByNumber(plhs[0],i,sizefield,facesize);
00209       mxArray *facexLeft = mxCreateDoubleScalar(f->eyes.xLeft);
00210       mxSetFieldByNumber(plhs[0],i,xLeftfield,facexLeft);
00211       mxArray *faceyLeft = mxCreateDoubleScalar(f->eyes.yLeft);
00212       mxSetFieldByNumber(plhs[0],i,yLeftfield,faceyLeft);
00213       mxArray *facexRight = mxCreateDoubleScalar(f->eyes.xRight);
00214       mxSetFieldByNumber(plhs[0],i,xRightfield,facexRight);
00215       mxArray *faceyRight = mxCreateDoubleScalar(f->eyes.yRight);
00216       mxSetFieldByNumber(plhs[0],i,yRightfield,faceyRight);
00217 
00218 
00219       // Create structures for eyes of each face
00220       // cout << "Doing left eyes" << endl;
00221       int numLeftEyes = f->leftEyes.size();
00222       mxArray *left_eye_x;
00223       mxArray *left_eye_y;
00224       mxArray *left_eye_size;
00225       mxArray *left_eye_act;
00226       mxArray *left_eye_flag;
00227       if(numLeftEyes == 0){
00228         left_eye_x = mxCreateDoubleMatrix(0,0,mxREAL);
00229         left_eye_y = mxCreateDoubleMatrix(0,0,mxREAL);
00230         left_eye_size = mxCreateDoubleMatrix(0,0,mxREAL);
00231         left_eye_act = mxCreateDoubleMatrix(0,0,mxREAL);
00232         left_eye_flag = mxCreateDoubleMatrix(0,0,mxREAL);
00233 
00234       } else {
00235         left_eye_x = mxCreateDoubleMatrix(numLeftEyes,1,mxREAL);
00236         left_eye_y = mxCreateDoubleMatrix(numLeftEyes,1,mxREAL);
00237         left_eye_size = mxCreateDoubleMatrix(numLeftEyes,1,mxREAL);
00238         left_eye_act = mxCreateDoubleMatrix(numLeftEyes,1,mxREAL);
00239         left_eye_flag = mxCreateDoubleMatrix(numLeftEyes,1,mxREAL);
00240         double *plx, *ply, *pls, *pla, *plf;
00241         plx = mxGetPr(left_eye_x);
00242         ply = mxGetPr(left_eye_y);
00243         pls = mxGetPr(left_eye_size);
00244         pla = mxGetPr(left_eye_act);
00245         plf = mxGetPr(left_eye_flag);
00246         for(int k = 0; k < f->leftEyes.size(); ++k){
00247                                         EyeObject *le = &(f->leftEyes[k]);
00248                                         *plx++ = le->x;
00249                                         *ply++ = le->y;
00250                                         *pls++ = le->scale;
00251                                         *pla++ = le->activation;
00252                 *plf++ = le->flag;
00253         }
00254       }
00255       mxSetField(plhs[0], i, "left_eye_x", left_eye_x);
00256       mxSetField(plhs[0], i, "left_eye_y", left_eye_y);
00257       mxSetField(plhs[0], i, "left_eye_size", left_eye_size);
00258       mxSetField(plhs[0], i, "left_eye_activation", left_eye_act);
00259       mxSetField(plhs[0], i, "left_eye_flag", left_eye_flag);
00260 
00261       // cout << "Doing right eyes" << endl;
00262       int numRightEyes = f->rightEyes.size();
00263       mxArray *right_eye_x;
00264       mxArray *right_eye_y;
00265       mxArray *right_eye_size;
00266       mxArray *right_eye_act;
00267       mxArray *right_eye_flag;
00268       if(numRightEyes == 0){
00269         right_eye_x = mxCreateDoubleMatrix(0,0,mxREAL);
00270         right_eye_y = mxCreateDoubleMatrix(0,0,mxREAL);
00271         right_eye_size = mxCreateDoubleMatrix(0,0,mxREAL);
00272         right_eye_act = mxCreateDoubleMatrix(0,0,mxREAL);
00273         right_eye_flag = mxCreateDoubleMatrix(0,0,mxREAL);
00274       } else {
00275         right_eye_x = mxCreateDoubleMatrix(numRightEyes,1,mxREAL);
00276         right_eye_y = mxCreateDoubleMatrix(numRightEyes,1,mxREAL);
00277         right_eye_size = mxCreateDoubleMatrix(numRightEyes,1,mxREAL);
00278         right_eye_act = mxCreateDoubleMatrix(numRightEyes,1,mxREAL);
00279         right_eye_flag = mxCreateDoubleMatrix(numRightEyes,1,mxREAL);
00280         double *prx, *pry, *prs, *pra, *prf;
00281         prx = mxGetPr(right_eye_x);
00282         pry = mxGetPr(right_eye_y);
00283         prs = mxGetPr(right_eye_size);
00284         pra = mxGetPr(right_eye_act);
00285         prf = mxGetPr(right_eye_flag);
00286         for(int k = 0; k < f->rightEyes.size(); ++k){
00287           EyeObject *re = &(f->rightEyes[k]);
00288           *prx++ = re->x;
00289           *pry++ = re->y;
00290           *prs++ = re->scale;
00291           *pra++ = re->activation;
00292           *prf++ = re->flag;
00293         }
00294       }
00295       mxSetField(plhs[0], i, "right_eye_x", right_eye_x);
00296       mxSetField(plhs[0], i, "right_eye_y", right_eye_y);
00297       mxSetField(plhs[0], i, "right_eye_size", right_eye_size);
00298       mxSetField(plhs[0], i, "right_eye_activation", right_eye_act);
00299       mxSetField(plhs[0], i, "right_eye_flag", right_eye_flag);
00300 
00301     }
00302   } else {
00303     plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
00304   }
00305   delete mpeyefinder;
00306 }

Here is the call graph for this function:


Generated on Mon Nov 8 17:08:13 2004 for MPT by  doxygen 1.3.9.1