main.cpp

**main.cpp** code is as follows.
 
include <iostream>
 
include <cmath>
 
include "FaceFeatures.h"
 
include "FaceDetector.h"
 
include <opencv2 highgui="" highgui.hpp="">
 
include <cstdlib>
 
follows.
#include <iostream>
#include <cmath>
#include "FaceFeatures.h"
#include "FaceDetector.h"
#include <opencv2/highgui/highgui.hpp>
#include <cstdlib>
using namespace std;
using namespace cv;
 
cv;
void process_features(FaceDetector &face_detect,Mat &frame, Face face);
 
face);
int
main(int argc, char argv[])
{
CvCapture *argv[])
{
CvCapture* capture = NULL;
 
NULL;
double t = 0.0;
Mat frame, frameCopy;
 
frameCopy;
Mat gray;
string fname;
vector<face> faces;
 
vector<Face> faces;
unsigned int kmod = 0;
 
0;
FaceDetector faceDetector("haarcascade_frontalface_alt.xml",
"haarcascade_mcs_mouth.xml",
"haarcascade_mcs_nose.xml",
"haarcascade_mcs_lefteye.xml",
"haarcascade_mcs_righteye.xml");
 
"haarcascade_mcs_righteye.xml");
capture = cvCaptureFromCAM(0);
cvNamedWindow("result", 1);
 
1);
if( capture ) {
cout << "In capture ..." << endl;
for(;;) {
kmod++;
IplImage* iplImg = cvQueryFrame( capture );
frame = iplImg;
 
iplImg;
 if( frame.empty() )
 break;
  if( iplImg->origin == IPL_ORIGIN_TL )
 frame.copyTo( frameCopy );
 else
  flip( frame, frameCopy, 0 );
  if( waitKey( 10 ) >= 0 )
 goto _cleanup_;
 if(kmod%2 == 0) {
  faces.clear(); /*Empty face list*/
 
 faceDetector.detect(frameCopy, faces);
}
vector<face>::const_iterator vector<Face>::const_iterator it;
for(it = faces.begin(); it != faces.end(); it++) {
process_features(faceDetector, frameCopy, *it);
}
imshow("result", frameCopy);
}
}
 
}
_cleanup_:
cvReleaseCapture( &capture );
 
);
return 0;
}
 
}
double calc_dist(Point p1, Point p2)
{
double v,aa,bb;
aa=p1.x -p2.x;
bb=p1.y-p2.y ;
v = sqrt(pow(aa,2) + pow (bb,2 ));
return v;
}
 
}
void
process_features(FaceDetector &face_detect, Mat &frame, Face face)
{
static bool initialized = false;
static DistanceFeatures neutral;
static int init_counter = 0;
 
0;
// cout<<"processing"<<endl; rectangle(frame,="" point(face.face_box.x,="" face.face_box.y),="" point(face.face_box.x+="" face.face_box.width,="" face.face_box.y+face.face_box.height),="" cv_rgb(0,="" 0="" ,="" 255="" ));="" <="" p="">
cout<<"processing"<<endl;
rectangle(frame, Point(face.face_box.x, face.face_box.y), Point(face.face_box.x+ face.face_box.width, face.face_box.y+face.face_box.height), CV_RGB(0, 0 , 255 ));
circle(frame, face.features.mouth.lip_left_edge, 3, CV_RGB(255, 0 , 0 ), -1);
circle(frame, face.features.mouth.lip_right_edge, 3, CV_RGB(255, 0 , 0 ), -1);
circle(frame, face.features.mouth.lip_top_center, 3, CV_RGB(255, 0 , 0 ), -1);
circle(frame, face.features.mouth.lip_bottom_center, 3, CV_RGB(255, 0 , 0 ), -1);
 
-1);
circle(frame, face.features.eyes.left_eye_top, 3, CV_RGB(255, 0 , 0 ), -1);
circle(frame, face.features.eyes.left_eye_bottom, 3, CV_RGB(255, 0 , 0 ), -1);
 
-1);
circle(frame, face.features.eyes.right_eye_top, 3, CV_RGB(255, 0 , 0 ), -1);
circle(frame, face.features.eyes.right_eye_bottom, 3, CV_RGB(255, 0 , 0 ), -1);
 
-1);
circle(frame, face.features.brows.left_brow_left, 3, CV_RGB(0, 255 , 0 ), -1);
circle(frame, face.features.brows.left_brow_center, 3, CV_RGB(0, 255 , 0 ), -1);
circle(frame, face.features.brows.left_brow_right, 3, CV_RGB(0, 255 , 0 ), -1);
 
-1);
circle(frame, face.features.brows.right_brow_left, 3, CV_RGB(0, 255 , 0 ), -1);
circle(frame, face.features.brows.right_brow_center, 3, CV_RGB(0,255 , 0 ), -1);
circle(frame, face.features.brows.right_brow_right, 3, CV_RGB(0, 255 , 0 ), -1);
 
-1);
circle(frame, face.features.nose.center, 3, CV_RGB(0, 255 , 0 ), -1);
 
-1);
double mouth_w = calc_dist(face.features.mouth.lip_left_edge, face.features.mouth.lip_right_edge);
double mouth_h = calc_dist(face.features.mouth.lip_top_center, face.features.mouth.lip_bottom_center);
 
face.features.mouth.lip_bottom_center);
double d_left_eye = calc_dist(face.features.eyes.left_eye_top, face.features.eyes.left_eye_bottom);
double d_right_eye = calc_dist(face.features.eyes.right_eye_top, face.features.eyes.right_eye_bottom);
 
face.features.eyes.right_eye_bottom);
double d_left_brow_left = calc_dist(face.features.brows.left_brow_left, face.features.nose.center);
double d_left_brow_middle = calc_dist(face.features.brows.left_brow_center, face.features.nose.center);
double d_left_brow_right = calc_dist(face.features.brows.left_brow_right, face.features.nose.center);
 
face.features.nose.center);
double d_right_brow_left = calc_dist(face.features.brows.right_brow_left, face.features.nose.center);
double d_right_brow_middle = calc_dist(face.features.brows.right_brow_center, face.features.nose.center);
double d_right_brow_right = calc_dist(face.features.brows.right_brow_right, face.features.nose.center);
 
face.features.nose.center);
DistanceFeatures tmp;
tmp.mouth_w = mouth_w;
tmp.mouth_h = mouth_h;
tmp.d_left_eye = d_left_eye;
tmp.d_right_eye = d_right_eye;
 
if 0
 
d_right_eye;
#if 0
tmp.d_left_brow_left = d_left_brow_left;
tmp.d_left_brow_middle = d_left_brow_middle;
tmp.d_left_brow_right = d_left_brow_right;
 
d_left_brow_right;
tmp.d_right_brow_left = d_right_brow_left;
tmp.d_right_brow_middle = d_right_brow_middle;
tmp.d_right_brow_right = d_right_brow_right;
 
endif
 
d_right_brow_right;
#endif
if(init_counter == 0) {
cout<<"Calibrating neutral face.."<<endl; init_counter++;="" }="" else="" if(init_counter="=" 20)="" {="" initialized="true;" neutral="tmp;" init_counter++;<="" p="">
face.."<<endl;
init_counter++;
}
else if(init_counter == 20) {
initialized = true;
neutral = tmp;
init_counter++;
cout<<"Calibrated!"<<endl;
 
 }
else {
init_counter++;
}
 
}
double out[4];
 
out[4];
if(initialized) {
face_detect.detect_emotion(tmp, neutral, out);
for(int i=0;i<4;i++) {cout<<out[i]&lt;&lt;" ";}="" cout&lt;<endl;="" }="" }<="" p="">
facedetector.cpp {cout<<out[i]<<" ";}
cout<<endl;
}
}
**facedetector.cpp** code is as follows:
 
include <iostream>
 
include "HaarCascadeObjectDetector.h"
 
include "FaceDetector.h"
 
follows:
#include <iostream>
#include "HaarCascadeObjectDetector.h"
#include "FaceDetector.h"
//#include "fann.h"
 
include<malloc.h>
 
include<opencv2\core\core.hpp>
 
"fann.h"
#include<malloc.h>
#include<opencv2\core\core.hpp>
using namespace std;
using namespace cv;
 
cv;
//struct fann *ann;
 
*ann;
FaceDetector::FaceDetector(string face_cascade_file, string mouth_cascade_file, string nose_cascade_file, string left_eye_cascade_file, string right_eye_cascade_file)
{
 
{
this->detector = new HaarCascadeObjectDetector(face_cascade_file);
this->mouthFeatureDetector = new MouthFeatureDetector(mouth_cascade_file);
this->noseFeatureDetector = new NoseFeatureDetector(nose_cascade_file);
this->eyeFeatureDetector = new EyeFeatureDetector(left_eye_cascade_file, right_eye_cascade_file);
this->browFeatureDetector = new BrowFeatureDetector();
 
BrowFeatureDetector();
this->ann = fann_create_from_file("emotions.net");
}
 
}
FaceDetector::FaceDetector(cv::CascadeClassifier face_cascade, cv::CascadeClassifier mouth_cascade, cv::CascadeClassifier nose_cascade, cv::CascadeClassifier left_cascade, cv::CascadeClassifier right_cascade)
{
this->detector = new HaarCascadeObjectDetector(face_cascade);
this->mouthFeatureDetector = new MouthFeatureDetector(mouth_cascade);
this->noseFeatureDetector = new NoseFeatureDetector(nose_cascade);
this->eyeFeatureDetector = new EyeFeatureDetector(left_cascade, right_cascade);
this->browFeatureDetector = new BrowFeatureDetector();
 
BrowFeatureDetector();
this->ann = fann_create_from_file("emotions.net");
}
 
}
FaceDetector::~FaceDetector()
{
delete this->detector;
delete this->mouthFeatureDetector;
delete this->noseFeatureDetector;
delete this->eyeFeatureDetector;
delete this->browFeatureDetector;
 
this->browFeatureDetector;
fann_destroy(this->ann);
}
 
}
int
FaceDetector::detect(Mat image, vector<face>& vector<Face>& faces)
{
Mat gray;
vector<rect> vector<Rect> face_rects;
Face tmp;
 
tmp;
cvtColor(image, gray, CV_BGR2GRAY);
detector->detect(gray, face_rects); /Detect /*Detect using Haar cascades/ 
 
/Do cascades*/
/*Do feature detection/
vector<rect>::const_iterator detection*/
vector<Rect>::const_iterator it;
for(it = face_rects.begin(); it != face_rects.end(); it++)
{
tmp.face_box = it;
*it;
 this->mouthFeatureDetector->detect(gray, *it, tmp.features.mouth); /Detect /*Detect features on mouth/
mouth*/
 this->noseFeatureDetector->detect(gray, *it, tmp.features.nose); /Detect /*Detect features on nose/
nose*/
 this->eyeFeatureDetector->detect(gray, *it, tmp.features.eyes); /Detect /*Detect eye features/
features*/
 this->browFeatureDetector->detect(gray, *it, tmp.features.brows); /Detect /*Detect brow features*/
//cout<<tmp.features.mouth.lip_left_edge&lt;<endl; faces.push_back(tmp);="" }="" return="" null;="" }<="" p="">
if 0
 
endif
 
//cout<<tmp.features.mouth.lip_left_edge<<endl;
faces.push_back(tmp);
}
return NULL;
}
#if 0
#endif
void FaceDetector::detect_emotion(DistanceFeatures emotion, DistanceFeatures neutral,double *output)
{
fann_type *calc_out;
 
*calc_out;
fann_type input[10];
calc_out=0;
/*
input[0] = emotion.mouth_w/neutral.mouth_w;
input[1] = emotion.mouth_h/neutral.mouth_h;
 
emotion.mouth_h/neutral.mouth_h;
input[2] = emotion.d_left_eye/neutral.d_left_eye;
input[3] = emotion.d_right_eye/neutral.d_right_eye;
 
emotion.d_right_eye/neutral.d_right_eye;
input[4] = emotion.d_left_brow_left/neutral.d_left_brow_left;
input[5] = emotion. d_left_brow_middle/neutral. d_left_brow_middle;
input[6] = emotion.d_left_brow_right/neutral.d_left_brow_right;
 
emotion.d_left_brow_right/neutral.d_left_brow_right;
input[7] = emotion.d_right_brow_left/neutral.d_right_brow_left;
input[8] = emotion.d_right_brow_middle/neutral.d_right_brow_middle;
input[9] = emotion.d_right_brow_right/neutral.d_right_brow_right;
*/
input[0] = 1.0;
input[1] = 1.0;
input[2] = 1.0;
input[3] = 1.0;
input[4] = 1.0;
input[5] = 1.0;
input[6] = 1.0;
input[7] = 1.0;
input[8] = 1.0;
input[9] = 1.0;
 
1.0;
calc_out = fann_run(this->ann, input);
 
input);
//output=((double *) (malloc(25 * sizeof(double))));
 
sizeof(double))));
output[0] = ((double)calc_out[0]);
output[1] = ((double)calc_out[1]);
output[2] = ((double)calc_out[2]);
output[3] = ((double)calc_out[3]);
 
((double)calc_out[3]);
// free(output);
 
}
 
ifdef __TEST__
 
free(output);
}
#ifdef __TEST__
int
main(int argc, char *argv[])
{
return 0;
}
 
endif}
#endif

Waiting for guidance. . .

Thanks.