├── Containers.cpp
├── calpoints.txt
├── FeatureDetector.h
├── FaceDetector.h
├── GtkStore.h
├── GtkStore.cpp
├── opengazer.cpp
├── GazeTrackerGtk.h
├── utils.cpp
├── EyeExtractor.h
├── GazeArea.h
├── LeastSquares.h
├── TrackingSystem.h
├── HeadTracker.h
├── Point.h
├── HeadCompensation.cpp
├── OutputMethods.h
├── LeastSquares.cpp
├── FeatureDetector.cpp
├── Alert.cpp
├── GraphicalPointer.h
├── PointTracker.h
├── MainGazeTracker.h
├── FMatrixAffineCompute.cpp
├── Makefile
├── FaceDetector.cpp
├── Containers.h
├── GraphicalPointer.cpp
├── GazeTracker.h
├── Point.cpp
├── Calibrator.h
├── EyeExtractor.cpp
├── OutputMethods.cpp
├── GazeTrackerGtk.cpp
├── GaussianProcess.cpp
├── BlinkDetector.h
├── GazeArea.cpp
├── BlinkDetector.cpp
├── Alert.h
├── Calibrator.cpp
├── utils.h
├── README
├── GazeTracker.cpp
├── TrackingSystem.cpp
├── MainGazeTracker.cpp
├── PointTracker.cpp
├── HeadTracker.cpp
└── LICENSE


/Containers.cpp:
--------------------------------------------------------------------------------
1 | #include "Containers.h"
2 | #include <iostream>
3 | 
4 | 


--------------------------------------------------------------------------------
/calpoints.txt:
--------------------------------------------------------------------------------
 1 | 0.5 0.5 
 2 | 0.1 0.5 
 3 | 0.9 0.5
 4 | 0.5 0.1 
 5 | 0.5 0.9 
 6 | 0.1 0.1 
 7 | 0.1 0.9 
 8 | 0.9 0.9 
 9 | 0.9 0.1 
10 | 0.3 0.3 
11 | 0.3 0.7 
12 | 0.7 0.7 
13 | 0.7 0.3
14 | 


--------------------------------------------------------------------------------
/FeatureDetector.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | 
 4 | class FeatureDetector {
 5 |     CvSize eyesize;
 6 |     scoped_ptr<IplImage> sumimage, sum2image, temp;
 7 |     int samples;
 8 | public:
 9 |     FeatureDetector(CvSize eyesize);
10 |     void addSample(const IplImage *source);
11 |     shared_ptr<IplImage> getMean();
12 |     shared_ptr<IplImage> getVariance();
13 | };
14 | 


--------------------------------------------------------------------------------
/FaceDetector.h:
--------------------------------------------------------------------------------
 1 | #include "utils.h"
 2 | #include <opencv/cv.h>
 3 | 
 4 | class FaceDetector {
 5 |     CvMemStorage* storage;
 6 |     CvHaarClassifierCascade* cascade ;
 7 | 
 8 | public:
 9 |     static FaceDetector facedetector;
10 |     FaceDetector(char *cascadename="haarcascade_frontalface_alt.xml");
11 |     ~FaceDetector();
12 |     vector<CvRect> detect(const IplImage *img);
13 | };
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/GtkStore.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <gtkmm.h>
 3 | #include "OutputMethods.h"
 4 | #include "GraphicalPointer.h"
 5 | 
 6 | 
 7 | class WindowStore: public AbstractStore {
 8 |     WindowPointer pointer, target;
 9 |  public:
10 |     WindowStore(const WindowPointer::PointerSpec& pointerspec,
11 | 		const WindowPointer::PointerSpec& targetspec);
12 |     virtual void store(const TrackerOutput &output);
13 | };
14 | 


--------------------------------------------------------------------------------
/GtkStore.cpp:
--------------------------------------------------------------------------------
 1 | #include "GtkStore.h"
 2 | 
 3 | WindowStore::WindowStore(const WindowPointer::PointerSpec& pointerspec,
 4 | 			 const WindowPointer::PointerSpec& targetspec):
 5 |     pointer(pointerspec), target(targetspec)
 6 | {
 7 | }
 8 | 
 9 | void WindowStore::store(const TrackerOutput &output) {
10 |     pointer.setPosition((int) output.gazepoint.x, (int) output.gazepoint.y);
11 |     target.setPosition((int) output.target.x, (int) output.target.y);
12 | }
13 | 


--------------------------------------------------------------------------------
/opengazer.cpp:
--------------------------------------------------------------------------------
 1 | #include <gtkmm.h>
 2 | #include <iostream>
 3 | #include "GazeTrackerGtk.h"
 4 | #include "OutputMethods.h"
 5 | #include "GtkStore.h"
 6 | 
 7 | int main(int argc, char **argv)
 8 | {
 9 |     Gtk::Main kit(argc, argv);
10 |     Glib::thread_init();
11 | 
12 | //     CalibrationWindow calwindow;
13 | //     calwindow.show();
14 | 
15 |     GazeTrackerGtk helloworld(argc, argv);
16 | 
17 |     helloworld.show();
18 | 
19 |     Gtk::Main::run(helloworld);
20 |     
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/GazeTrackerGtk.h:
--------------------------------------------------------------------------------
 1 | #include <gtkmm/button.h>
 2 | #include <gtkmm/window.h>
 3 | #include <gtkmm/drawingarea.h>
 4 | #include <gtkmm/box.h>
 5 | 
 6 | #include "GazeArea.h"
 7 | 
 8 | class GazeTrackerGtk: public Gtk::Window {
 9 |  protected:
10 |   //Member widgets:
11 |     Gtk::Button calibratebutton, loadbutton, savebutton, clearbutton;
12 |     Gtk::VBox vbox;
13 |     Gtk::HBox buttonbar;
14 | 
15 |  public:
16 |     GazeArea picture;
17 |     GazeTrackerGtk(int argc, char **argv);
18 |     virtual ~GazeTrackerGtk();
19 |     
20 | };
21 | 


--------------------------------------------------------------------------------
/utils.cpp:
--------------------------------------------------------------------------------
 1 | #include "utils.h"
 2 | 
 3 | void releaseImage(IplImage *image) {
 4 | //     cout << "deleting shared image" << endl;
 5 |     cvReleaseImage(&image);
 6 | }
 7 | 
 8 | shared_ptr<IplImage> createImage(const CvSize &size, int depth, int channels) {
 9 |     return shared_ptr<IplImage>(cvCreateImage(size, depth, channels),
10 | 				releaseImage);
11 | }
12 | 
13 | namespace boost {
14 |     template<>
15 |     void checked_delete(IplImage *image) {
16 | // 	cout << "deleting scoped image" << endl;
17 | 	if (image)
18 | 	    cvReleaseImage(&image);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/EyeExtractor.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | #include "PointTracker.h"
 4 | 
 5 | class EyeExtractor {
 6 |     const PointTracker &tracker; /* dangerous */
 7 |     scoped_ptr<IplImage> eyefloat2;
 8 | 
 9 |     void processEye(void);
10 | 
11 | public:
12 |     static const int eyedx;
13 |     static const int eyedy;
14 |     static const CvSize eyesize;
15 | 
16 |     scoped_ptr<IplImage> eyegrey, eyefloat, eyeimage;
17 | 
18 |     EyeExtractor(const PointTracker &tracker);
19 |     void extractEye(const IplImage *origimage) throw (TrackingException);
20 |     ~EyeExtractor(void);
21 | };
22 | 
23 | 


--------------------------------------------------------------------------------
/GazeArea.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <gtkmm/drawingarea.h>
 3 | #include "MainGazeTracker.h"
 4 | 
 5 | class GazeArea: public Gtk::DrawingArea {
 6 |     friend class GazeTrackerGtk;
 7 |     int lastPointId;
 8 |     int clickCount;
 9 |  public:
10 |     MainGazeTracker gazetracker;
11 | 
12 |     GazeArea(int argc, char **argv,
13 | 	     const vector<shared_ptr<AbstractStore> > &stores);
14 |     virtual ~GazeArea();
15 | 
16 |  protected:
17 |     virtual bool on_expose_event(GdkEventExpose *event);
18 |     virtual bool on_button_press_event(GdkEventButton *event);
19 |     virtual bool on_button_release_event(GdkEventButton *event);
20 |     bool on_idle();
21 | };
22 | 


--------------------------------------------------------------------------------
/LeastSquares.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <vnl/vnl_vector.h>
 3 | #include <vnl/vnl_matrix.h>
 4 | 
 5 | typedef vnl_vector<double> Vector;
 6 | typedef vnl_matrix<double> Matrix;
 7 | 
 8 | class LeastSquares {
 9 |     Matrix X;
10 |     Vector Y;
11 | public:
12 |     const int n;
13 | 
14 |     LeastSquares(int n): X(n,n), Y(n), n(n) {}
15 | 
16 |     void addSample(double xs[], double y);
17 |     void addSample(double x1, double x2, double y);
18 |     void addSample(double x1, double x2, double x3, double y);
19 | 
20 |     Vector solve(void);
21 |     void solve(double &a0, double &a1);
22 |     void solve(double &a0, double &a1, double &a2);
23 | };
24 | 
25 |  
26 | 


--------------------------------------------------------------------------------
/TrackingSystem.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | #include "PointTracker.h"
 4 | #include "HeadTracker.h"
 5 | #include "HeadCompensation.cpp"
 6 | #include "EyeExtractor.h"
 7 | #include "OutputMethods.h"
 8 | #include "GazeTracker.h"
 9 | 
10 | struct TrackingSystem {
11 |     PointTracker tracker;
12 |     HeadTracker headtracker;
13 |     HeadCompensation headcomp;
14 |     EyeExtractor eyex;
15 |     GazeTracker gazetracker;
16 | 
17 |     TrackingSystem(CvSize size);
18 |     void doprocessing(const IplImage *frame, 
19 | 		      IplImage *image);
20 |     void displayeye(IplImage *image, int basex, int basey, 
21 | 		    int stepx, int stepy);
22 | 
23 | };
24 | 


--------------------------------------------------------------------------------
/HeadTracker.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <vgl/vgl_homg_point_2d.h>
 3 | #include <opencv/cv.h>
 4 | #include <vector>
 5 | #include "PointTracker.h"
 6 | 
 7 | using namespace std;
 8 | 
 9 | class HeadTracker {
10 |     vector<double> depths;
11 | 
12 |     vector<bool> detectinliers(vector<HomPoint> const &prev, 
13 | 			       vector<HomPoint> const &now,
14 | 			       double radius = 30.0);
15 | 
16 |     void predictpoints(double xx0, double yy0, double xx1, double yy1,
17 | 		       double rotx, double roty, double atx, double aty);
18 | 
19 |  public:
20 |     PointTracker &tracker;
21 | 
22 |     double rotx, roty, atx, aty;
23 | 
24 |     void draw(IplImage *image);
25 |     void updatetracker(void);
26 | 
27 |     HeadTracker(PointTracker &tracker) : tracker(tracker) {}
28 | };
29 | 


--------------------------------------------------------------------------------
/Point.h:
--------------------------------------------------------------------------------
 1 | struct Point {
 2 |     double x, y;
 3 | 
 4 |     Point(): x(0.0), y(0.0) {}
 5 |     Point(double x, double y): x(x), y(y) {}
 6 |     Point(CvPoint2D32f const& point): x(point.x), y(point.y) {}
 7 |     Point(CvPoint const& point): x(point.x), y(point.y) {}
 8 | 
 9 |     void operator=(CvPoint2D32f const& point);
10 |     void operator=(CvPoint const& point);
11 | 
12 |     double distance(Point other) const;
13 |     Point operator+(const Point &other) const;
14 |     Point operator-(const Point &other) const;
15 | 
16 |     void save(CvFileStorage *out, const char* name) const;
17 |     void load(CvFileStorage *in, CvFileNode *node);
18 | 
19 |     CvPoint cvpoint(void) const;
20 |     CvPoint2D32f cvpoint32(void) const;
21 | 
22 |     int closestPoint(const vector<Point> &points) const;
23 | };
24 | 
25 | ostream& operator<< (ostream& out, const Point& p);
26 | istream& operator>> (istream& in, Point& p);
27 | void convert(const Point& point, CvPoint2D32f& p);
28 | 
29 | 


--------------------------------------------------------------------------------
/HeadCompensation.cpp:
--------------------------------------------------------------------------------
 1 | #include "LeastSquares.h"
 2 | 
 3 | class HeadCompensation {
 4 |     LeastSquares xparams, yparams;
 5 |     const HeadTracker &head;
 6 | 
 7 |     double xa0, xa1, xa2, ya0, ya1, ya2;
 8 |     int samples;
 9 | public:
10 | 
11 |     HeadCompensation(HeadTracker const& head): 
12 | 	xparams(3), yparams(3), head(head), 
13 | 	xa0(0.0), xa1(0.0), xa2(0.0),
14 | 	ya0(0.0), ya1(0.0), ya2(0.0), samples(0)
15 |     {}
16 | 
17 |     void addCorrection(Point correction) {
18 | 	xparams.addSample(head.rotx, head.roty, 1.0, correction.x);
19 | 	yparams.addSample(head.rotx, head.roty, 1.0, correction.y);
20 | 	samples++;
21 |     }
22 | 
23 |     void updateFactors(void) {
24 | 	if (samples > 0) {
25 | 	    xparams.solve(xa0, xa1, xa2);
26 | 	    yparams.solve(ya0, ya1, ya2);
27 | 	}
28 |     }
29 | 
30 |     Point estimateCorrection(void) {
31 | 	return Point(xa0 * head.rotx + xa1 * head.roty + xa2, 
32 | 		     ya0 * head.rotx + ya1 * head.roty + ya2);
33 |     }
34 | };
35 | 


--------------------------------------------------------------------------------
/OutputMethods.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | #include "GazeTracker.h"
 4 | #include <netinet/in.h>
 5 | 
 6 | class AbstractStore {
 7 | public:
 8 |     virtual void store(const TrackerOutput& output) = 0;
 9 |     virtual ~AbstractStore();
10 | };
11 | 
12 | class MmapStore: public AbstractStore {
13 |     int fd;
14 |     int *positiontable;
15 | public:
16 |     MmapStore(const char *filename="/tmp/gaze-mouse");
17 |     virtual void store(const TrackerOutput& output);
18 |     virtual ~MmapStore();
19 | };
20 |  
21 | class StreamStore: public AbstractStore {
22 |     ostream &stream;
23 | public:
24 |     StreamStore(ostream &stream);
25 |     virtual void store(const TrackerOutput& output);
26 |     virtual ~StreamStore();
27 | };
28 | 
29 | class SocketStore: public AbstractStore {
30 |     int mysocket;
31 |     struct sockaddr_in destaddr;
32 | public:
33 |     SocketStore(int port=20320);
34 |     virtual void store(const TrackerOutput& output);
35 |     virtual ~SocketStore();
36 | };
37 | 


--------------------------------------------------------------------------------
/LeastSquares.cpp:
--------------------------------------------------------------------------------
 1 | #include "LeastSquares.h"
 2 | #include <vnl/algo/vnl_cholesky.h>
 3 | #include <assert.h>
 4 | 
 5 | void LeastSquares::addSample(double xs[], double y) {
 6 |     for(int i=0; i<n; i++)
 7 | 	for(int j=0; j<n; j++)
 8 | 	    X[i][j] += xs[i]*xs[j];
 9 | 
10 |     for(int i=0; i<n; i++)
11 | 	Y[i] += xs[i]*y;
12 | }
13 | 
14 | void LeastSquares::addSample(double x1, double x2, double y) {
15 |     assert(n == 2);
16 |     double xs[2] = {x1, x2};
17 |     addSample(xs, y);
18 | }
19 | 
20 | void LeastSquares::addSample(double x1, double x2, double x3, double y) {
21 |     assert(n == 3);
22 |     double xs[3] = {x1, x2, x3};
23 |     addSample(xs, y);
24 | }
25 | 
26 | Vector LeastSquares::solve(void) {
27 |     return vnl_cholesky(X).solve(Y);
28 | }
29 | 
30 | void LeastSquares::solve(double &a0, double &a1) {
31 |     assert(n == 2);
32 |     Vector vec = solve();
33 |     a0 = vec[0];
34 |     a1 = vec[1];
35 | }
36 | 
37 | void LeastSquares::solve(double &a0, double &a1, double &a2) {
38 |     assert(n == 3);
39 |     Vector vec = solve();
40 |     a0 = vec[0];
41 |     a1 = vec[1];
42 |     a2 = vec[2];
43 | }
44 | 
45 | 
46 |  
47 | 


--------------------------------------------------------------------------------
/FeatureDetector.cpp:
--------------------------------------------------------------------------------
 1 | #include "FeatureDetector.h"
 2 | 
 3 | FeatureDetector::FeatureDetector(CvSize eyesize):
 4 |     eyesize(eyesize),
 5 |     sumimage(cvCreateImage(eyesize, IPL_DEPTH_32F, 1)),
 6 |     sum2image(cvCreateImage(eyesize, IPL_DEPTH_32F, 1)),
 7 |     temp(cvCreateImage(eyesize, IPL_DEPTH_32F, 1)),
 8 |     samples(0)
 9 | {
10 |     cvZero(sum2image.get());
11 |     cvZero(sumimage.get());
12 | }
13 | 
14 | void FeatureDetector::addSample(const IplImage *source) {
15 |     cvConvertScale(source, temp.get());
16 |     cvAcc(temp.get(), sumimage.get());
17 |     cvSquareAcc(temp.get(), sum2image.get());
18 |     samples++;
19 | }
20 | 
21 | shared_ptr<IplImage> FeatureDetector::getMean() {
22 |     shared_ptr<IplImage> mean(createImage(eyesize, IPL_DEPTH_32F, 1));
23 |     cvConvertScale(sumimage.get(), mean.get(), 1.0 / samples);
24 |     return mean;
25 | }
26 | 
27 | shared_ptr<IplImage> FeatureDetector::getVariance() {
28 |     shared_ptr<IplImage> variance(createImage(eyesize, IPL_DEPTH_32F, 1));
29 |     cvMul(sumimage.get(), sumimage.get(), temp.get(), -1.0/samples);
30 |     cvAdd(temp.get(), sum2image.get(), temp.get());
31 |     cvScale(temp.get(), variance.get(), 1.0/samples);
32 |     return variance;
33 | }
34 | 


--------------------------------------------------------------------------------
/Alert.cpp:
--------------------------------------------------------------------------------
 1 | #include "Alert.h"
 2 | 
 3 | AlertWindow::AlertWindow(const string& text): text(text) {
 4 |     window.set_title(text);
 5 |     window.show();
 6 | }
 7 | 
 8 | AlertWindow::~AlertWindow() {}
 9 | 
10 | NodeResult<void> AlertWindow::handleEvent(StateEventType event) {
11 |     StateNode<void>::handleEvent(event);
12 |     if (ticks >= 50)
13 | 	return NodeResult<void>(shared_ptr<AlertWindow>
14 | 			  (new AlertWindow(text + " x")));
15 |     else
16 | 	return NodeResult<void>();
17 | }
18 | 
19 | 
20 | // MessageNode::MessageNode(const shared_ptr<StateNode>& oknode,
21 | // 			 const shared_ptr<StateNode>& cancelnode,
22 | // 			 const string& text):
23 | //     oknode(oknode), cancelnode(cancelnode), text(text)
24 | // {
25 | // }
26 | 
27 | // shared_ptr<StateNode> MessageNode::handleEvent(StateEventType event) {
28 | //     switch (event) {
29 | //     case EVENT_2BLINK: return oknode;
30 | //     case EVENT_TIMEOUT: return cancelnode;
31 | //     case EVENT_DESELECTED: 
32 | // 	alert = 0;
33 | // 	return StateNode::handleEvent(event);
34 | //     case EVENT_SELECTED: 
35 | // 	alert = scoped_ptr<AlertWindow>(new AlertWindow(text));
36 | // 	return StateNode::handleEvent(event);
37 | //     default: return StateNode::handleEvent(event);
38 | //     }
39 | // }
40 | 
41 | 
42 | 


--------------------------------------------------------------------------------
/GraphicalPointer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <gtkmm.h>
 3 | #include "Containers.h"
 4 | 
 5 | /* represents the pointer as a small window and moves that window */
 6 | class WindowPointer {
 7 |  public:
 8 |     struct PointerSpec {
 9 | 	int width, height;
10 | 	double red, green, blue;
11 | 	PointerSpec(int width, int height, 
12 | 		    double red, double green, double blue);
13 |     };
14 |  private:
15 |     class GtkPointerDrawingArea: public Gtk::DrawingArea {
16 | 	PointerSpec spec;
17 |     public:
18 |         GtkPointerDrawingArea(const PointerSpec &pointerspec);
19 |         virtual bool on_expose_event(GdkEventExpose *event);
20 |     };
21 |     class GtkPointerWindow: public Gtk::Window {
22 |         GtkPointerDrawingArea area;
23 |     public:
24 |         GtkPointerWindow(const PointerSpec &pointerspec);
25 |     };  
26 |     GtkPointerWindow pointerwindow;
27 |  public:
28 |     WindowPointer(const PointerSpec &pointerspec);
29 |     void setPosition(int x, int y);
30 | };
31 | 
32 | /* class PointerMark: public Gtk::DrawingArea { */
33 | /*     virtual bool on_expose_event(GdkEventExpose *event); */
34 | /* }; */
35 | 
36 | /* class CalibrationMark: public Gtk::DrawingArea { */
37 | /*     virtual bool on_expose_event(GdkEventExpose *event); */
38 | /* }; */
39 | 
40 | 


--------------------------------------------------------------------------------
/PointTracker.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <opencv/cv.h>
 4 | #include <vector>
 5 | #include <vgl/vgl_homg_point_2d.h>
 6 | #include "utils.h"
 7 | 
 8 | using namespace std;
 9 | typedef vgl_vector_2d<double> HomPoint;
10 | 
11 | class TrackingException: public exception {};
12 | 
13 | class PointTracker {
14 | public:
15 |     static const int eyepoint1 = 0;
16 |     static const int eyepoint2 = 1;
17 |     vector<char> status;
18 |     vector<CvPoint2D32f> origpoints, currentpoints, lastpoints;
19 | 
20 |  private:
21 |     static const int win_size = 11;
22 |     int flags;
23 | 
24 |     scoped_ptr<IplImage> grey, orig_grey, pyramid, orig_pyramid,
25 | 	last_grey, last_pyramid;
26 | 
27 |     void synchronizepoints();
28 | 
29 | public:
30 |     PointTracker(const CvSize &size);
31 |     void cleartrackers();
32 |     void addtracker(const Point &point);
33 |     void updatetracker(int id, const Point &point);
34 |     void removetracker(int id);
35 |     int getClosestTracker(const Point &point);
36 |     void track(const IplImage *frame, int pyramiddepth=1);
37 |     int countactivepoints(void);
38 |     bool areallpointsactive(void);
39 |     int pointcount();
40 |     void draw(IplImage *canvas);
41 | 
42 |     vector<HomPoint> 
43 | 	getpoints(const vector<CvPoint2D32f> PointTracker::*points, 
44 | 		  bool allpoints=true);
45 | 
46 |     void save(string filename, string newname, const IplImage *frame);
47 |     void load(string filename, string newname, const IplImage *frame);
48 | };
49 | 


--------------------------------------------------------------------------------
/MainGazeTracker.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | #include "TrackingSystem.h"
 4 | //#include "Alert.h"
 5 | #include "Calibrator.h"
 6 | #include <opencv/highgui.h>
 7 | #include <gtkmm.h>
 8 | 
 9 | struct CommandLineArguments {
10 |     vector<char*> parameters;
11 |     vector<char*> options;
12 |      
13 |     CommandLineArguments(int argc, char **argv);
14 |     bool isoption(const char* option);
15 | };
16 | 
17 | 
18 | 
19 | class VideoInput {
20 |     CvCapture* capture;
21 | 
22 |  public:
23 |     int framecount;
24 |     const IplImage* frame;
25 |     const CvSize size;
26 |     VideoInput();
27 |     VideoInput(const char* avifile);
28 |     ~VideoInput();
29 |     void updateFrame();
30 | };
31 | 
32 | class VideoWriter;
33 | /* class FileInput; */
34 | 
35 | class MainGazeTracker {
36 |     scoped_ptr<VideoWriter> video;
37 |     int framestoreload;
38 |     vector<shared_ptr<AbstractStore> > stores;
39 |     int framecount;
40 |     bool autoreload;
41 | //    StateMachine<void> statemachine;
42 | 
43 |  public:
44 |     shared_ptr<TrackingSystem> tracking;
45 | 
46 |     FrameProcessing framefunctions;
47 |     scoped_ptr<IplImage> canvas;
48 |     scoped_ptr<VideoInput> videoinput;
49 | 
50 |     MainGazeTracker(int argc, char** argv,
51 | 		    const vector<shared_ptr<AbstractStore> > &stores);
52 |     void doprocessing(void);
53 |     ~MainGazeTracker(void);
54 |     void addTracker(Point point);
55 |     void addExemplar(Point exemplar);
56 |     void startCalibration();
57 |     void startTesting();
58 |     void savepoints();
59 |     void loadpoints();
60 |     void clearpoints();
61 | };
62 | 


--------------------------------------------------------------------------------
/FMatrixAffineCompute.cpp:
--------------------------------------------------------------------------------
 1 | #include <vnl/algo/vnl_svd.h>
 2 | 
 3 | template <class T>
 4 | 
 5 | T sum(vector<T> const& vector) {
 6 |     T sum = vector[0];
 7 | 
 8 |     for(int i=1; i<vector.size(); i++)
 9 | 	sum += vector[i];
10 | 
11 |     return sum;
12 | }
13 | 
14 | Vector computeAffineFMatrix(vector<HomPoint> const& points1,
15 | 			    vector<HomPoint> const& points2)
16 | {
17 |     assert(points1.size() == points2.size());
18 | 
19 |     int n = points1.size();
20 | 
21 |     Vector centroid(4, 0.0);
22 |     
23 |     for(int i=0; i<n; i++) {
24 | 	centroid[0] += points1[i].x();
25 | 	centroid[1] += points1[i].y();
26 | 	centroid[2] += points2[i].x();
27 | 	centroid[3] += points2[i].y();
28 |     }
29 | 
30 |     centroid /= n;
31 | 
32 |     Matrix matrix(n, 4);
33 | 
34 |     for(int i=0; i<n; i++) {
35 | 	matrix(i, 0) = points1[i].x() - centroid[0];
36 | 	matrix(i, 1) = points1[i].y() - centroid[1];
37 | 	matrix(i, 2) = points2[i].x() - centroid[2];
38 | 	matrix(i, 3) = points2[i].y() - centroid[3];
39 |     }
40 | 
41 | //     cout << "fmatrixcompute: " << endl << matrix << endl << endl;
42 | 
43 |     vnl_svd<double> svd(matrix);
44 | 
45 | //     cout << "U = " << endl << svd.U() << endl << endl;
46 | //     cout << "W = " << endl << svd.W() << endl << endl;
47 | //     cout << "V = " << endl << svd.V() << endl << endl;
48 | 
49 |     Vector v = svd.V().get_column(3);
50 | 
51 |     Vector result(5);
52 | 
53 |     result.update(v);		// a,b,c,d
54 |     result[4] = inner_product(v, centroid);
55 | 
56 |     if (result[4] < 0) 
57 | 	result = -result;
58 |     
59 | 
60 | 
61 | //     cout << "mat: " << v << endl;
62 | //     cout << "test: " << matrix * v << endl;
63 | 
64 |     return result.normalize();
65 | }
66 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # required libraries: vxl, opencv, boost, gtkmm
 2 | 
 3 | VXLDIR = /opt
 4 | VERSION = opengazer-0.1.2
 5 | CPPFLAGS = -Wall -g -O3
 6 | LINKER = -L$(VXLDIR)/lib -L/usr/local/lib -lm -ldl -lvnl -lmvl -lvnl_algo -lvgl -lgthread-2.0 
 7 | 
 8 | # change the following line if your vxl library is installed elsewhere
 9 | INCLUDES = $(foreach prefix,/usr/local/include $(VXLDIR)/include $(VXLDIR)/include/vxl, \
10 | 	$(foreach suffix,/core /vcl /contrib/oxl,-I$(prefix)$(suffix)))
11 | 
12 | # -I/usr/include/ffmpeg
13 | # -lcv0.9.7 -lhighgui0.9.7
14 | # -lvgui
15 | 
16 | sources = opengazer.cpp Calibrator.cpp GazeTrackerGtk.cpp HeadTracker.cpp LeastSquares.cpp EyeExtractor.cpp GazeTracker.cpp MainGazeTracker.cpp OutputMethods.cpp PointTracker.cpp FaceDetector.cpp GazeArea.cpp TrackingSystem.cpp GtkStore.cpp Containers.cpp GraphicalPointer.cpp Point.cpp utils.cpp BlinkDetector.cpp FeatureDetector.cpp Alert.cpp 
17 | 
18 | objects = $(patsubst %.cpp,%.o,$(sources))
19 | 
20 | %.o.depends: %.cpp
21 | 	g++ -MM $< > $@
22 | 
23 | %.o: %.cpp 
24 | 	g++ -c $(CPPFLAGS) -o $@ `pkg-config cairomm-1.0 opencv gtkmm-2.4 --cflags` $(INCLUDES) $< 
25 | 
26 | opengazer: 	$(objects)
27 | 	g++ $(CPPFLAGS) -o $@ `pkg-config cairomm-1.0 opencv gtkmm-2.4 --libs`  $(LINKER) $^
28 | 
29 | include $(patsubst %.cpp,%.o.depends,$(sources))
30 | 
31 | TAGS: always
32 | 	etags *.cpp *.h
33 | 
34 | ship: always
35 | 	mkdir $(VERSION) || rm -fr $(VERSION)/*
36 | 	cp LICENSE README Makefile calpoints.txt haarcascade_frontalface_alt.xml $$(for file in $$(cat $(addsuffix .depends,$(objects))) ; do test -f $$file && echo $$file ; done | sort -u) $(VERSION)/
37 | 	tar czf $(VERSION).tar.gz $(VERSION)
38 | 	cp $(VERSION).tar.gz README /home/ftp/pub/www/opengazer/
39 | 
40 | .PHONY: always ship


--------------------------------------------------------------------------------
/FaceDetector.cpp:
--------------------------------------------------------------------------------
 1 | #include "FaceDetector.h"
 2 | 
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | #include <string.h>
 6 | #include <assert.h>
 7 | #include <math.h>
 8 | #include <float.h>
 9 | #include <limits.h>
10 | #include <time.h>
11 | #include <ctype.h>
12 | 
13 | FaceDetector FaceDetector::facedetector;
14 | 
15 | FaceDetector::FaceDetector(char *cascadename):
16 |     cascade((CvHaarClassifierCascade*)cvLoad(cascadename, 0, 0, 0)),
17 |     storage(cvCreateMemStorage(0))
18 | {}
19 | 
20 | 
21 | FaceDetector::~FaceDetector() {
22 |     cvReleaseMemStorage(&storage);
23 |     // fixme: release the cascade somehow
24 | }
25 | 
26 | vector<CvRect> FaceDetector::detect(const IplImage *img) {
27 |     double scale = 1.3;
28 |     IplImage* gray = cvCreateImage( cvSize(img->width,img->height), 8, 1 );
29 |     IplImage* small_img = 
30 | 	cvCreateImage( cvSize( cvRound (img->width/scale),
31 | 			       cvRound (img->height/scale)), 8, 1 );
32 |     int i;
33 | 
34 |     cvCvtColor( img, gray, CV_BGR2GRAY );
35 |     cvResize( gray, small_img, CV_INTER_LINEAR );
36 |     cvEqualizeHist( small_img, small_img );
37 |     cvClearMemStorage( storage );
38 | 
39 |     CvSeq* faces = 
40 | 	cvHaarDetectObjects( small_img, cascade, storage,
41 | 			     1.1, 2, 0/*CV_HAAR_DO_CANNY_PRUNING*/,
42 | 			     cvSize(30, 30) );
43 | 
44 |     vector<CvRect> result;
45 |     for( i = 0; i < (faces ? faces->total : 0); i++ ) {
46 | 	CvRect *rect = (CvRect*)cvGetSeqElem( faces, i );
47 | 	result.push_back(cvRect((int)(rect->x * scale),
48 | 				(int)(rect->y * scale),
49 | 				(int)(rect->width * scale),
50 | 				(int)(rect->height * scale)));
51 |     }
52 | 
53 |     cvReleaseImage(&gray);
54 |     cvReleaseImage(&small_img);
55 | //     cvReleaseSeq(&faces);
56 | 
57 |     return result;
58 | }
59 | 
60 | 


--------------------------------------------------------------------------------
/Containers.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | #include <glibmm.h>
 4 | #include <vector>
 5 | 
 6 | #define xforeachactive(iter,container) \
 7 |     for(typeof(container.begin()) iter = container.begin();	\
 8 | 	iter != container.end(); iter++)			\
 9 | 	if ((*iter)->parent == this)
10 | 
11 | template <class ParentType, class ChildType> class Container;
12 | 
13 | template <class ParentType, class ChildType> 
14 | class  Containee {
15 |  protected:
16 |     void detach() { parent = 0; }
17 |  public:
18 |     ParentType *parent;		/* set to null to request removal */
19 |     Containee(): parent(0) {}
20 |     virtual ~Containee() {}
21 | };
22 | 
23 | template <class ParentType, class ChildType>		
24 | class Container {
25 |     typedef shared_ptr<ChildType> ChildPtr;
26 |     static bool isFinished(const ChildPtr &object) { 
27 | 	return !(object && object->parent);
28 |     }
29 |  protected:
30 |     std::vector<ChildPtr> objects;
31 | 
32 |     void removeFinished() { 
33 | 	objects.erase(remove_if(objects.begin(), objects.end(), isFinished),
34 | 		      objects.end());
35 |     }
36 | 
37 |  public:
38 |     void clear() {
39 | 	xforeachactive(iter, objects)
40 | 	    (*iter)->parent = 0;
41 | 	removeFinished();
42 |     }
43 | 	    
44 | 
45 |     static void addchild(ParentType *parent, const ChildPtr &child) {
46 | 	parent->objects.push_back(child);
47 | 	child->parent = parent;
48 |  	parent->removeFinished(); 
49 |     }
50 | 
51 |     virtual ~Container() {
52 | 	clear();
53 |     }
54 | };
55 | 
56 | template <class ParentPtr, class ChildPtr>
57 | class ProcessContainer: public Container<ParentPtr, ChildPtr> {
58 |  public:
59 |     virtual void process() {
60 | 	xforeachactive(iter, this->objects)
61 | 	    (*iter)->process();
62 |  	this->removeFinished(); 
63 |     }
64 |     virtual ~ProcessContainer() {};
65 | };
66 | 
67 | 


--------------------------------------------------------------------------------
/GraphicalPointer.cpp:
--------------------------------------------------------------------------------
 1 | #include "GraphicalPointer.h"
 2 | #include <cairomm/context.h>
 3 | 
 4 | WindowPointer::PointerSpec::PointerSpec(int width, int height, 
 5 | 					double red, double green, double blue):
 6 |     width(width), height(height), red(red), green(green), blue(blue) 
 7 | {
 8 | }
 9 | 
10 | WindowPointer::GtkPointerDrawingArea::
11 | GtkPointerDrawingArea(const PointerSpec &pointerspec):
12 |     spec(pointerspec)
13 | {
14 |     set_size_request(spec.width, spec.height);
15 | }
16 | 
17 | bool WindowPointer::GtkPointerDrawingArea::
18 | on_expose_event(GdkEventExpose *event) 
19 | {
20 |     Glib::RefPtr<Gdk::Window> window = get_window();
21 |     if (window) {
22 | 	Cairo::RefPtr<Cairo::Context> cr(new Cairo::Context(gdk_cairo_create(window->gobj()), true));
23 | 	if (event) {
24 | 	    cr->rectangle(event->area.x, event->area.y,
25 | 			  event->area.width, event->area.height);
26 | 	    cr->clip();
27 | 	}
28 | 	cr->set_source_rgb(1.0, 1.0, 1.0);
29 | 	cr->paint();
30 | 	cr->set_source_rgb(spec.red, spec.green, spec.blue);
31 | 	cr->arc(get_width()/2, get_height()/2, get_width()/3, 0, 2*M_PI);
32 | 	cr->fill();
33 | // 	Glib::RefPtr<Gdk::GC> gc = Gdk::GC::create(window);
34 | // 	color.set_blue(100);
35 | // 	gc->set_foreground(color);
36 | // 	window->draw_arc(gc, true, 0, 0, get_width(), get_height(), 0, 360*64);
37 |     }
38 |     return false;
39 | }
40 | 
41 | WindowPointer::GtkPointerWindow::
42 | GtkPointerWindow(const PointerSpec &pointerspec):
43 |     area(pointerspec)
44 | {
45 |     add(area);
46 |     area.show();
47 |     set_decorated(false);
48 |     set_keep_above(true);
49 | }
50 | 
51 | WindowPointer::WindowPointer(const PointerSpec &pointerspec):
52 |     pointerwindow(pointerspec) 
53 | {
54 |     pointerwindow.show();
55 | }
56 | 
57 | void WindowPointer::setPosition(int x, int y) {
58 |     pointerwindow.move(x, y);
59 | }
60 | 


--------------------------------------------------------------------------------
/GazeTracker.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | #include "GaussianProcess.cpp"
 4 | 
 5 | typedef MeanAdjustedGaussianProcess<SharedImage> ImProcess;
 6 | 
 7 | struct Targets {
 8 |     vector<Point> targets;
 9 | 
10 |     Targets(void) {};
11 |     Targets(vector<Point> const& targets): targets(targets) {}
12 |     int getCurrentTarget(Point point);
13 | };
14 | 
15 | struct CalTarget {
16 |     Point point;
17 |     SharedImage image, origimage;
18 | 
19 |     CalTarget();
20 |     CalTarget(Point point, const IplImage* image, const IplImage* origimage);
21 | 
22 |     void save(CvFileStorage* out, const char* name=NULL);
23 |     void load(CvFileStorage* in, CvFileNode *node);
24 | };
25 | 
26 | struct TrackerOutput {
27 |     Point gazepoint;
28 |     Point target;
29 |     int targetid;
30 | 
31 |     TrackerOutput(Point gazepoint, Point target, int targetid);
32 | };
33 | 
34 | class GazeTracker {
35 |     scoped_ptr<ImProcess> gpx, gpy;
36 |     vector<CalTarget> caltargets;
37 |     scoped_ptr<Targets> targets;
38 |     
39 |     static double imagedistance(const IplImage *im1, const IplImage *im2);
40 |     static double covariancefunction(const SharedImage& im1, 
41 | 				     const SharedImage& im2);
42 | 
43 |     void updateGPs(void);
44 | 
45 | public:
46 |     TrackerOutput output;
47 | 
48 |     GazeTracker(): targets(new Targets), 
49 | 	output(Point(0,0), Point(0,0), -1) {}
50 | 
51 |     bool isActive() { return gpx.get() && gpy.get(); }
52 | 
53 |     void clear();
54 |     void addExemplar(Point point, 
55 | 		     const IplImage *eyefloat, const IplImage *eyegrey);
56 |     void draw(IplImage *canvas, int eyedx, int eyedy);
57 |     void save(void);
58 |     void save(CvFileStorage *out, const char *name);
59 |     void load(void);
60 |     void load(CvFileStorage *in, CvFileNode *node);
61 |     void update(const IplImage *image);
62 |     int getTargetId(Point point);
63 |     Point getTarget(int id);
64 | };
65 | 


--------------------------------------------------------------------------------
/Point.cpp:
--------------------------------------------------------------------------------
 1 | #include "utils.h"
 2 | 
 3 | void convert(const Point& point, CvPoint2D32f& p) {
 4 |     p.x = point.x;
 5 |     p.y = point.y;
 6 | }
 7 | 
 8 | ostream& operator<< (ostream& out, const Point& p) {
 9 |     out << p.x << " " << p.y << endl;
10 |     return out;
11 | }
12 | 
13 | istream& operator>> (istream& in, Point& p) {
14 |     in >> p.x >> p.y;
15 |     return in;
16 | }
17 | 
18 | void Point::operator=(CvPoint2D32f const& point) {
19 |     x = point.x; 
20 |     y = point.y;
21 | }
22 | 
23 | void Point::operator=(CvPoint const& point) {
24 |     x = point.x; 
25 |     y = point.y;
26 | }
27 | 
28 | 
29 | double Point::distance(Point other) const {
30 |     return fabs(other.x - x) + fabs(other.y - y);
31 | }
32 | 
33 | Point Point::operator+(const Point &other) const {
34 |     return Point(x + other.x, y + other.y);
35 | }
36 |     
37 | Point Point::operator-(const Point &other) const {
38 |     return Point(x - other.x, y - other.y);
39 | }
40 |     
41 | void Point::save(CvFileStorage *out, const char* name) const {
42 |     cvStartWriteStruct(out, name, CV_NODE_MAP);
43 |     cvWriteReal(out, "x", x);
44 |     cvWriteReal(out, "y", y);
45 |     cvEndWriteStruct(out);
46 | }
47 | 
48 | void Point::load(CvFileStorage *in, CvFileNode *node) {
49 |     x = cvReadRealByName(in, node, "x");
50 |     y = cvReadRealByName(in, node, "y");
51 | }
52 | 
53 | CvPoint Point::cvpoint(void) const {
54 |     return cvPoint(cvRound(x), cvRound(y));
55 | }
56 | 
57 | CvPoint2D32f Point::cvpoint32(void) const {
58 |     return cvPoint2D32f(x, y);
59 | }
60 | 
61 | int Point::closestPoint(const vector<Point> &points) const {
62 |     if (points.empty())
63 | 	return -1;
64 | 
65 |     vector<double> distances(points.size());
66 |     transform(points.begin(), points.end(), distances.begin(), 
67 | 	      sigc::mem_fun(*this, &Point::distance));
68 |     return min_element(distances.begin(), distances.end()) - distances.begin();
69 | }
70 | 


--------------------------------------------------------------------------------
/Calibrator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <glibmm.h>
 3 | #include <gdkmm.h>
 4 | #include "utils.h"
 5 | #include "TrackingSystem.h"
 6 | #include "Containers.h"
 7 | #include "GraphicalPointer.h"
 8 | #include "FeatureDetector.h"
 9 | 
10 | class FrameProcessing;
11 | 
12 | class FrameFunction: 
13 | public Containee<FrameProcessing, FrameFunction> 
14 | {
15 |     const int &frameno;
16 |     int startframe;
17 |  protected:
18 |     int getFrame() { return frameno - startframe; }
19 | public:
20 |     FrameFunction(const int &frameno): frameno(frameno), startframe(frameno) {}
21 |     virtual void process()=0;
22 |     virtual ~FrameFunction();
23 | };
24 | 
25 | class FrameProcessing: 
26 | public ProcessContainer<FrameProcessing,FrameFunction> {};
27 | 
28 | class MovingTarget: public FrameFunction {
29 |     shared_ptr<WindowPointer> pointer;
30 |  public:
31 |     MovingTarget(const int &frameno, 
32 | 		 const vector<Point>& points, 
33 | 		 const shared_ptr<WindowPointer> &pointer,
34 | 		 int dwelltime=20);
35 |     virtual ~MovingTarget();
36 |     virtual void process();
37 |  protected:
38 |     vector<Point> points;
39 |     const int dwelltime;
40 |     int getPointNo();
41 |     int getPointFrame();
42 |     bool active();
43 | };
44 | 
45 | class Calibrator: public MovingTarget {
46 |     static const Point defaultpointarr[];
47 |     shared_ptr<TrackingSystem> trackingsystem;
48 |     scoped_ptr<FeatureDetector> averageeye;
49 | public:
50 |     static vector<Point> defaultpoints;
51 |     static vector<Point> loadpoints(istream& in);
52 |     Calibrator(const int &frameno, 
53 | 	       const shared_ptr<TrackingSystem> &trackingsystem, 
54 | 	       const vector<Point>& points, 
55 | 	       const shared_ptr<WindowPointer> &pointer,
56 | 	       int dwelltime=20);
57 |     virtual ~Calibrator();
58 |     virtual void process();
59 |     static vector<Point> scaled(const vector<Point>& points, double x, double y);
60 | };
61 | 
62 | 
63 | 


--------------------------------------------------------------------------------
/EyeExtractor.cpp:
--------------------------------------------------------------------------------
 1 | #include "utils.h"
 2 | #include "EyeExtractor.h"
 3 | 
 4 | const int EyeExtractor::eyedx = 32;
 5 | const int EyeExtractor::eyedy = 16;
 6 | const CvSize EyeExtractor::eyesize = cvSize(eyedx*2, eyedy*2);
 7 | 
 8 | void EyeExtractor::processEye(void) {
 9 |     cvConvertScale(eyegrey.get(), eyefloat2.get());
10 |     // todo: equalize it somehow first!
11 |     cvSmooth(eyefloat2.get(), eyefloat.get(), CV_GAUSSIAN, 3);
12 |     cvEqualizeHist(eyegrey.get(), eyegrey.get());
13 | }
14 | 
15 | 
16 | EyeExtractor::EyeExtractor(const PointTracker &tracker):
17 |     tracker(tracker), 
18 |     eyefloat2(cvCreateImage( eyesize, IPL_DEPTH_32F, 1 )),
19 |     eyegrey(cvCreateImage( eyesize, 8, 1 )),
20 |     eyefloat(cvCreateImage( eyesize, IPL_DEPTH_32F, 1 )),
21 |     eyeimage(cvCreateImage( eyesize, 8, 3 ))
22 | {
23 | }
24 | 
25 | void EyeExtractor::extractEye(const IplImage *origimage) 
26 |     throw (TrackingException) 
27 | {
28 |     if (!tracker.status[tracker.eyepoint1])
29 | 	throw TrackingException();
30 | 
31 |     double x0 = tracker.currentpoints[tracker.eyepoint1].x;
32 |     double y0 = tracker.currentpoints[tracker.eyepoint1].y;
33 |     double x1 = tracker.currentpoints[tracker.eyepoint2].x;
34 |     double y1 = tracker.currentpoints[tracker.eyepoint2].y;
35 |     double factor = 0.17;
36 |     double xfactor = 0.05;
37 |     double yfactor = 0.20 * (x0 < x1 ? -1 : 1);
38 |     double L = factor / eyedx;
39 |     double LL = x0 < x1? L : -L;
40 |     float matrix[6] = 
41 | 	{LL*(x1-x0), LL*(y0-y1), 
42 | 	 x0 + factor * ((1-xfactor)*(x1-x0) + yfactor * (y0-y1)),
43 | 	 LL*(y1-y0), LL*(x1-x0), 
44 | 	 y0 + factor * ((1-xfactor)*(y1-y0) + yfactor * (x1-x0))};
45 |     CvMat M = cvMat( 2, 3, CV_32F, matrix );
46 | 
47 |     cvGetQuadrangleSubPix( origimage, eyeimage.get(), &M);
48 |     cvCvtColor(eyeimage.get(), eyegrey.get(), CV_RGB2GRAY);
49 | 
50 |     processEye();
51 | }
52 | 
53 | EyeExtractor::~EyeExtractor(void) {
54 | }
55 | 
56 | 
57 | 


--------------------------------------------------------------------------------
/OutputMethods.cpp:
--------------------------------------------------------------------------------
 1 | #include "OutputMethods.h"
 2 | #include <sys/types.h>
 3 | #include <sys/socket.h>
 4 | #include <netinet/in.h>
 5 | #include <arpa/inet.h>
 6 | #include <sys/mman.h>
 7 | #include <sys/types.h>
 8 | #include <sys/stat.h>
 9 | #include <fcntl.h>
10 | #include <unistd.h>
11 | 
12 | AbstractStore::~AbstractStore() {
13 | }
14 | 
15 | MmapStore::MmapStore(const char *filename) {
16 |     fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
17 |     write(fd, &fd, sizeof(fd));
18 |     write(fd, &fd, sizeof(fd));
19 |     if (fd < 0) {perror("open");return;}
20 |     positiontable = (int*) mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
21 | 				MAP_SHARED, fd, 0);
22 | }
23 | 
24 | void MmapStore::store(const TrackerOutput& output) {
25 |     positiontable[0] = (int) output.gazepoint.x - 320;
26 |     positiontable[1] = (int) output.gazepoint.y - 240;
27 | }
28 | 
29 | MmapStore::~MmapStore() {
30 |     munmap(positiontable, getpagesize());
31 |     close(fd);
32 | }
33 |  
34 | StreamStore::StreamStore(ostream &stream): stream(stream) {
35 | }
36 | 
37 | StreamStore::~StreamStore() {
38 | }
39 | 
40 | void StreamStore::store(const TrackerOutput& output) {
41 |     stream << (int) output.gazepoint.x << " " 
42 | 	   << (int) output.gazepoint.y << " -> "
43 | 	   << output.targetid << endl;
44 |     stream.flush();
45 | }
46 | 
47 | SocketStore::SocketStore(int port) {
48 |     mysocket = socket(PF_INET, SOCK_DGRAM, 0);
49 | 	
50 |     destaddr.sin_family = AF_INET;
51 |     destaddr.sin_port = htons(port);
52 |     destaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
53 | }
54 | 
55 | void SocketStore::store(const TrackerOutput& output) {
56 |     ostringstream stream;
57 |     stream << "x " << (int) output.gazepoint.x << endl
58 | 	   << "y " << (int) output.gazepoint.y << endl;
59 |     string str = stream.str();
60 |     sendto(mysocket, str.c_str(), str.size(), 0, 
61 | 	   (sockaddr*)&destaddr, sizeof(destaddr));
62 | }
63 | 
64 | SocketStore::~SocketStore(void) {
65 |     close(mysocket);
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/GazeTrackerGtk.cpp:
--------------------------------------------------------------------------------
 1 | #include "GazeTrackerGtk.h"
 2 | #include <gtkmm.h>
 3 | #include <iostream>
 4 | #include "GtkStore.h"
 5 | 
 6 | static vector<shared_ptr<AbstractStore> > getStores() {
 7 |     vector<shared_ptr<AbstractStore> > stores;
 8 | 
 9 |     stores.push_back(shared_ptr<AbstractStore>(new SocketStore()));
10 |     stores.push_back(shared_ptr<AbstractStore>(new StreamStore(cout)));
11 |     stores.push_back(shared_ptr<AbstractStore>
12 |       (new WindowStore(WindowPointer::PointerSpec(20, 20, 0, 0, 1),
13 | 		       WindowPointer::PointerSpec(30, 30, 1, 0, 1))));
14 | 
15 |     return stores;
16 | }
17 | 
18 | GazeTrackerGtk::GazeTrackerGtk(int argc, char **argv):
19 |     calibratebutton("Calibrate"), 
20 |     loadbutton("Load points"),
21 |     savebutton("Save points"),
22 |     clearbutton("Clear points"),
23 |     picture(argc, argv, getStores())
24 | {
25 |     set_title("opengazer 0.1.1");
26 | 
27 |     add(vbox);
28 |     vbox.pack_start(picture);
29 |     vbox.pack_start(buttonbar);
30 | 
31 |     buttonbar.pack_start(calibratebutton);
32 |     Gtk::Button *testbutton = manage(new Gtk::Button("Test"));
33 |     buttonbar.pack_start(*testbutton);
34 |     buttonbar.pack_start(savebutton);
35 |     buttonbar.pack_start(loadbutton);
36 |     buttonbar.pack_start(clearbutton);
37 |     
38 |     calibratebutton.signal_clicked().
39 |  	connect(sigc::mem_fun(&picture.gazetracker,
40 | 			      &MainGazeTracker::startCalibration));
41 |     testbutton->signal_clicked().
42 |  	connect(sigc::mem_fun(&picture.gazetracker,
43 | 			      &MainGazeTracker::startTesting));
44 |     savebutton.signal_clicked().
45 | 	connect(sigc::mem_fun(&picture.gazetracker,
46 | 			      &MainGazeTracker::savepoints));
47 |     loadbutton.signal_clicked().
48 | 	connect(sigc::mem_fun(&picture.gazetracker,
49 | 			      &MainGazeTracker::loadpoints));
50 |     clearbutton.signal_clicked().
51 | 	connect(sigc::mem_fun(&picture.gazetracker,
52 | 			      &MainGazeTracker::clearpoints));
53 | 
54 |     picture.show();
55 |     testbutton->show();
56 |     calibratebutton.show();
57 |     savebutton.show();
58 |     loadbutton.show();
59 |     clearbutton.show();
60 |     buttonbar.show();
61 |     vbox.show();
62 | }
63 | 
64 | 
65 | GazeTrackerGtk::~GazeTrackerGtk() {
66 | }
67 | 
68 | 
69 | 


--------------------------------------------------------------------------------
/GaussianProcess.cpp:
--------------------------------------------------------------------------------
 1 | #include <vnl/algo/vnl_cholesky.h>
 2 | 
 3 | class MultiGaussian {
 4 | public:
 5 |     Vector mean;
 6 |     Matrix covariance;
 7 | 
 8 |     MultiGaussian(Vector const& mean, Matrix const& covariance):
 9 | 	mean(mean), covariance(covariance) {}
10 | };
11 | 
12 | template <class T>
13 | class GaussianProcess {
14 | public:
15 |     typedef double (*CovarianceFunction)(const T&, const T&);
16 | private:
17 |     vector<T> inputs;
18 |     CovarianceFunction covariancefunction;
19 | private:
20 |     Matrix L;
21 |     Vector alpha;
22 | 
23 |     Matrix getcovariancematrix(vector<T> const& in1, 
24 | 			       vector<T> const& in2) const
25 |     {
26 | 	Matrix K(in1.size(), in2.size());
27 | 	
28 | 	for(int i=0; i<in1.size(); i++)
29 | 	    for(int j=0; j<in2.size(); j++)
30 | 		K(i,j) = covariancefunction(in1[i], in2[j]);
31 | 
32 | 	return K;
33 |     }
34 | 
35 | public:
36 |     GaussianProcess(vector<T> const& inputs, 
37 | 		    Vector const& targets,
38 | 		    CovarianceFunction covariancefunction, 
39 | 		    double noise=0.0):
40 |     inputs(inputs), covariancefunction(covariancefunction)
41 |     {
42 | 	Matrix K = getcovariancematrix(inputs, inputs);	
43 | 	for(int i=0; i<inputs.size(); i++)
44 | 	    K[i][i] += noise;
45 | 	// todo: do we need the "verbose" mode in cholesky?
46 | 	vnl_cholesky chol(K);
47 | 	L = chol.lower_triangle();
48 | 	alpha = chol.solve(targets);
49 |     }
50 | 
51 |     Vector getmeans(vector<T> const &tests) const {
52 | 	Matrix KK = getcovariancematrix(inputs, tests);
53 | 	return KK.transpose() * alpha;
54 |     }
55 | 
56 |     double getmean(T const& test) const {
57 | 	return getmeans(vector<T>(1, test))[0];
58 |     }
59 | };
60 | 
61 | template <class T> 
62 | class MeanAdjustedGaussianProcess {
63 |     double mean;
64 |     const GaussianProcess<T> gp;
65 | 
66 | public:
67 |     MeanAdjustedGaussianProcess(vector<T> const& inputs, 
68 | 				Vector const& targets,
69 | 				typename GaussianProcess<T>::CovarianceFunction 
70 | 				  covariancefunction, 
71 | 				double noise=0.0): 
72 | 	mean(targets.mean()), 
73 | 	gp(GaussianProcess<T>(inputs, targets - mean, 
74 | 			      covariancefunction, noise))
75 |     {}   
76 | 
77 |     double getmean(T const& test) const {
78 | 	return gp.getmean(test) + mean;
79 |     }
80 | };
81 | 


--------------------------------------------------------------------------------
/BlinkDetector.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "utils.h"
 3 | 
 4 | using namespace std;
 5 | using namespace boost;
 6 | 
 7 | struct StateNode {
 8 |     int minduration, maxduration;
 9 |     double threshold;
10 |     StateNode(int minduration, int maxduration, double threshold);
11 |     bool isSatisfied(double value) const;
12 | };
13 | 
14 | class LinearStateSystem {
15 |     const vector<StateNode> states;
16 |     int currentState, duration;
17 | public:
18 |     LinearStateSystem(const vector<StateNode> &states);
19 |     void updateState(double value);
20 |     void setState(int state);
21 |     int getState();
22 |     bool isFinalState();
23 | };
24 | 
25 | class LambdaAccumulator {
26 |     const double lambda;
27 |     double current;
28 |  public:
29 |     LambdaAccumulator(double lambda, double initial);
30 |     void update(double value);
31 |     double getValue();
32 | };
33 | 
34 | class BlinkDetector {
35 |     scoped_ptr<IplImage> averageEye;
36 |     LambdaAccumulator acc;
37 |     LinearStateSystem states;
38 |     static vector<StateNode> constructStates();
39 |  public:
40 |     BlinkDetector();
41 |     void update(const scoped_ptr<IplImage> &image);
42 |     int getState();
43 | };
44 | 
45 | 
46 | 
47 | /* template <class T> */
48 | /* class TwoClassDetector { */
49 | /*     const T class0, class1; */
50 | /*  public: */
51 | /*     TwoClassDetector(const T& class0, const T& class1):  */
52 | /*     class0(class0), class1(class1) {} */
53 | 	
54 | /*     double classify(const T& object) { */
55 | /* 	double dist0 = distance(class0, object); */
56 | /* 	double dist1 = distance(class0, object); */
57 | /* 	return dist0 / (dist0 + dist1); */
58 | /*     }; */
59 | /* }; */
60 | 
61 | /* template <class T, class Func> */
62 | /* class Accumulator { */
63 | /*     T accumulator; */
64 | /*     Func func; */
65 | /*  public: */
66 | /*     Accumulator(const T& initial, const Func& func):  */
67 | /*     accumulator(initial), func(func) */
68 | /*     {}; */
69 | /*     void update(const T& object) { */
70 | /* 	accumulator = func(accumulator, object); */
71 | /*     } */
72 | /*     T get() { */
73 | /* 	return accumulator; */
74 | /*     } */
75 | /* }; */
76 | 
77 | /* template <T> */
78 | /* class GetFurtherObject { */
79 | /*     T referenceobject; */
80 | /*  public: */
81 | /*     T operator()(const T& one, const T& two) { */
82 | /* 	if (distance(referenceobject, one) > distance(referenceobject, two)) */
83 | /* 	    return one; */
84 | /* 	else */
85 | /* 	    return two; */
86 | /*     } */
87 | /* }; */
88 | 
89 | /* Accumulator<shared_ptr<IplImage> >  */
90 | /* blink(currentimage, GetFurtherObject(average)); */
91 | 
92 | /* typedef TwoClassDetector<shared_ptr<IplImage> > BlinkDetector(average, blink.get()); */
93 | 


--------------------------------------------------------------------------------
/GazeArea.cpp:
--------------------------------------------------------------------------------
 1 | #include "GazeArea.h"
 2 | #include "OutputMethods.h"
 3 | #include <opencv/cv.h>
 4 | 
 5 | GazeArea::GazeArea(int argc, char **argv, 
 6 | 		   const vector<shared_ptr<AbstractStore> > &stores):
 7 |     lastPointId(-1), gazetracker(argc, argv, stores)
 8 | {
 9 |     set_size_request(gazetracker.canvas->width, gazetracker.canvas->height);
10 |     Glib::signal_idle().connect(sigc::mem_fun(*this, &GazeArea::on_idle));
11 |     add_events(Gdk::BUTTON_PRESS_MASK);
12 |     add_events(Gdk::BUTTON_RELEASE_MASK);
13 | }
14 | 
15 | GazeArea::~GazeArea(void) {}
16 | 
17 | bool GazeArea::on_idle() {
18 |     gazetracker.doprocessing();
19 |     queue_draw();
20 |     return true;
21 | }
22 | 
23 | bool GazeArea::on_expose_event(GdkEventExpose *event) {
24 |     Glib::RefPtr<Gdk::Window> window = get_window();
25 |     if (window) {
26 | 	Gtk::Allocation allocation = get_allocation();
27 | 	const int width = allocation.get_width();
28 | 	const int height = allocation.get_height();
29 | 
30 | 	Glib::RefPtr<Gdk::GC> gc = Gdk::GC::create(window);
31 | 	const IplImage *image = gazetracker.canvas.get();
32 | 	Glib::RefPtr<Gdk::Pixbuf> pixbuf =
33 | 	    Gdk::Pixbuf::create_from_data((guint8*) image->imageData,
34 | 					  Gdk::COLORSPACE_RGB,
35 | 					  false,
36 | 					  image->depth,
37 | 					  image->width,
38 | 					  image->height,
39 | 					  image->widthStep);
40 | 	window->draw_pixbuf(gc, pixbuf, 0,0,0,0, width, height,
41 | 			    Gdk::RGB_DITHER_NONE, 0, 0);
42 |     }
43 |     return true;
44 | }
45 | 
46 | bool GazeArea::on_button_press_event(GdkEventButton *event) {
47 |     if (event->button == 1) {
48 | 	switch(event->type) {
49 | 	case GDK_BUTTON_PRESS: clickCount = 1; break;
50 | 	case GDK_2BUTTON_PRESS: clickCount = 2; break;
51 | 	case GDK_3BUTTON_PRESS: clickCount = 3; break;
52 | 	default: break;
53 | 	}
54 | 
55 | 	if (event->type == GDK_BUTTON_PRESS) {
56 | 	    Point point(event->x, event->y);
57 | 	    PointTracker &tracker = gazetracker.tracking->tracker;
58 | 	    int closest = tracker.getClosestTracker(point);
59 | 	    if (closest >= 0 &&
60 | 		point.distance(tracker.currentpoints[closest]) <= 10)
61 | 		lastPointId = closest;
62 | 	    else
63 | 		lastPointId = -1;
64 | 	}
65 | 	return true;
66 |     }
67 |     else 
68 | 	return false;
69 | }
70 | 
71 | bool GazeArea::on_button_release_event(GdkEventButton *event) {
72 |     if (event->button == 1) {
73 | 	PointTracker &tracker = gazetracker.tracking->tracker;
74 | 	Point point(event->x, event->y);
75 | 	if (lastPointId >= 0)
76 | 	    switch(clickCount) {
77 | 	    case 1: tracker.updatetracker(lastPointId, point); break;
78 | 	    case 2: tracker.removetracker(lastPointId); break;
79 | 	    }
80 | 	else
81 | 	    tracker.addtracker(point);
82 | 	return true;
83 |     }
84 |     else
85 | 	return false;
86 | }
87 | 


--------------------------------------------------------------------------------
/BlinkDetector.cpp:
--------------------------------------------------------------------------------
 1 | #include "BlinkDetector.h"
 2 | #include <iostream>
 3 | #include "EyeExtractor.h"
 4 | #include "utils.h"
 5 | 
 6 | StateNode::StateNode(int minduration, int maxduration, double threshold):
 7 |     minduration(minduration), maxduration(maxduration), threshold(threshold) 
 8 | {
 9 | }
10 | 
11 | bool StateNode::isSatisfied(double value) const {
12 |     if (threshold > 0)
13 | 	return value >= threshold;
14 |     else
15 | 	return value <= -threshold;
16 | }
17 | 
18 | LinearStateSystem::LinearStateSystem(const vector<StateNode> &states): 
19 |     states(states), currentState(0), duration(0)
20 | {
21 |     assert(!states.empty());
22 | }
23 | 
24 | void LinearStateSystem::updateState(double value) {
25 |     cout << "update state: " << value << endl;
26 |     duration++;
27 |     if (currentState > 0 &&
28 | 	((duration < states[currentState].minduration &&
29 | 	  !states[currentState].isSatisfied(value)) || 
30 | 	 duration > states[currentState].maxduration))
31 | 	setState(0);
32 | 
33 |     if (!isFinalState() && states[currentState+1].isSatisfied(value))
34 | 	setState(currentState+1);
35 | }
36 | 
37 | void LinearStateSystem::setState(int state) {
38 |     currentState = state;
39 |     duration = 0;
40 | }
41 | 
42 | int LinearStateSystem::getState() {
43 |     return currentState;
44 | }
45 | 
46 | bool LinearStateSystem::isFinalState() {
47 |     return currentState == (int)states.size() - 1;
48 | }
49 | 
50 | LambdaAccumulator::LambdaAccumulator(double lambda, double initial):
51 |     lambda(lambda), current(initial)
52 | {
53 | }
54 | 
55 | void LambdaAccumulator::update(double value) {
56 |     current = (1-lambda)*current + lambda*value;
57 | }
58 | 
59 | double LambdaAccumulator::getValue() {
60 |     return current;
61 | }
62 | 
63 | BlinkDetector::BlinkDetector():
64 |     averageEye(cvCreateImage(EyeExtractor::eyesize, IPL_DEPTH_32F, 1)),
65 |     acc(0.1, 1000.0), 
66 |     states(constructStates())
67 | {
68 | }
69 | 
70 | vector<StateNode> BlinkDetector::constructStates() {
71 |     vector<StateNode> states;
72 |     states.push_back(StateNode(0, 0, +0.00)); 
73 |     states.push_back(StateNode(1, 8, +1.50)); 
74 |     states.push_back(StateNode(1, 8, -1.20)); // blink
75 |     states.push_back(StateNode(1, 8, +1.50)); 
76 |     states.push_back(StateNode(1, 8, -1.20)); // double blink
77 |     return states;
78 | }
79 | 
80 | void BlinkDetector::update(const scoped_ptr<IplImage> &eyefloat) {
81 |     double distance = cvNorm(eyefloat.get(), averageEye.get(), CV_L2);
82 |     acc.update(distance);
83 |     cout << "update distance" << distance << " -> " << acc.getValue() << endl;
84 |     states.updateState(distance / acc.getValue());
85 |     cvRunningAvg(eyefloat.get(), averageEye.get(), 0.05);
86 | }
87 | 
88 | int BlinkDetector::getState() {
89 |     return states.getState();
90 | }
91 | 


--------------------------------------------------------------------------------
/Alert.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include "utils.h"
  3 | 
  4 | /* class Alert { */
  5 | /*     shared_ptr<BlinkDetector> blinkdet; */
  6 | /*  public: */
  7 | /*     Alert(const shared_ptr<BlinkDetector>& blinkdet); */
  8 | /*     void alert(const string& string); */
  9 | /* }; */
 10 | 
 11 | enum StateEventType {
 12 |     EVENT_NOTHING, EVENT_SELECTED, EVENT_DESELECTED, EVENT_TICK,
 13 |     EVENT_BLINK, EVENT_2BLINK};
 14 | 
 15 | 
 16 | template <class ReturnType> class StateNode;
 17 | 
 18 | template<class ReturnType>
 19 | struct NodeResult {
 20 |     shared_ptr<StateNode<ReturnType> > nextNode;
 21 |     shared_ptr<ReturnType> result;
 22 |     NodeResult(const shared_ptr<StateNode<ReturnType> > &nextNode = 
 23 | 	       shared_ptr<StateNode<ReturnType> >(),
 24 | 	       const shared_ptr<ReturnType> &result = shared_ptr<ReturnType>()):
 25 |     nextNode(nextNode), result(result) {}
 26 | };
 27 | 
 28 | template<class ReturnType>
 29 | class StateNode {
 30 |  protected:
 31 |     int ticks;
 32 |  public:
 33 |     StateNode(): ticks(0) {}
 34 |     virtual NodeResult<ReturnType> handleEvent(StateEventType event);
 35 |     virtual ~StateNode() {};
 36 | };
 37 | 
 38 | template<class ReturnType>
 39 | class StateMachine: public StateNode<ReturnType>{
 40 |     shared_ptr<StateNode<ReturnType> > currentNode;
 41 |  public:
 42 |     StateMachine(const shared_ptr<StateNode<ReturnType> >& initialNode);
 43 |     virtual  NodeResult<ReturnType> handleEvent(StateEventType event);
 44 | };
 45 | 
 46 | template<class ReturnType>
 47 | NodeResult<ReturnType> StateNode<ReturnType>::handleEvent(StateEventType event) {
 48 |     switch(event) {
 49 |     case EVENT_SELECTED: 
 50 |     case EVENT_DESELECTED: ticks = 0; break;
 51 |     case EVENT_TICK: ticks++; break;
 52 |     default:;
 53 |     }
 54 |     return NodeResult<ReturnType>();
 55 | }
 56 | 
 57 | template<class ReturnType>
 58 | StateMachine<ReturnType>::StateMachine(const shared_ptr<StateNode<ReturnType> >& initialNode):
 59 |     currentNode(initialNode) 
 60 | {
 61 | }
 62 | 
 63 | template<class ReturnType>
 64 | NodeResult<ReturnType> StateMachine<ReturnType>::handleEvent(StateEventType event) {
 65 |     for(;;) {
 66 | 	NodeResult<ReturnType> result = currentNode->handleEvent(event);
 67 | 	if (result.result.get() != 0)
 68 | 	    return result;
 69 | 	if (result.nextNode.get() == 0) 
 70 | 	    return result;
 71 | 	currentNode->handleEvent(EVENT_DESELECTED);
 72 | 	currentNode = result.nextNode;
 73 | 	event = EVENT_SELECTED;
 74 |     }
 75 | }
 76 | 
 77 | 
 78 | 
 79 | class AlertWindow: public StateNode<void> {
 80 |     Gtk::Window window;
 81 |     string text;
 82 |  public:
 83 |     AlertWindow(const string &text);
 84 |     virtual ~AlertWindow();
 85 |     virtual NodeResult<void> handleEvent(StateEventType event);
 86 | };
 87 | 
 88 | 
 89 | 
 90 | /* class MessageNode: public StateNode { */
 91 | /*     shared_ptr<StateNode> oknode, cancelnode; */
 92 | /*     scoped_ptr<AlertWindow> alert; */
 93 | /*     string text; */
 94 | /*  public: */
 95 | /*     MessageNode(const shared_ptr<StateNode>& oknode, */
 96 | /* 		const shared_ptr<StateNode>& cancelnode, */
 97 | /* 		const string& text); */
 98 | 
 99 | /*     virtual shared_ptr<StateNode> handleEvent(StateEventType event); */
100 | /* }; */
101 | 		
102 | 


--------------------------------------------------------------------------------
/Calibrator.cpp:
--------------------------------------------------------------------------------
  1 | #include "Calibrator.h"
  2 | 
  3 | Calibrator::~Calibrator() {
  4 | #ifdef DEBUG
  5 |     cout << "Destroying calibrator" << endl;
  6 | #endif
  7 | }
  8 | 
  9 | FrameFunction::~FrameFunction() {
 10 | #ifdef DEBUG
 11 |     cout << "Destroying framefunction" << endl;
 12 | #endif
 13 | }
 14 | 
 15 | MovingTarget::MovingTarget(const int &frameno, 
 16 | 			   const vector<Point>& points, 
 17 | 			   const shared_ptr<WindowPointer> &pointer,
 18 | 			   int dwelltime):
 19 |     FrameFunction(frameno), 
 20 |     points(points), dwelltime(dwelltime), pointer(pointer)
 21 | {    
 22 | };
 23 | 
 24 | MovingTarget::~MovingTarget() {
 25 |     int id = getFrame() / dwelltime;
 26 | }
 27 | 
 28 | void MovingTarget::process() {
 29 |     if (active()) {
 30 | 	int id = getPointNo();
 31 | 	if (getPointFrame() == 1) 
 32 | 	    pointer->setPosition((int)points[id].x, (int)points[id].y);	
 33 |     }
 34 |     else
 35 | 	detach();
 36 | }
 37 | 
 38 | bool MovingTarget::active() {
 39 |     return getPointNo() < (int) points.size();
 40 | }
 41 | 
 42 | int MovingTarget::getPointNo() {
 43 |     return getFrame() / dwelltime;
 44 | }
 45 | 
 46 | int MovingTarget::getPointFrame() {
 47 |     return getFrame() % dwelltime;
 48 | }
 49 | 
 50 | Calibrator::Calibrator(const int &framecount, 
 51 | 		       const shared_ptr<TrackingSystem> &trackingsystem,
 52 | 		       const vector<Point>& points, 
 53 | 		       const shared_ptr<WindowPointer> &pointer,
 54 | 		       int dwelltime): 
 55 |     MovingTarget(framecount, points, pointer, dwelltime),
 56 |     trackingsystem(trackingsystem)
 57 | {
 58 |     trackingsystem->gazetracker.clear();
 59 |     // todo: remove all calibration points
 60 | }
 61 | 
 62 | 
 63 | void Calibrator::process() {
 64 |     if (active()) {
 65 | 	int id = getPointNo();
 66 | 	int frame = getPointFrame();
 67 | 	if (frame == 1) // start
 68 | 	    averageeye.reset(new FeatureDetector(EyeExtractor::eyesize));
 69 | 
 70 | 	if (frame >= dwelltime/2) // middle
 71 | 	    averageeye->addSample(trackingsystem->eyex.eyefloat.get());
 72 | 
 73 | 	if (frame == dwelltime-1) { // end
 74 | 	    trackingsystem->gazetracker.
 75 | 		addExemplar(points[id], averageeye->getMean().get(),
 76 | 			    trackingsystem->eyex.eyegrey.get());
 77 | 	}
 78 |     }
 79 |     MovingTarget::process();
 80 | }
 81 | 
 82 | const Point Calibrator::defaultpointarr[] = {Point(0.5, 0.5), 
 83 | 					     Point(0.1, 0.5), Point(0.9, 0.5),
 84 | 					     Point(0.5, 0.1), Point(0.5, 0.9), 
 85 | 					     Point(0.1, 0.1), Point(0.1, 0.9), 
 86 | 					     Point(0.9, 0.9), Point(0.9, 0.1), 
 87 | 					     Point(0.3, 0.3), Point(0.3, 0.7), 
 88 | 					     Point(0.7, 0.7), Point(0.7, 0.3)};
 89 | 
 90 | vector<Point> 
 91 | Calibrator::defaultpoints(Calibrator::defaultpointarr, 
 92 | 			  Calibrator::defaultpointarr+
 93 | 			  (sizeof(Calibrator::defaultpointarr) / 
 94 | 			   sizeof(Calibrator::defaultpointarr[0])));
 95 | 
 96 | vector<Point> Calibrator::loadpoints(istream& in) {
 97 |     vector<Point> result;
 98 | 
 99 |     for(;;) {
100 | 	double x, y;
101 | 	in >> x >> y;
102 | 	if (in.rdstate()) break; // break if any error
103 | 	result.push_back(Point(x, y));
104 |     }
105 | 
106 |     return result;
107 | }
108 | 
109 | vector<Point> Calibrator::scaled(const vector<Point> &points,
110 | 				      double x, double y) 
111 | {
112 | //     double dx = x > y ? (x-y)/2 : 0.0;
113 | //     double dy = y > x ? (y-x)/2 : 0.0;
114 | //     double scale = x > y ? y : x;
115 | 
116 |     vector<Point> result;
117 | 
118 |     xforeach(iter, points)
119 | 	result.push_back(Point(iter->x * x, iter->y * y));
120 | // 	result.push_back(Point(iter->x * scale + dx, iter->y * scale + dy));
121 | 
122 |     return result;
123 | }
124 | 


--------------------------------------------------------------------------------
/utils.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <opencv/cv.h>
  4 | #include <math.h>
  5 | #include <vector>
  6 | #include <iostream>
  7 | #include <vnl/algo/vnl_svd.h>
  8 | #include <gdkmm.h>
  9 | #include <boost/shared_ptr.hpp>
 10 | #include <boost/scoped_ptr.hpp>
 11 | 
 12 | //#define DEBUG
 13 | 
 14 | using namespace std;
 15 | using namespace boost;
 16 | 
 17 | #define xforeach(iter,container) \
 18 |     for(typeof(container.begin()) iter = container.begin();	\
 19 | 	iter != container.end(); iter++)
 20 | 
 21 | #define xforeachback(iter,container) \
 22 |     for(typeof(container.rbegin()) iter = container.rbegin();	\
 23 | 	iter != container.rend(); iter++)
 24 | 
 25 | typedef vnl_vector<double> Vector;
 26 | typedef vnl_matrix<double> Matrix;
 27 | 
 28 | 
 29 | 
 30 | template <class T>
 31 | inline T square(T a) {
 32 |     return a * a;
 33 | }
 34 | 
 35 | template <class T> 
 36 | ostream& operator<< (ostream& out, vector<T> const& vec) {
 37 |     out << vec.size() << endl;
 38 |     xforeach(iter, vec)
 39 | 	out << *iter << endl;
 40 |     return out;
 41 | }
 42 | 
 43 | template <class T>
 44 | istream& operator>> (istream& in, vector<T> &vec) {
 45 |     int size;
 46 |     T element;
 47 | 
 48 |     vec.clear();
 49 |     in >> size;
 50 |     for(int i=0; i<size; i++) {
 51 | 	in >> element;
 52 | 	vec.push_back(element);
 53 |     }
 54 |     return in;
 55 | }
 56 | 
 57 | 
 58 | template <class T>
 59 | T teefunction(T source, char* prefix, char *postfix="\n") {
 60 |     cout << prefix << source << postfix;
 61 |     return source;
 62 | }
 63 | 
 64 | #define debugtee(x) teefunction(x, #x ": ")
 65 | 
 66 | template <class T>
 67 | void savevector(CvFileStorage *out, const char* name, vector<T>& vec) {
 68 |     cvStartWriteStruct(out, name, CV_NODE_SEQ);
 69 |     for(int i=0; i<vec.size(); i++) 
 70 | 	vec[i].save(out);
 71 |     cvEndWriteStruct(out);
 72 | }
 73 | 
 74 | template <class T>
 75 | vector<T> loadvector(CvFileStorage *in, CvFileNode *node) {
 76 |     CvSeq *seq = node->data.seq;
 77 |     CvSeqReader reader;
 78 |     cvStartReadSeq(seq, &reader, 0);
 79 |     vector<T> result(seq->total);
 80 |     for(int i=0; i<seq->total; i++) {
 81 | 	CvFileNode *item = (CvFileNode*) reader.ptr;
 82 | 	result[i].load(in, item);
 83 | 	CV_NEXT_SEQ_ELEM(seq->elem_size, reader);       
 84 |     }
 85 |     return result;
 86 | }
 87 | 
 88 | #include <gtkmm.h>
 89 | 
 90 | #include "Point.h"
 91 | 
 92 | template <class From, class To>
 93 | void convert(const From& from, To& to) {
 94 |     to = from;
 95 | }
 96 | 
 97 | template <class From, class To>
 98 | void convert(const vector<From> &from, vector<To> &to) {
 99 |     to.resize(from.size());
100 |     for(int i=0; i< (int) from.size(); i++)
101 | 	convert(from[i], to[i]);
102 | }
103 | 
104 | class ConstancyDetector {
105 |     int value;
106 |     int counter; 
107 |     int maxcounter;
108 | public:
109 |     ConstancyDetector(int maxcounter) : 
110 | 	value(-1), counter(0), maxcounter(maxcounter) {}
111 | 
112 |     bool isStable(void) {
113 | 	return counter >= maxcounter;
114 |     }
115 | 
116 |     bool isStableExactly(void) {
117 | 	return counter == maxcounter;
118 |     }
119 | 
120 |     bool observe(int newvalue) {
121 | 	if (newvalue != value || newvalue < 0) 
122 | 	    counter = 0;
123 | 	else
124 | 	    counter++;
125 | 	value = newvalue;
126 | 	return isStable();
127 |     }
128 | 
129 |     void reset(void) {
130 | 	counter = 0;
131 | 	value = -1;
132 |     }
133 | };
134 | 
135 | // #define output(X) { cout << #X " = " << X << endl; }
136 | 
137 | 
138 | template <class T> 
139 | int maxabsindex(T const& vec, int size) {
140 |     int maxindex = 0;
141 |     for(int i=0; i<size; i++)
142 | 	if (fabs(vec[i]) > fabs(vec[maxindex]))
143 | 	    maxindex = i;
144 |     return maxindex;
145 | }
146 | 
147 | namespace boost {
148 |     template <>
149 | 	void checked_delete(IplImage *image);
150 | }
151 | 
152 | void releaseImage(IplImage *image);
153 | shared_ptr<IplImage> createImage(const CvSize &size, int depth, int channels);
154 | 
155 | typedef shared_ptr<const IplImage> SharedImage;
156 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | Download:
  2 | 
  3 | 1. Tarball from 
  4 | 
  5 |    http://www.inference.phy.cam.ac.uk/opengazer/
  6 | 
  7 | 2. Or from sourceforge 
  8 | 
  9 |    http://sourceforge.net/projects/opengazer
 10 | 
 11 |    $ svn co https://opengazer.svn.sourceforge.net/svnroot/opengazer
 12 | 
 13 | Requirements:
 14 |   vxl >= 1.5.1	        http://vxl.sourceforge.net/
 15 |   opencv >= 0.9.7	http://sourceforge.net/projects/opencvlibrary
 16 |   gtkmm-2.4 >= 2.8.0	http://www.gtkmm.org/
 17 |   cairomm-1.0 >= 0.6.0  http://cairographics.org/cairomm/
 18 |   boost >= 1.32.0	http://www.boost.org/
 19 | 	
 20 | Under Debian testing:
 21 | 
 22 |   # apt-get install libcv-dev libhighgui-dev libcvaux-dev \
 23 |     	    	    libgtkmm-2.4-dev libcairomm-1.0-dev libboost-dev
 24 | 
 25 |   (vxl must be installed from the source)		    
 26 |   Important: in vxl's ccmake, set BUILD_SHARED_LIBS to ON.
 27 | 
 28 | Compilation:
 29 | 
 30 |   > tar xzf opengazer-0.1.tar.gz 
 31 |   > cd opengazer-0.1
 32 | 
 33 |   Edit the VXLDIR variable in the Makefile to point to your vxl
 34 |   include headers
 35 | 
 36 |   > make 
 37 | 
 38 |   Define the variable LD_LIBRARY_PATH to point to your vxl shared libraries
 39 | 
 40 |   > export LD_LIBRARY_PATH=$VXLDIR/lib
 41 | 
 42 | Instructions:
 43 | 
 44 | 0. Make sure that you have read access to webcam device file
 45 |    (/dev/video0).  In Debian/Ubuntu you can achieve that by adding
 46 |    yourself to the video group
 47 | 
 48 |    > sudo addgroup $USER video
 49 | 
 50 |    Then logout and login again (important).
 51 | 
 52 | 1. Set up the drivers to your camera correctly.  Put the camera into
 53 |    640x480 mode.  With pwc drivers you have to say
 54 | 
 55 |    > sudo rmmod pwc
 56 |    > sudo modprobe pwc size=vga
 57 | 
 58 | 2. Put the camera centrally under you monitor, so that the height of
 59 |    your face in the image is about half of the height of the image,
 60 |    and close to the centre of the image.  Make sure the background
 61 |    light level is reasonably constant across the image.
 62 | 
 63 | 3. Make VXLDIR point to your vxl libraries, for example 
 64 | 
 65 |    > export VXLDIR=/opt
 66 | 
 67 |    Define the variable LD_LIBRARY_PATH to point to your vxl shared libraries
 68 | 
 69 |    > export LD_LIBRARY_PATH=$VXLDIR/lib:$LD_LIBRARY_PATH
 70 | 
 71 |    Start the opengazer program
 72 | 
 73 |    > ./opengazer
 74 | 
 75 | 4. While keeping your head still, use the mouse to select points on
 76 |    your face that will be used to track your head.  The first two
 77 |    points much be eye corners.  Select at least two other salient
 78 |    points (recommended 7-8 in total).  Double-clicking on an existing
 79 |    point removes it.  The first two points (corresponding to eye
 80 |    corners) will be blue, the other will be green.  When a point
 81 |    becomes red, it means that it lost track.  When you are happy with
 82 |    your selection, click "Save points".
 83 | 
 84 |    You need at least four points in total, but I recommend 7-8.  Once
 85 |    they have been selected, the position of your head will be tracked
 86 |    and the rotation estimates displayed as white and blue lines from
 87 |    the center of the screen.  The blue line indicates the difference
 88 |    in head position between the first frame and the current position:
 89 |    make sure that it is as short as possible at all times!
 90 | 
 91 | 5. Now you can exit the program, run it again, click "load points",
 92 |    and the points you selected in point 3 should appear.  You have
 93 |    probably noted a white and blue line in the center of the image;
 94 |    they indicate the current rotation of your head.  The shorter the
 95 |    blue line, the closer your head position is to the original.  While
 96 |    using the gaze tracker, try to orient your head so that the length
 97 |    of the blue line is as small as possible.
 98 | 
 99 | 6. The next step is calibration.  Remember, in order for this gaze
100 |    tracker to work, you must keep your head absolutely still.  Press
101 |    "Calibrate".  You will now be asked to look at various points on
102 |    the screen, indicated by a red circle.  Remember: do not move your
103 |    head, only your eyes!  
104 | 
105 | 7. During the calibration and afterwards, a small blue will indicate
106 |    the estimated position of your gaze focus.
107 | 
108 | 
109 | 
110 | DEVELOPING OPENGAZER
111 | 
112 | 1. The coordinates of the calibration points are stored in
113 |    "calpoints.txt".  Feel free to change them.  For example, by having
114 |    only two calibration points: one on the left of the screen, and the
115 |    other on the right, you can use opengazer as a binary switch.
116 | 
117 | 2. Opengazer shows the current estimate of the gaze point as a small
118 |    purle circle on the screen.  
119 | 
120 |    It also outputs this information to the standard output.  Each line
121 |    has the format
122 | 
123 |    Xcoordinate Ycoordinate -> IDoftheclosestcalibrationpoint
124 | 
125 |    Opengazer also opens a local UDP socket at port 20230 to which it
126 |    sends the current estimates X and Y.  
127 | 
128 |    To add more output methods, or to change the existing one, take a
129 |    look at files "OutputMethods.cpp" and "OutputMethods.h".
130 | 
131 | 3. Other files used by opengazer
132 | 
133 |    calpoints.txt   Coordinates calibration points 
134 |    		   (as fraction of the screen)
135 | 
136 |    points.txt      Coordinates of the tracking points on the user face, in
137 |    		   pixels.  This file is saved when the user clicks
138 |    		   "Save points"
139 |    
140 |    


--------------------------------------------------------------------------------
/GazeTracker.cpp:
--------------------------------------------------------------------------------
  1 | #include "GazeTracker.h"
  2 | 
  3 | int Targets::getCurrentTarget(Point point) {
  4 |     vector<double> distances(targets.size());
  5 |     //    debugtee(targets);
  6 |     transform(targets.begin(), targets.end(), distances.begin(),
  7 | 	      sigc::mem_fun(point, &Point::distance));
  8 |     //    debugtee(distances);
  9 |     return min_element(distances.begin(), distances.end()) - distances.begin();
 10 | //     for(int i=0; i<targets.size(); i++)
 11 | // 	if (point.distance(targets[i]) < 30)
 12 | // 	    return i;
 13 | //     return -1;
 14 | }
 15 | 
 16 | 
 17 | CalTarget::CalTarget() {}
 18 | 
 19 | CalTarget::CalTarget(Point point, 
 20 | 		     const IplImage* image, const IplImage* origimage):
 21 |     point(point), 
 22 |     image(cvCloneImage(image), releaseImage), 
 23 |     origimage(cvCloneImage(origimage), releaseImage) 
 24 | {
 25 | }
 26 | 
 27 | void CalTarget::save(CvFileStorage* out, const char* name) {
 28 |     cvStartWriteStruct(out, name, CV_NODE_MAP);
 29 |     point.save(out, "point");
 30 |     cvWrite(out, "image", image.get());
 31 |     cvWrite(out, "origimage", origimage.get());
 32 |     cvEndWriteStruct(out);
 33 | }
 34 | 
 35 | void CalTarget::load(CvFileStorage* in, CvFileNode *node) {
 36 |     point.load(in, cvGetFileNodeByName(in, node, "point"));
 37 |     image.reset((IplImage*) cvReadByName(in, node, "image"));
 38 |     origimage.reset((IplImage*) cvReadByName(in, node, "origimage"));
 39 | }
 40 | 
 41 | TrackerOutput::TrackerOutput(Point gazepoint, Point target, int targetid):
 42 |     gazepoint(gazepoint), target(target), targetid(targetid)
 43 | {
 44 | }
 45 | 
 46 | template <class T, class S>
 47 | vector<S> getsubvector(vector<T> const& input, S T::*ptr) {
 48 |     vector<S> output(input.size());
 49 |     for(int i=0; i<input.size(); i++)
 50 | 	output[i] = input[i].*ptr;
 51 |     return output;
 52 | }
 53 | 
 54 | double GazeTracker::imagedistance(const IplImage *im1, const IplImage *im2) {
 55 |     double norm = cvNorm(im1, im2, CV_L2);
 56 |     return norm*norm;
 57 | }
 58 | 
 59 | double GazeTracker::covariancefunction(SharedImage const& im1, 
 60 | 				       SharedImage const& im2)
 61 | {
 62 |     const double sigma = 1.0;
 63 |     const double lscale = 500.0;
 64 |     return sigma*sigma*exp(-imagedistance(im1.get(),im2.get())/(2*lscale*lscale));
 65 | }
 66 | 
 67 | void GazeTracker::updateGPs(void) {
 68 |     Vector xlabels(caltargets.size());
 69 |     Vector ylabels(caltargets.size());
 70 | 		
 71 |     for(int i=0; i<caltargets.size(); i++) {
 72 | 	xlabels[i] = caltargets[i].point.x;
 73 | 	ylabels[i] = caltargets[i].point.y;
 74 |     }
 75 | 
 76 |     vector<SharedImage> images = 
 77 | 	getsubvector(caltargets, &CalTarget::image);
 78 | 
 79 |     gpx.reset(new ImProcess(images, xlabels, covariancefunction, 0.01));
 80 |     gpy.reset(new ImProcess(images, ylabels, covariancefunction, 0.01));  
 81 |     targets.reset(new Targets(getsubvector(caltargets, &CalTarget::point)));
 82 | }
 83 | 
 84 | void GazeTracker::clear() {
 85 |     caltargets.clear();
 86 |     // updateGPs()
 87 | }
 88 | 
 89 | void GazeTracker::addExemplar(Point point, 
 90 | 			      const IplImage *eyefloat, 
 91 | 			      const IplImage *eyegrey) 
 92 | {
 93 |     caltargets.push_back(CalTarget(point, eyefloat, eyegrey));
 94 |     updateGPs();
 95 | }
 96 | 
 97 | // void GazeTracker::updateExemplar(int id, 
 98 | // 				 const IplImage *eyefloat, 
 99 | // 				 const IplImage *eyegrey)
100 | // {
101 | //     cvConvertScale(eyegrey, caltargets[id].origimage.get());
102 | //     cvAdd(caltargets[id].image.get(), eyefloat, caltargets[id].image.get());
103 | //     cvConvertScale(caltargets[id].image.get(), caltargets[id].image.get(), 0.5);
104 | //     updateGPs();
105 | // }
106 | 
107 | void GazeTracker::draw(IplImage *destimage, int eyedx, int eyedy) {
108 | //     for(int i=0; i<caltargets.size(); i++) {
109 | // 	Point p = caltargets[i].point;
110 | // 	cvSetImageROI(destimage, cvRect((int)p.x - eyedx, (int)p.y - eyedy, 
111 | // 					2*eyedx, 2*eyedy));
112 | // 	cvCvtColor(caltargets[i].origimage, destimage, CV_GRAY2RGB);
113 | // 	cvRectangle(destimage, cvPoint(0,0), cvPoint(2*eyedx-1,2*eyedy-1),
114 | // 		    CV_RGB(255,0,255));
115 | //     }
116 | //     cvResetImageROI(destimage);
117 | }
118 | 
119 | void GazeTracker::save(void) {
120 |     CvFileStorage *out = 
121 | 	cvOpenFileStorage("calibration.xml", NULL, CV_STORAGE_WRITE);
122 |     save(out, "GazeTracker");
123 |     cvReleaseFileStorage(&out);
124 | }
125 | 
126 | void GazeTracker::save(CvFileStorage *out, const char *name) {
127 |     cvStartWriteStruct(out, name, CV_NODE_MAP);
128 |     savevector(out, "caltargets", caltargets);
129 |     cvEndWriteStruct(out);
130 | }
131 | 
132 | 
133 | void GazeTracker::load(void) {
134 |     CvFileStorage *in = 
135 | 	cvOpenFileStorage("calibration.xml", NULL, CV_STORAGE_READ);
136 |     CvFileNode *root = cvGetRootFileNode(in);
137 |     load(in, cvGetFileNodeByName(in, root, "GazeTracker"));
138 |     cvReleaseFileStorage(&in);
139 |     updateGPs();
140 | }
141 | 
142 | void GazeTracker::load(CvFileStorage *in, CvFileNode *node) {
143 |     caltargets = loadvector<CalTarget>(in, cvGetFileNodeByName(in, node, 
144 | 							       "caltargets"));
145 | }
146 | 
147 | static void ignore(const IplImage *) {}
148 | 
149 | void GazeTracker::update(const IplImage *image) {
150 |     if (isActive()) {
151 | 	output.gazepoint = Point(gpx->getmean(SharedImage(image, &ignore)), 
152 | 				 gpy->getmean(SharedImage(image, &ignore)));
153 | 	output.targetid = getTargetId(output.gazepoint);
154 | 	output.target = getTarget(output.targetid);
155 |     }
156 | }
157 | 
158 | int GazeTracker::getTargetId(Point point) {
159 |     return targets->getCurrentTarget(point);
160 | }
161 | 
162 | Point GazeTracker::getTarget(int id) {
163 |     return targets->targets[id];
164 | }
165 | 
166 | 
167 | 


--------------------------------------------------------------------------------
/TrackingSystem.cpp:
--------------------------------------------------------------------------------
  1 | #include "TrackingSystem.h"
  2 | #include "FeatureDetector.h"
  3 | #include "BlinkDetector.h"
  4 | 
  5 | static double quadraticminimum(double xm1, double x0, double xp1) {
  6 | //     cout << "values:" << xm1 << " " << x0 << " " << xp1 << endl;
  7 |     return (xm1 - xp1) / (2*(xp1 + xm1 - 2*x0));
  8 | }
  9 | 
 10 | static Point subpixelminimum(const IplImage *values) {
 11 |     CvPoint maxpoint;
 12 |     cvMinMaxLoc(values, NULL, NULL, &maxpoint);
 13 | //     cout << "max: " << maxpoint.x << " " << maxpoint.y << endl;
 14 |     
 15 |     int x = maxpoint.x;
 16 |     int y = maxpoint.y;
 17 | 
 18 |     Point p(x, y);
 19 | 
 20 |     if (x > 0 && x < 6)
 21 | 	p.x += quadraticminimum(cvGetReal2D(values, y, x-1),
 22 | 				cvGetReal2D(values, y, x+0),
 23 | 				cvGetReal2D(values, y, x+1));
 24 |     
 25 |     if (y > 0 && y < 4)
 26 | 	p.y += quadraticminimum(cvGetReal2D(values, y-1, x),
 27 | 				cvGetReal2D(values, y+0, x),
 28 | 				cvGetReal2D(values, y+1, x));
 29 | 
 30 |     return p;
 31 | }
 32 | 
 33 | 
 34 | TrackingSystem::TrackingSystem(CvSize size):
 35 |     tracker(size), headtracker(tracker), headcomp(headtracker), eyex(tracker) 
 36 | {}
 37 | 
 38 | 
 39 | void TrackingSystem::doprocessing(const IplImage *frame, 
 40 | 				  IplImage *image) 
 41 | {
 42 |     tracker.track(frame, 2);
 43 |     if (tracker.countactivepoints() < 4) {
 44 | 	tracker.draw(image);
 45 | 	throw TrackingException();
 46 |     }
 47 | 
 48 |     headtracker.updatetracker();
 49 |     eyex.extractEye(frame);	// throws Tracking Exception
 50 |     gazetracker.update(eyex.eyefloat.get());
 51 | 	
 52 |     displayeye(image, 0, 0, 0, 2);
 53 |     tracker.draw(image);
 54 |     headtracker.draw(image);
 55 | }
 56 | 
 57 | void TrackingSystem::displayeye(IplImage *image, 
 58 | 				 int basex, int basey, int stepx, int stepy) 
 59 | {
 60 |     CvSize eyesize = EyeExtractor::eyesize;
 61 |     int eyedx = EyeExtractor::eyedx;
 62 |     int eyedy = EyeExtractor::eyedy;
 63 | 
 64 |     static IplImage *eyegreytemp = cvCreateImage( eyesize, 8, 1 );
 65 |     static FeatureDetector features(EyeExtractor::eyesize);
 66 | 
 67 |     features.addSample(eyex.eyegrey.get());
 68 | 
 69 |     basex *= 2*eyedx; basey *= 2*eyedy;
 70 |     stepx *= 2*eyedx; stepy *= 2*eyedy;
 71 | 
 72 |     gazetracker.draw(image, eyedx, eyedy);
 73 | 
 74 |     cvSetImageROI(image, cvRect(basex, basey, eyedx*2, eyedy*2));
 75 |     cvCvtColor(eyex.eyegrey.get(), image, CV_GRAY2RGB);
 76 | 
 77 |     cvSetImageROI(image, cvRect(basex + stepx*1, basey + stepy*1,
 78 | 				    eyedx*2, eyedy*2));
 79 |     cvCvtColor(eyex.eyegrey.get(), image, CV_GRAY2RGB);
 80 | 
 81 |     cvConvertScale(features.getMean().get(),  eyegreytemp);
 82 |     cvSetImageROI(image, cvRect(basex, basey, eyedx*2, eyedy*2));
 83 |     cvCvtColor(eyegreytemp, image, CV_GRAY2RGB);
 84 | 
 85 | // //     features.getVariance(eyegreytemp);
 86 | // //     cvSetImageROI(image, cvRect(basex, basey+stepy*2, eyedx*2, eyedy*2));
 87 | // //     cvCvtColor(eyegreytemp, image, CV_GRAY2RGB);
 88 | 
 89 | //     // compute the x-derivative
 90 |     
 91 | //     static IplImage *eyegreytemp1 = cvCreateImage( eyesize, IPL_DEPTH_32F, 1 );
 92 | //     static scoped_ptr<IplImage> 
 93 | // 	eyegreytemp2(cvCreateImage(eyesize, IPL_DEPTH_32F, 1));
 94 | 
 95 | // //     static IplImage *eyegreytemp3 = cvCreateImage( eyesize, IPL_DEPTH_32F, 1 );
 96 | //     static IplImage *eyegreytemp4 = cvCreateImage(cvSize(7,5),IPL_DEPTH_32F,1);
 97 | //     features.getMean(eyegreytemp1);
 98 | //     cvConvertScale(eyex.eyegrey, eyegreytemp2.get());
 99 | //     double distance = cvNorm(eyegreytemp1, eyegreytemp2.get(), CV_L2);
100 | //     static BlinkDetector blinkdet;
101 | //     blinkdet.update(eyegreytemp2);
102 | //     cout << "distance: " << distance 
103 | // 	 << " blink: " << blinkdet.getState() <<endl;
104 |     
105 | //     cvSetImageROI(eyegreytemp1, cvRect(2,2,eyedx*2-6,eyedy*2-4));
106 | //     cvMatchTemplate(eyegreytemp2.get(), eyegreytemp1, eyegreytemp4, CV_TM_SQDIFF);
107 | //     cvResetImageROI(eyegreytemp1);
108 | 
109 | //     for(int i=0; i<5; i++) {
110 | // 	cout << endl;
111 | // 	for(int j=0; j<7; j++)
112 | // 	    cout << cvGetReal2D(eyegreytemp4, i, j)/1e6 << " ";
113 | //     }
114 | //     cout << endl;
115 | 
116 | //     CvPoint maxpoint;
117 | //     cvMinMaxLoc(eyegreytemp4, NULL, NULL, &maxpoint);
118 | //     cout << "max: " << maxpoint.x << " " << maxpoint.y << endl;
119 | 
120 | //     cvSetImageROI(eyex.eyegrey, 
121 | // 		  cvRect(maxpoint.x, maxpoint.y, eyedx*2-6, eyedy*2-4));
122 | //     cvSetImageROI(image, cvRect(basex, basey+stepy*3, eyedx*2-6, eyedy*2-4));
123 | //     cvCvtColor(eyex.eyegrey, image, CV_GRAY2RGB);
124 | //     cvResetImageROI(eyex.eyegrey);
125 | 
126 | //     Point mxpoint = subpixelminimum(eyegreytemp4);
127 | //     cout << "max: " << mxpoint.x << " " << mxpoint.y << endl;
128 | 
129 | //     tracker.currentpoints[0].x += 0.4 * (mxpoint.x - 3.0);
130 | //     tracker.currentpoints[0].y += 0.4 * (mxpoint.y - 2.0);
131 | 
132 | //     cvSub(eyex.eyefloat, eyegreytemp1, eyegreytemp3);
133 | //     cvSetImageROI(eyegreytemp1, cvRect(0,0,eyedx*2-1,eyedy*2));
134 | //     cvSetImageROI(eyegreytemp2, cvRect(1,0,eyedx*2-1,eyedy*2));
135 | //     cvCopy(eyegreytemp1, eyegreytemp2);
136 | //     cvResetImageROI(eyegreytemp1);
137 | //     cvResetImageROI(eyegreytemp2);
138 | //     cvAddS(eyegreytemp1, cvScalar(128.0), eyegreytemp1);
139 | //     cvSub(eyegreytemp1, eyegreytemp2, eyegreytemp1);
140 |     
141 | //     cvSetImageROI(image, cvRect(basex, basey+stepy*2, eyedx*2, eyedy*2));
142 | //     cvConvertScale(eyegreytemp1, eyegreytemp);
143 | 
144 | // //     cvMul(eyegreytemp3, eyegreytemp1, eyegreytemp3);
145 | // //     cout << "x movement: " << cvAvg(eyegreytemp3).val[0] << endl;
146 |     
147 | 
148 | //     cvCvtColor(eyegreytemp, image, CV_GRAY2RGB);
149 | 
150 |     
151 | 
152 |     cvResetImageROI(image);
153 | }
154 | 


--------------------------------------------------------------------------------
/MainGazeTracker.cpp:
--------------------------------------------------------------------------------
  1 | #include "utils.h"
  2 | #include <fstream>
  3 | #include "MainGazeTracker.h"
  4 | 
  5 | class VideoWriter {
  6 |     CvVideoWriter *video;
  7 | public:
  8 |     VideoWriter(CvSize size) : 
  9 | 	video(cvCreateVideoWriter("out.avi", 0x58564944, 15.0, size))
 10 |     {}
 11 |     
 12 |     void write(const IplImage *image) {
 13 | 	cvWriteFrame(video, image);
 14 |     }
 15 | 
 16 |     ~VideoWriter() {
 17 | 	cvReleaseVideoWriter(&video);
 18 |     }
 19 | };
 20 | 
 21 | 
 22 | 
 23 | CommandLineArguments::CommandLineArguments(int argc, char** argv) {
 24 |     for(int i=1; i<argc; i++) {
 25 | 	if (argv[i][0] == '-') 
 26 | 	    options.push_back(argv[i]);
 27 | 	else 
 28 | 	    parameters.push_back(argv[i]);
 29 |     }
 30 | }
 31 | 
 32 | bool CommandLineArguments::isoption(const char* option) {
 33 |     xforeach(iter, options)
 34 | 	if (!strcmp(*iter, option))
 35 | 	    return true;
 36 |     return false;
 37 | }
 38 | 
 39 | VideoInput::VideoInput(): 
 40 |     capture(cvCaptureFromCAM(0)), framecount(0),
 41 |     frame(cvQueryFrame(capture)), size(cvSize(frame->width, frame->height))
 42 | {}
 43 | 
 44 | VideoInput::VideoInput(const char* filename):
 45 |     capture(cvCaptureFromFile(filename)), framecount(0),
 46 |     frame(cvQueryFrame(capture)), size(cvSize(frame->width, frame->height)) 
 47 | {}
 48 | 
 49 | void VideoInput::updateFrame() {
 50 |     framecount++;
 51 |     frame = cvQueryFrame(capture);
 52 | }
 53 | 
 54 | VideoInput::~VideoInput() {
 55 |     cvReleaseCapture( &capture );
 56 | }
 57 | 
 58 | MainGazeTracker::MainGazeTracker(int argc, char** argv, 
 59 | 				 const vector<shared_ptr<AbstractStore> > 
 60 | 				 &stores): 
 61 |     framestoreload(-1), stores(stores), autoreload(false)
 62 | //     , statemachine(shared_ptr<AlertWindow>(new AlertWindow("start")))
 63 | {
 64 |     CommandLineArguments args(argc, argv);
 65 | 
 66 |     if (args.parameters.size() == 0) {
 67 | 	videoinput.reset(new VideoInput());
 68 | 	if (args.isoption("--record"))
 69 | 	    video.reset(new VideoWriter(videoinput->size));
 70 |     }
 71 |     else {
 72 | 	videoinput.reset(new VideoInput(args.parameters[0]));
 73 | // 	if (args.parameters.size() >= 2)
 74 | // 	    fileinput.reset(new FileInput(parameters[1]));
 75 |     }
 76 | 
 77 | 
 78 |     canvas.reset(cvCreateImage(videoinput->size, 8, 3));
 79 |     tracking.reset(new TrackingSystem(videoinput->size));
 80 | 						     
 81 | }
 82 | 
 83 | void MainGazeTracker::addTracker(Point point) {
 84 |     tracking->tracker.addtracker(point);
 85 | }
 86 | 
 87 | void MainGazeTracker::savepoints() {
 88 |     try {
 89 | 	tracking->tracker.save("tracker", "points.txt", videoinput->frame);
 90 | 	autoreload = true;
 91 |     }
 92 |     catch (ios_base::failure &e) {
 93 | 	cout << e.what() << endl;
 94 |     }
 95 | }
 96 | 
 97 | void MainGazeTracker::loadpoints() {
 98 |     try {
 99 | 	tracking->tracker.load("tracker", "points.txt", videoinput->frame);
100 | 	autoreload = true;
101 |     }
102 |     catch (ios_base::failure &e) {
103 | 	cout << e.what() << endl;
104 |     }
105 | }
106 | 
107 | void MainGazeTracker::clearpoints() {
108 |     tracking->tracker.cleartrackers();
109 |     autoreload = false;
110 | }
111 | 
112 | void MainGazeTracker::doprocessing(void) {
113 |     framecount++;
114 |     videoinput->updateFrame();
115 |     const IplImage *frame = videoinput->frame;
116 | 
117 |     if (video.get())
118 | 	video->write(frame);
119 | 
120 |     canvas->origin = frame->origin;
121 |     cvCopy( frame, canvas.get(), 0 );
122 | 
123 |     try {
124 | 	tracking->doprocessing(frame, canvas.get());
125 | 	if (tracking->gazetracker.isActive()) {
126 | 	    xforeach(iter, stores)
127 | 		(*iter)->store(tracking->gazetracker.output);
128 | // 	    cout << point.x << " " << point.y << " -> " 
129 | // 		 << tracking->gazetracker.getTargetId(point) << endl;
130 | 	}
131 | // 	if (!tracking->tracker.areallpointsactive())
132 | // 	    throw TrackingException();
133 | 	framestoreload = 20;
134 |     }
135 |     catch (TrackingException&) {
136 | 	framestoreload--;
137 |     }
138 | 
139 |     framefunctions.process();
140 | //     statemachine.handleEvent(EVENT_TICK);
141 | 
142 |     if (autoreload && framestoreload <= 0) 
143 |  	loadpoints();
144 | }
145 | 
146 | 
147 | MainGazeTracker::~MainGazeTracker(void) {
148 | }
149 | 
150 | 
151 | void MainGazeTracker::addExemplar(Point exemplar) {
152 |     if (exemplar.x >= EyeExtractor::eyedx && 
153 | 	exemplar.x + EyeExtractor::eyedx < videoinput->size.width &&
154 | 	exemplar.y >= EyeExtractor::eyedy && 
155 | 	exemplar.y + EyeExtractor::eyedy < videoinput->size.height) 
156 | 	tracking->gazetracker.addExemplar(exemplar, 
157 | 					  tracking->eyex.eyefloat.get(), 
158 | 					  tracking->eyex.eyegrey.get());
159 | }
160 | 
161 | static vector<Point> scalebyscreen(const vector<Point> &points) {
162 |     Glib::RefPtr<Gdk::Screen> screen = 
163 | 	Gdk::Display::get_default()->get_default_screen();
164 |     return Calibrator::scaled(points, screen->get_width(), screen->get_height());
165 | }
166 | 
167 | void MainGazeTracker::startCalibration() {
168 |     shared_ptr<WindowPointer> 
169 | 	pointer(new WindowPointer(WindowPointer::PointerSpec(30,30,1,0,0)));
170 | 
171 |     ifstream calfile("calpoints.txt");
172 | 
173 |     shared_ptr<Calibrator> 
174 | 	calibrator(new Calibrator(framecount, tracking, 
175 | 				  scalebyscreen(Calibrator::loadpoints(calfile)),
176 | 				  pointer));
177 |     
178 |     framefunctions.clear();
179 |     framefunctions.addchild(&framefunctions, calibrator);
180 | }
181 | 
182 | void MainGazeTracker::startTesting() {
183 |     vector<Point> points;
184 |     for(double x=0.2; x<0.9; x+=0.2)
185 | 	for(double y=0.2; y<0.9; y+=0.2)
186 | 	    points.push_back(Point(x,y));
187 | 
188 |     shared_ptr<WindowPointer> 
189 | 	pointer(new WindowPointer(WindowPointer::PointerSpec(30,30,0,1,0)));
190 | 
191 |     shared_ptr<MovingTarget> 
192 | 	moving(new MovingTarget(framecount, scalebyscreen(points), pointer));
193 |     
194 |     framefunctions.clear();
195 |     framefunctions.addchild(&framefunctions, moving);
196 | }
197 | 


--------------------------------------------------------------------------------
/PointTracker.cpp:
--------------------------------------------------------------------------------
  1 | #include "PointTracker.h"
  2 | #include "FaceDetector.h"
  3 | #include <opencv/highgui.h>
  4 | #include <fstream>
  5 | 
  6 | 
  7 | PointTracker::PointTracker(const CvSize &size):
  8 |     flags(CV_LKFLOW_INITIAL_GUESSES),
  9 |     grey(cvCreateImage(size, 8, 1)),
 10 |     orig_grey(cvCreateImage(size, 8, 1)),
 11 |     pyramid(cvCreateImage(size, 8, 1)),
 12 |     orig_pyramid(cvCreateImage(size, 8, 1)),
 13 |     last_grey(cvCreateImage(size, 8, 1)),
 14 |     last_pyramid(cvCreateImage(size, 8, 1))
 15 | //     origpoints(new CvPoint2D32f[MAX_COUNT]),
 16 | //     currentpoints(new CvPoint2D32f[MAX_COUNT]),
 17 | //     status(new char[MAX_COUNT]),
 18 | {}
 19 | 
 20 | static Point pointbetweenrects(const Point &point, CvRect source, CvRect dest) {
 21 |     return Point((point.x-source.x)*(double(dest.width)/source.width)+dest.x,
 22 | 		 (point.y-source.y)*(double(dest.height)/source.height)+dest.y);
 23 | 
 24 | }
 25 | 
 26 | static vector<Point> pointbetweenrects(const vector<Point> &points,
 27 | 				       CvRect source, CvRect dest)
 28 | {
 29 |     vector<Point> result;
 30 |     result.reserve(points.size());
 31 |     xforeach(iter, points)
 32 | 	result.push_back(pointbetweenrects(*iter, source, dest));
 33 |     return result;
 34 | }
 35 | 
 36 | void PointTracker::save(string filename, string newpoints, 
 37 | 			const IplImage *frame) 
 38 | {
 39 |     vector<CvRect> faces = FaceDetector::facedetector.detect(frame);
 40 |     if (faces.size() == 1) {
 41 | 	cvSaveImage((filename + "-orig-grey.png").c_str(), orig_grey.get());
 42 | 	cvSaveImage((filename + "-orig-pyramid.png").c_str(), orig_pyramid.get());
 43 |     
 44 | 	ofstream origfile((filename + "-orig-points.txt").c_str());
 45 | 	origfile << origpoints;
 46 | 
 47 | 	CvRect face = faces[0];
 48 | 	ofstream facefile(newpoints.c_str());
 49 | 	vector<Point> temppoints;
 50 | 	convert(currentpoints, temppoints);
 51 | 	facefile << pointbetweenrects(temppoints, face, cvRect(0, 0, 1, 1));
 52 |     }
 53 |     else 
 54 | 	throw ios_base::failure("No face found in the image");
 55 | }
 56 | 
 57 | void PointTracker::load(string filename, string newpoints, 
 58 | 			const IplImage *frame) 
 59 | {
 60 |     vector<CvRect> faces = FaceDetector::facedetector.detect(frame);
 61 | 
 62 |     if (faces.size() == 1) {
 63 | 	ifstream origfile((filename + "-orig-points.txt").c_str());
 64 | 	ifstream facefile(newpoints.c_str());
 65 | 	if (!origfile.is_open() || !facefile.is_open())
 66 | 	    throw ios_base::failure("File not found");
 67 | 
 68 | 	// todo: memory leak here, change to scoped_ptr!
 69 | 	orig_grey.reset(cvLoadImage((filename + "-orig-grey.png").c_str(), 0));
 70 | 	orig_pyramid.reset(cvLoadImage((filename + "-orig-pyramid.png").c_str(), 0));
 71 |     
 72 | 	vector<Point> temppoints;
 73 | 	origfile >> temppoints;
 74 | 	convert(temppoints, origpoints);
 75 | 
 76 | 	facefile >> temppoints;
 77 | 	temppoints = pointbetweenrects(temppoints, cvRect(0,0,1,1), faces[0]);
 78 | 	convert(temppoints, currentpoints);
 79 | 	lastpoints = currentpoints;
 80 |     }
 81 |     else
 82 | 	throw ios_base::failure("No face found in the image");
 83 | }
 84 | 
 85 | int PointTracker::getClosestTracker(const Point &point) {
 86 |     vector<Point> points;
 87 |     convert(currentpoints, points);
 88 |     return point.closestPoint(points);
 89 | }
 90 | 
 91 | void PointTracker::removetracker(int id) {
 92 |     currentpoints.erase(currentpoints.begin()+id);
 93 |     lastpoints.erase(lastpoints.begin()+id);
 94 |     origpoints.erase(origpoints.begin()+id);
 95 | }
 96 | 
 97 | void PointTracker::synchronizepoints() {
 98 |     swap(orig_grey, grey);
 99 |     swap(orig_pyramid, pyramid);
100 |     origpoints = lastpoints = currentpoints;
101 | }
102 | 
103 | void PointTracker::updatetracker(int id, const Point &point) {
104 |     currentpoints[id] = point.cvpoint32();
105 |     synchronizepoints();
106 | }
107 | 
108 | void PointTracker::addtracker(const Point &point) {
109 |     currentpoints.push_back(point.cvpoint32());
110 |     synchronizepoints();
111 | }
112 | 
113 | void PointTracker::cleartrackers() {
114 |     currentpoints.clear();
115 |     synchronizepoints();
116 | }
117 | 
118 | void PointTracker::track(const IplImage *frame, int pyramiddepth) 
119 | {
120 |     assert(lastpoints.size() == currentpoints.size());
121 |     assert(origpoints.size() == currentpoints.size());
122 |     status.resize(currentpoints.size());
123 |     cvCvtColor(frame, grey.get(), CV_BGR2GRAY );
124 |     if (!currentpoints.empty()) {
125 | 	// first calculate the new position of the features based
126 | 	// on the (pyramidal) last frame and position estimations
127 | 	cvCalcOpticalFlowPyrLK(last_grey.get(), grey.get(), 
128 | 			       last_pyramid.get(), pyramid.get(),
129 | 			       &lastpoints[0], &currentpoints[0], pointcount(), 
130 | 			       cvSize(win_size,win_size), 2, &status[0], 0,
131 | 			       cvTermCriteria(CV_TERMCRIT_ITER|
132 | 					      CV_TERMCRIT_EPS,20,0.01), 
133 | 			       flags);
134 | 
135 | 	// then calculate the position based on the original
136 | 	// template without any pyramids
137 | 	cvCalcOpticalFlowPyrLK(orig_grey.get(), grey.get(), 
138 | 			       orig_pyramid.get(), pyramid.get(),
139 | 			       &origpoints[0], &currentpoints[0], pointcount(), 
140 | 			       cvSize(win_size, win_size), 
141 | 			       pyramiddepth, &status[0], 0,
142 | 			       cvTermCriteria(CV_TERMCRIT_ITER|
143 | 					      CV_TERMCRIT_EPS,20,0.01), 
144 | 			       flags);
145 | 
146 | 
147 | 	flags |= CV_LKFLOW_PYR_A_READY;
148 |     }
149 | 
150 |     cvCopy(grey.get(), last_grey.get(), 0);
151 |     cvCopy(pyramid.get(), last_pyramid.get(), 0);
152 |     lastpoints = currentpoints;
153 | }
154 | 
155 | int PointTracker::countactivepoints(void) {
156 |     return count_if(status.begin(), status.end(), 
157 | 		    bind1st(not_equal_to<char>(), 0));
158 | }
159 | 
160 | bool PointTracker::areallpointsactive(void) {
161 |     return count(status.begin(), status.end(), 0) == 0;
162 | }
163 | 
164 | void PointTracker::draw(IplImage *canvas) {
165 |     for(int i=0; i< (int) currentpoints.size(); i++)
166 | 	cvCircle( canvas, cvPointFrom32f(currentpoints[i]), 3, 
167 | 		  status[i]?(i == eyepoint1 || i == eyepoint2 ? 
168 | 			     CV_RGB(255,0,0):
169 | 			     CV_RGB(0,255,0)):
170 | 		  CV_RGB(0,0,255), 
171 | 		  -1, 8,0);
172 | }
173 | 
174 | int PointTracker::pointcount() {
175 |     return currentpoints.size();
176 | }
177 | 
178 | vector<HomPoint> 
179 | PointTracker::getpoints(const vector<CvPoint2D32f> PointTracker::*points, 
180 | 			bool allpoints) 
181 | {
182 |     vector<HomPoint> vec;
183 |     for(int i=0; i<pointcount(); i++)
184 | 	if (allpoints || status[i])
185 | 	    vec.push_back(HomPoint((this->*points)[i].x, 
186 | 				   (this->*points)[i].y));
187 |     return vec;
188 | }
189 | 


--------------------------------------------------------------------------------
/HeadTracker.cpp:
--------------------------------------------------------------------------------
  1 | #include "HeadTracker.h"
  2 | #include "FMatrixAffineCompute.cpp"
  3 | 
  4 | static double squarenorm(HomPoint point) {
  5 |     return square(point.x()) + square(point.y());
  6 | }
  7 | 
  8 | 
  9 | static double mean(vector<HomPoint> const& vec, 
 10 | 		   double (HomPoint::*func)() const) 
 11 | {
 12 |     double sum = 0.0;
 13 |     for(int i=0; i<vec.size(); i++)
 14 | 	sum += (vec[i].*func)();
 15 |     return sum / vec.size();
 16 | }
 17 | 
 18 | 
 19 | static void predict(double xorig, double yorig, 
 20 | 	     double a, double b, double c, double d, double depth,
 21 | 	     double &xnew, double &ynew) 
 22 | {
 23 |     double A =       - a*xorig - b*yorig;
 24 |     double B = depth - b*xorig + a*yorig;
 25 | 
 26 |     xnew = (c*A + d*B) / (d*d + c*c);
 27 |     ynew = (d*A - c*B) / (d*d + c*c);
 28 | }
 29 | 		 
 30 | 
 31 | static HomPoint 
 32 | predictpoint(HomPoint p, double depth, double dmeanx, double dmeany, 
 33 | 	     double rotx, double roty, double atx, double aty) 
 34 | { 
 35 |     HomPoint p2 (p.x() * atx - p.y() * aty,
 36 | 		 p.x() * aty + p.y() * atx);
 37 | 
 38 |     return HomPoint(p2.x() + roty * depth + dmeanx, 
 39 |  		    p2.y() - rotx * depth + dmeany);
 40 | }
 41 | 
 42 | vector<bool> HeadTracker::detectinliers(vector<HomPoint> const &prev, 
 43 | 					vector<HomPoint> const &now,
 44 | 					double radius)
 45 | {
 46 |     assert(prev.size() == now.size());
 47 | 
 48 |     vector<HomPoint> transitions;
 49 |     for(int i=0; i<prev.size(); i++)
 50 | 	transitions.push_back(now[i] - prev[i]);
 51 | 
 52 | //     cout << "xtrans:";
 53 | //     for(int i=0; i<prev.size(); i++)
 54 | // 	cout << " " << transitions[i].x();
 55 | //     cout << endl;
 56 | 
 57 | //     cout << "ytrans:";
 58 | //     for(int i=0; i<prev.size(); i++)
 59 | // 	cout << " " << transitions[i].y();
 60 | //     cout << endl;
 61 | 
 62 |     vector<int> closepoints(transitions.size());
 63 |     for(int i=0; i<transitions.size(); i++) {
 64 | 	closepoints[i] = 0;
 65 | 	for(int j=0; j<transitions.size(); j++)
 66 | 	    if (squarenorm(transitions[i] - transitions[j]) <= square(radius))
 67 | 		closepoints[i]++;
 68 |     }
 69 | 
 70 |     int maxindex = max_element(closepoints.begin(), closepoints.end()) 
 71 | 	- closepoints.begin();
 72 | 
 73 |     vector<bool> inliers(transitions.size());
 74 |     for(int i=0; i<transitions.size(); i++)
 75 | 	inliers[i] = (squarenorm(transitions[i] - transitions[maxindex]) 
 76 | 		      <= square(radius));
 77 | 
 78 |     for(int i=0; i<inliers.size(); i++)
 79 | 	if (!inliers[i]) {
 80 | 	    tracker.status[i] = false;
 81 |   	    tracker.currentpoints[i].x = 
 82 | 		0.9 * (tracker.origpoints[i].x + transitions[maxindex].x())
 83 | 		+ 0.1 * tracker.currentpoints[i].x;
 84 |   	    tracker.currentpoints[i].y = 
 85 | 		0.9 * (tracker.origpoints[i].y + transitions[maxindex].y())
 86 | 		+ 0.1 * tracker.currentpoints[i].y;
 87 | 	}
 88 | 
 89 |     return inliers;
 90 | }
 91 | 
 92 | 
 93 | void 
 94 | HeadTracker::predictpoints(double xx0, double yy0, double xx1, double yy1,
 95 | 			   double rotx, double roty, double atx, double aty) 
 96 | {
 97 |     double maxdiff = 0.0;
 98 |     int diffindex = -1;
 99 | 
100 |     vector<HomPoint> points = 
101 | 	tracker.getpoints(&PointTracker::origpoints, true);
102 | 
103 |     for(int i=0; i<points.size(); i++) {
104 | 	HomPoint p(points[i].x() - xx0, points[i].y() - yy0);
105 | 	HomPoint p1 = predictpoint(p, depths[i], xx1, yy1, 
106 | 				   rotx, roty, atx, aty);
107 | 	HomPoint p2 = predictpoint(p, -depths[i], xx1, yy1,
108 | 				   rotx, roty, atx, aty);
109 | 
110 | 	double diff1 = fabs(p1.x() - tracker.currentpoints[i].x) + 
111 | 	    fabs(p1.y() - tracker.currentpoints[i].y);
112 | 
113 | 	double diff2 = fabs(p2.x() - tracker.currentpoints[i].x) + 
114 | 	    fabs(p2.y() - tracker.currentpoints[i].y);
115 | 
116 | 	double diff = diff1 > diff2 ? diff2 : diff1;
117 | 
118 | 	// dubious code, I'm not sure about it
119 | 	if (!tracker.status[i]) {
120 | 	    tracker.currentpoints[i].x = 
121 | 		0.5 * tracker.currentpoints[i].x + 0.5 * p1.x();
122 | 	    tracker.currentpoints[i].y = 
123 | 		0.5 * tracker.currentpoints[i].y + 0.5 * p1.y();
124 | 	}
125 |     }
126 | }
127 | 
128 | void HeadTracker::updatetracker(void) {
129 |     depths.resize(tracker.pointcount());
130 |     detectinliers(tracker.getpoints(&PointTracker::origpoints, true), 
131 | 		  tracker.getpoints(&PointTracker::currentpoints, true));
132 | 
133 |     vector<HomPoint> origpoints = 
134 | 	tracker.getpoints(&PointTracker::origpoints, false);
135 |     vector<HomPoint> currentpoints = 
136 | 	tracker.getpoints(&PointTracker::currentpoints, false);
137 | 
138 |     double xx0 = mean(origpoints, &HomPoint::x);
139 |     double yy0 = mean(origpoints, &HomPoint::y);
140 |     double xx1 = mean(currentpoints, &HomPoint::x);
141 |     double yy1 = mean(currentpoints, &HomPoint::y);
142 | 
143 |     Vector fmatrix = computeAffineFMatrix(origpoints, currentpoints);
144 |     
145 |     double a = fmatrix[0];
146 |     double b = fmatrix[1];
147 |     double c = fmatrix[2];
148 |     double d = fmatrix[3];
149 |     double e = fmatrix[4];
150 | 
151 |     // compute the change
152 | 
153 |     vector<double> offsets(tracker.pointcount());
154 | 
155 |     double depthsum = 0.0001;
156 |     double offsetsum = 0.0001;
157 | 
158 |     for(int i=0; i<tracker.pointcount(); i++) 
159 | 	if (tracker.status[i]) {
160 | 	    double xorig = tracker.origpoints[i].x - xx0;
161 | 	    double yorig = tracker.origpoints[i].y - yy0;
162 | 	    double xnew = tracker.currentpoints[i].x - xx1;
163 | 	    double ynew = tracker.currentpoints[i].y - yy1;
164 | 	    double x0 = b*xorig - a*yorig;
165 | 	    double x1 = -d*xnew + c*ynew;
166 | 	    offsets[i] = x0 - x1;
167 | 	    offsetsum += offsets[i]*offsets[i];
168 | 	    depthsum += depths[i]*depths[i];
169 | 	}
170 |     
171 |     if (tracker.areallpointsactive()) {
172 | // 	cout << endl;
173 | 	depthsum = 1.0;
174 |     }
175 | 
176 |     double depthscale = sqrt(offsetsum / depthsum);
177 | 
178 |     rotx = c * depthscale / hypot(a,b) / hypot(c,d);
179 |     roty = d * depthscale / hypot(a,b) / hypot(c,d);
180 | 
181 |     atx = -(a*c + b*d) / (c*c + d*d); // at = AmpliTwist
182 |     aty = -(a*d - c*b) / (c*c + d*d); // at = AmpliTwist
183 | 
184 |     // depths
185 | 
186 |     vector<double> newdepths(tracker.pointcount());
187 | 
188 |     for(int i=0; i<tracker.pointcount(); i++) 
189 | 	if (tracker.status[i]) 
190 | 	    newdepths[i] = offsets[i] / depthscale;
191 | 
192 |     if (newdepths[1] > newdepths[2]) {
193 | 	rotx = -rotx;
194 | 	roty = -roty;
195 | 	for(int i=0; i<tracker.pointcount(); i++)
196 | 	    depths[i] = -newdepths[i];
197 |     }
198 |     else
199 | 	for(int i=0; i<tracker.pointcount(); i++)
200 | 	    depths[i] = newdepths[i];
201 | 	
202 | 
203 | //     // distance
204 | //     double distance1 = 0.0;
205 | //     double distance2 = 0.0;
206 | //     for(int i=0; i<tracker.pointcount; i++)
207 | // 	if (tracker.status[i]) {
208 | // 	    distance1 += square(depths[i] - newdepths[i]);
209 | // 	    distance2 += square(depths[i] + newdepths[i]);
210 | // 	}
211 | 
212 | //     for(int i=0; i<tracker.pointcount; i++) 
213 | // 	if (tracker.status[i])
214 | // 	    if (distance1 > distance2) {
215 | // 		rotx = -rotx;
216 | // 		roty = -roty;
217 | // 		depths[i] = -newdepths[i];
218 | // 	    }
219 | //             else
220 | // 		depths[i] = newdepths[i];
221 | 	
222 |     predictpoints(xx0, yy0, xx1, yy1,
223 |  		  rotx, roty, atx, aty);
224 | 
225 | }
226 | 
227 | void HeadTracker::draw(IplImage *image) {
228 | //     cout << "state: "<< rotx << " " << roty << " " 
229 | // 	 << atx << " " << aty << endl;
230 | 	
231 |     cvLine(image, 
232 | 	   cvPoint(320, 240),
233 | 	   cvPoint(320 + int(atx * 50), 240 + int(aty * 50)),
234 | 	   CV_RGB(255,255,255));
235 | 
236 | //     for(int i=0; i<tracker.pointcount; i++)
237 | // 	cvLine(image, 
238 | // 	       cvPoint(tracker.currentpoints[i].x, tracker.currentpoints[i].y),
239 | // 	       cvPoint(tracker.origpoints[i].x - xx0 + xx1, 
240 | // 		       tracker.origpoints[i].y - yy0 + yy1), 
241 | // 	       CV_RGB(255,0,0));
242 |     
243 |     for(int i=0; i<tracker.pointcount(); i++) {
244 | 	cvLine(image, 
245 | 	       cvPoint((int)tracker.currentpoints[i].x, 
246 | 		       (int)tracker.currentpoints[i].y),
247 | 	       cvPoint((int)tracker.currentpoints[i].x, 
248 | 		       int(tracker.currentpoints[i].y + depths[i] * 100)),
249 | 	       CV_RGB(0,0,255));
250 |     }
251 | 
252 |     double scale = 10;
253 | 
254 |     cvLine(image, 
255 | 	   cvPoint(320, 240),
256 | 	   cvPoint(320 + int(roty * scale), 240 + int(rotx * scale)),
257 | 	   CV_RGB(255,0,0));    
258 | }
259 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 		    GNU GENERAL PUBLIC LICENSE
  2 | 		       Version 2, June 1991
  3 | 
  4 |  Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
  5 |  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 | 			    Preamble
 10 | 
 11 |   The licenses for most software are designed to take away your
 12 | freedom to share and change it.  By contrast, the GNU General Public
 13 | License is intended to guarantee your freedom to share and change free
 14 | software--to make sure the software is free for all its users.  This
 15 | General Public License applies to most of the Free Software
 16 | Foundation's software and to any other program whose authors commit to
 17 | using it.  (Some other Free Software Foundation software is covered by
 18 | the GNU Lesser General Public License instead.)  You can apply it to
 19 | your programs, too.
 20 | 
 21 |   When we speak of free software, we are referring to freedom, not
 22 | price.  Our General Public Licenses are designed to make sure that you
 23 | have the freedom to distribute copies of free software (and charge for
 24 | this service if you wish), that you receive source code or can get it
 25 | if you want it, that you can change the software or use pieces of it
 26 | in new free programs; and that you know you can do these things.
 27 | 
 28 |   To protect your rights, we need to make restrictions that forbid
 29 | anyone to deny you these rights or to ask you to surrender the rights.
 30 | These restrictions translate to certain responsibilities for you if you
 31 | distribute copies of the software, or if you modify it.
 32 | 
 33 |   For example, if you distribute copies of such a program, whether
 34 | gratis or for a fee, you must give the recipients all the rights that
 35 | you have.  You must make sure that they, too, receive or can get the
 36 | source code.  And you must show them these terms so they know their
 37 | rights.
 38 | 
 39 |   We protect your rights with two steps: (1) copyright the software, and
 40 | (2) offer you this license which gives you legal permission to copy,
 41 | distribute and/or modify the software.
 42 | 
 43 |   Also, for each author's protection and ours, we want to make certain
 44 | that everyone understands that there is no warranty for this free
 45 | software.  If the software is modified by someone else and passed on, we
 46 | want its recipients to know that what they have is not the original, so
 47 | that any problems introduced by others will not reflect on the original
 48 | authors' reputations.
 49 | 
 50 |   Finally, any free program is threatened constantly by software
 51 | patents.  We wish to avoid the danger that redistributors of a free
 52 | program will individually obtain patent licenses, in effect making the
 53 | program proprietary.  To prevent this, we have made it clear that any
 54 | patent must be licensed for everyone's free use or not licensed at all.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 | 		    GNU GENERAL PUBLIC LICENSE
 60 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 61 | 
 62 |   0. This License applies to any program or other work which contains
 63 | a notice placed by the copyright holder saying it may be distributed
 64 | under the terms of this General Public License.  The "Program", below,
 65 | refers to any such program or work, and a "work based on the Program"
 66 | means either the Program or any derivative work under copyright law:
 67 | that is to say, a work containing the Program or a portion of it,
 68 | either verbatim or with modifications and/or translated into another
 69 | language.  (Hereinafter, translation is included without limitation in
 70 | the term "modification".)  Each licensee is addressed as "you".
 71 | 
 72 | Activities other than copying, distribution and modification are not
 73 | covered by this License; they are outside its scope.  The act of
 74 | running the Program is not restricted, and the output from the Program
 75 | is covered only if its contents constitute a work based on the
 76 | Program (independent of having been made by running the Program).
 77 | Whether that is true depends on what the Program does.
 78 | 
 79 |   1. You may copy and distribute verbatim copies of the Program's
 80 | source code as you receive it, in any medium, provided that you
 81 | conspicuously and appropriately publish on each copy an appropriate
 82 | copyright notice and disclaimer of warranty; keep intact all the
 83 | notices that refer to this License and to the absence of any warranty;
 84 | and give any other recipients of the Program a copy of this License
 85 | along with the Program.
 86 | 
 87 | You may charge a fee for the physical act of transferring a copy, and
 88 | you may at your option offer warranty protection in exchange for a fee.
 89 | 
 90 |   2. You may modify your copy or copies of the Program or any portion
 91 | of it, thus forming a work based on the Program, and copy and
 92 | distribute such modifications or work under the terms of Section 1
 93 | above, provided that you also meet all of these conditions:
 94 | 
 95 |     a) You must cause the modified files to carry prominent notices
 96 |     stating that you changed the files and the date of any change.
 97 | 
 98 |     b) You must cause any work that you distribute or publish, that in
 99 |     whole or in part contains or is derived from the Program or any
100 |     part thereof, to be licensed as a whole at no charge to all third
101 |     parties under the terms of this License.
102 | 
103 |     c) If the modified program normally reads commands interactively
104 |     when run, you must cause it, when started running for such
105 |     interactive use in the most ordinary way, to print or display an
106 |     announcement including an appropriate copyright notice and a
107 |     notice that there is no warranty (or else, saying that you provide
108 |     a warranty) and that users may redistribute the program under
109 |     these conditions, and telling the user how to view a copy of this
110 |     License.  (Exception: if the Program itself is interactive but
111 |     does not normally print such an announcement, your work based on
112 |     the Program is not required to print an announcement.)
113 | 
114 | These requirements apply to the modified work as a whole.  If
115 | identifiable sections of that work are not derived from the Program,
116 | and can be reasonably considered independent and separate works in
117 | themselves, then this License, and its terms, do not apply to those
118 | sections when you distribute them as separate works.  But when you
119 | distribute the same sections as part of a whole which is a work based
120 | on the Program, the distribution of the whole must be on the terms of
121 | this License, whose permissions for other licensees extend to the
122 | entire whole, and thus to each and every part regardless of who wrote it.
123 | 
124 | Thus, it is not the intent of this section to claim rights or contest
125 | your rights to work written entirely by you; rather, the intent is to
126 | exercise the right to control the distribution of derivative or
127 | collective works based on the Program.
128 | 
129 | In addition, mere aggregation of another work not based on the Program
130 | with the Program (or with a work based on the Program) on a volume of
131 | a storage or distribution medium does not bring the other work under
132 | the scope of this License.
133 | 
134 |   3. You may copy and distribute the Program (or a work based on it,
135 | under Section 2) in object code or executable form under the terms of
136 | Sections 1 and 2 above provided that you also do one of the following:
137 | 
138 |     a) Accompany it with the complete corresponding machine-readable
139 |     source code, which must be distributed under the terms of Sections
140 |     1 and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     b) Accompany it with a written offer, valid for at least three
143 |     years, to give any third party, for a charge no more than your
144 |     cost of physically performing source distribution, a complete
145 |     machine-readable copy of the corresponding source code, to be
146 |     distributed under the terms of Sections 1 and 2 above on a medium
147 |     customarily used for software interchange; or,
148 | 
149 |     c) Accompany it with the information you received as to the offer
150 |     to distribute corresponding source code.  (This alternative is
151 |     allowed only for noncommercial distribution and only if you
152 |     received the program in object code or executable form with such
153 |     an offer, in accord with Subsection b above.)
154 | 
155 | The source code for a work means the preferred form of the work for
156 | making modifications to it.  For an executable work, complete source
157 | code means all the source code for all modules it contains, plus any
158 | associated interface definition files, plus the scripts used to
159 | control compilation and installation of the executable.  However, as a
160 | special exception, the source code distributed need not include
161 | anything that is normally distributed (in either source or binary
162 | form) with the major components (compiler, kernel, and so on) of the
163 | operating system on which the executable runs, unless that component
164 | itself accompanies the executable.
165 | 
166 | If distribution of executable or object code is made by offering
167 | access to copy from a designated place, then offering equivalent
168 | access to copy the source code from the same place counts as
169 | distribution of the source code, even though third parties are not
170 | compelled to copy the source along with the object code.
171 | 
172 |   4. You may not copy, modify, sublicense, or distribute the Program
173 | except as expressly provided under this License.  Any attempt
174 | otherwise to copy, modify, sublicense or distribute the Program is
175 | void, and will automatically terminate your rights under this License.
176 | However, parties who have received copies, or rights, from you under
177 | this License will not have their licenses terminated so long as such
178 | parties remain in full compliance.
179 | 
180 |   5. You are not required to accept this License, since you have not
181 | signed it.  However, nothing else grants you permission to modify or
182 | distribute the Program or its derivative works.  These actions are
183 | prohibited by law if you do not accept this License.  Therefore, by
184 | modifying or distributing the Program (or any work based on the
185 | Program), you indicate your acceptance of this License to do so, and
186 | all its terms and conditions for copying, distributing or modifying
187 | the Program or works based on it.
188 | 
189 |   6. Each time you redistribute the Program (or any work based on the
190 | Program), the recipient automatically receives a license from the
191 | original licensor to copy, distribute or modify the Program subject to
192 | these terms and conditions.  You may not impose any further
193 | restrictions on the recipients' exercise of the rights granted herein.
194 | You are not responsible for enforcing compliance by third parties to
195 | this License.
196 | 
197 |   7. If, as a consequence of a court judgment or allegation of patent
198 | infringement or for any other reason (not limited to patent issues),
199 | conditions are imposed on you (whether by court order, agreement or
200 | otherwise) that contradict the conditions of this License, they do not
201 | excuse you from the conditions of this License.  If you cannot
202 | distribute so as to satisfy simultaneously your obligations under this
203 | License and any other pertinent obligations, then as a consequence you
204 | may not distribute the Program at all.  For example, if a patent
205 | license would not permit royalty-free redistribution of the Program by
206 | all those who receive copies directly or indirectly through you, then
207 | the only way you could satisfy both it and this License would be to
208 | refrain entirely from distribution of the Program.
209 | 
210 | If any portion of this section is held invalid or unenforceable under
211 | any particular circumstance, the balance of the section is intended to
212 | apply and the section as a whole is intended to apply in other
213 | circumstances.
214 | 
215 | It is not the purpose of this section to induce you to infringe any
216 | patents or other property right claims or to contest validity of any
217 | such claims; this section has the sole purpose of protecting the
218 | integrity of the free software distribution system, which is
219 | implemented by public license practices.  Many people have made
220 | generous contributions to the wide range of software distributed
221 | through that system in reliance on consistent application of that
222 | system; it is up to the author/donor to decide if he or she is willing
223 | to distribute software through any other system and a licensee cannot
224 | impose that choice.
225 | 
226 | This section is intended to make thoroughly clear what is believed to
227 | be a consequence of the rest of this License.
228 | 
229 |   8. If the distribution and/or use of the Program is restricted in
230 | certain countries either by patents or by copyrighted interfaces, the
231 | original copyright holder who places the Program under this License
232 | may add an explicit geographical distribution limitation excluding
233 | those countries, so that distribution is permitted only in or among
234 | countries not thus excluded.  In such case, this License incorporates
235 | the limitation as if written in the body of this License.
236 | 
237 |   9. The Free Software Foundation may publish revised and/or new versions
238 | of the General Public License from time to time.  Such new versions will
239 | be similar in spirit to the present version, but may differ in detail to
240 | address new problems or concerns.
241 | 
242 | Each version is given a distinguishing version number.  If the Program
243 | specifies a version number of this License which applies to it and "any
244 | later version", you have the option of following the terms and conditions
245 | either of that version or of any later version published by the Free
246 | Software Foundation.  If the Program does not specify a version number of
247 | this License, you may choose any version ever published by the Free Software
248 | Foundation.
249 | 
250 |   10. If you wish to incorporate parts of the Program into other free
251 | programs whose distribution conditions are different, write to the author
252 | to ask for permission.  For software which is copyrighted by the Free
253 | Software Foundation, write to the Free Software Foundation; we sometimes
254 | make exceptions for this.  Our decision will be guided by the two goals
255 | of preserving the free status of all derivatives of our free software and
256 | of promoting the sharing and reuse of software generally.
257 | 
258 | 			    NO WARRANTY
259 | 
260 |   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268 | REPAIR OR CORRECTION.
269 | 
270 |   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278 | POSSIBILITY OF SUCH DAMAGES.
279 | 
280 | 		     END OF TERMS AND CONDITIONS
281 | 
282 | 	    How to Apply These Terms to Your New Programs
283 | 
284 |   If you develop a new program, and you want it to be of the greatest
285 | possible use to the public, the best way to achieve this is to make it
286 | free software which everyone can redistribute and change under these terms.
287 | 
288 |   To do so, attach the following notices to the program.  It is safest
289 | to attach them to the start of each source file to most effectively
290 | convey the exclusion of warranty; and each file should have at least
291 | the "copyright" line and a pointer to where the full notice is found.
292 | 
293 |     <one line to give the program's name and a brief idea of what it does.>
294 |     Copyright (C) <year>  <name of author>
295 | 
296 |     This program is free software; you can redistribute it and/or modify
297 |     it under the terms of the GNU General Public License as published by
298 |     the Free Software Foundation; either version 2 of the License, or
299 |     (at your option) any later version.
300 | 
301 |     This program is distributed in the hope that it will be useful,
302 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
303 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
304 |     GNU General Public License for more details.
305 | 
306 |     You should have received a copy of the GNU General Public License along
307 |     with this program; if not, write to the Free Software Foundation, Inc.,
308 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309 | 
310 | Also add information on how to contact you by electronic and paper mail.
311 | 
312 | If the program is interactive, make it output a short notice like this
313 | when it starts in an interactive mode:
314 | 
315 |     Gnomovision version 69, Copyright (C) year name of author
316 |     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 |     This is free software, and you are welcome to redistribute it
318 |     under certain conditions; type `show c' for details.
319 | 
320 | The hypothetical commands `show w' and `show c' should show the appropriate
321 | parts of the General Public License.  Of course, the commands you use may
322 | be called something other than `show w' and `show c'; they could even be
323 | mouse-clicks or menu items--whatever suits your program.
324 | 
325 | You should also get your employer (if you work as a programmer) or your
326 | school, if any, to sign a "copyright disclaimer" for the program, if
327 | necessary.  Here is a sample; alter the names:
328 | 
329 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 |   `Gnomovision' (which makes passes at compilers) written by James Hacker.
331 | 
332 |   <signature of Ty Coon>, 1 April 1989
333 |   Ty Coon, President of Vice
334 | 
335 | This General Public License does not permit incorporating your program into
336 | proprietary programs.  If your program is a subroutine library, you may
337 | consider it more useful to permit linking proprietary applications with the
338 | library.  If this is what you want to do, use the GNU Lesser General
339 | Public License instead of this License.
340 | 


--------------------------------------------------------------------------------