GazeTK

var net = require('net');

var ws = require("nodejs-websocket");

var HOST = '127.0.0.1';

var PORT = 6555;

var connected = false;

var client = new net.Socket();

var connectionManager = [];

var connectionId = 0;

var websocket_server = null;

var eyeTracker = "";

if (process.argv.length == 2) {

	console.log("Start the server with --tracker=smi or --tracker=mygaze or --tracker=eyetribe");

	process.exit();

} else if (process.argv.length > 2) {

	process.argv.forEach(function(val, index, array) {

		if (val.indexOf("tracker") > -1) {

			eyeTracker = val.split("=")[1];

		}

	});

}

if (eyeTracker == "" || eyeTracker == undefined) {

	console.log("tracker was not set - exiting.");

	process.exit();

}

console.log("Tracker is " + eyeTracker);

function createServer() {

	websocket_server = ws.createServer(function(conn) {

		conn.on("text", function(str) {

			var senderID;

			for (var c in connectionManager) {

				//console.log(c+"{__}"+position);

				if (conn == connectionManager[c].conn) {

					senderID = connectionManager[c].id;

				}

			}

			console.log("Message from connection with id:" + senderID + " : \"" + str + "\"");

			if (str.indexOf("TYPE") > -1) {

				console.log("typestring: " + str);

				var clientType = str.split(':');

				//connectionManager[connectionId] = new Array();

				console.log("type = " + clientType[1]);

				for (var c in connectionManager) {

					//console.log("Sending SMI Data: "+str);

					if (connectionManager[c]['conn'] == conn) {

						connectionManager[c]['type'] = clientType[1];

					}

				}

			}

			if (eyeTracker == "smi") {

				try {

					for (var c in connectionManager) {

						console.log("Sending SMI Data: " + str);

						if (connectionManager[c]['type'] == "browser") {

							connectionManager[c]['conn'].sendText(str);

						}

					}

				} catch (err) {

					console.log("error in websocketserver: ");

					console.log("error at line:" + err.lineNumber);

					console.log("error:" + err);

					console.log("error at message:" + data);

					console.log("trying to establish new connection");

					createServer();

				}

			}

			if (eyeTracker == "mygaze") {

				try {

					for (var c in connectionManager) {

						console.log("Sending myGaze Data: " + str);

						if (connectionManager[c]['type'] == "browser") {

							connectionManager[c]['conn'].sendText(str);

						}

					}

				} catch (err) {

					console.log("error in websocketserver: ");

					console.log("error at line:" + err.lineNumber);

					console.log("error:" + err);

					console.log("error at message:" + data);

					console.log("trying to establish new connection");

					createServer();

				}

			}

			if (eyeTracker == "eyetribe") {

				//send the message from the browser directly to the eyetracker

				client.write(str);

			}

		});

			conn.on('error', function(er) {

  // The error won't crash the process, but what it does is worse!

  // Though we've prevented abrupt process restarting, we are leaking

  // resources like crazy if this ever happens.

  // This is no better than process.on('uncaughtException')!

  console.log(eyeTracker +" disconnected. ERRORMESSAGE: ", er.message);

});

		conn.on("close", function(code, reason) {

			for (var c in connectionManager) {

				//console.log(c+"{__}"+position);

				if (conn == connectionManager[c].conn) {

					console.log("connection '" + c + "' disconnected.");

					delete connectionManager[c];

				}

			}

		});

	}).listen(6777);

	websocket_server.on("connection", function(conn) {

		connectionManager[connectionId] = [];

		connectionManager[connectionId].conn = conn;

		connectionManager[connectionId].id = connectionId;

		console.log("A new client connected with id: " + connectionId);

		connectionId++;

	});

}

if (eyeTracker == "eyetribe") {

	//Heartbeat timer

	setInterval(function() {

		if (connected) {

			sendHeartbeat(client);

		}

	}, 250);

	client.connect(PORT, HOST, function() {

		console.log('Websocket connected successfully to tcp server(EyeTracker): ' + HOST + ':' + PORT);

		connected = true;

		//check the eyetracker status

		//client.write('{"category": "tracker","request": "get","values": ["push", "iscalibrated" ]}');

		//client.write('{"category": "tracker","request": "set","values": {"push": true,"version": 1}}');

		//client.write('{"category": "tracker","request" : "get","values": [ "push", "iscalibrated" ]}');

	});

} else if (eyeTracker == "smi") {

	console.log('Waiting for messages from SMI EyeTracker on 127.0.0.1:6777');

} else if (eyeTracker == "mygaze") {

	console.log('Waiting for messages from myGaze EyeTracker on 127.0.0.1:6777');

}

//as soon as the websocket receives any data from the eyetracker it is forwarded to the browser

client.on('data', function(data) {

	try {

		for (var c in connectionManager) {

			console.log("Sending EyeTrackingData to Browser: "+data);

			connectionManager[c]['conn'].sendText(data);

		}

	} catch (err) {

		console.log("error in websocketserver: ");

		console.log("error at line:" + err.lineNumber);

		console.log("error:" + err);

		console.log("error at message:" + data);

		console.log("trying to establish new connection");

		createServer();

	}

	// Close the client socket completely

	//client.destroy();    

});

// Add a 'close' event handler for the client socket

client.on('close', function() {

	connected = false;

	console.log('EyeTracker Disconnected.');

	createServer();

});

function sendHeartbeat(socket) {

	socket.write("{\"category\":\"heartbeat\",\"request\":null}");

	//console.log('Heartbeat sent.');	

}

try {

	createServer();

} catch (err) {

	console.log("error in websocketserver: ");

	console.log("error at line:" + err.lineNumber);

	console.log("error:" + err);

	console.log("error at message:" + data);

	console.log("trying to establish new connection");

	createServer();

}

#

# DeviceServer_MyGaze.py

# 

# This file is part of GazeTk.

#

# Copyright 2015 Thies Pfeiffer and Dimitri Heil

# GazeTk is distributed under the terms of the GNU General Public License

# 

# GazeTk is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

# 

# GazeTk is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with GazeTk. If not, see <http://www.gnu.org/licenses/>.

#

from myGazeAPI import  *            			# myGaze library

from websocket import create_connection

ws = create_connection("ws://127.0.0.1:6777")

print "sending: Hi, this is the python server"

ws.send("TYPE:mygaze");

ws.send("Hi, this is the mygaze python server")

print "sent."

# ---------------------------------------------------------------------------- 

# ---- connect to myGazeAPI eyetracking-server 

# ---------------------------------------------------------------------------- 

res = myGazeAPI.iV_Connect()

if res != 1:

    print "Could not connect " + str(res) 

    exit(0)

# ---------------------------------------------------------------------------- 

# ---- read out system information 

# ---------------------------------------------------------------------------- 

res = myGazeAPI.iV_GetSystemInfo(byref(systemData))

print "myGaze eyetracking-server Version: " + str(systemData.iV_MajorVersion) + "." + str(systemData.iV_MinorVersion) + "." + str(systemData.iV_Buildnumber)

print "myGaze API Version: " + str(systemData.API_MajorVersion) + "." + str(systemData.API_MinorVersion) + "." + str(systemData.API_Buildnumber)

# ---------------------------------------------------------------------------- 

# ---- start the calibration and validation process 

# ---------------------------------------------------------------------------- 

# see the User Manual for detailed information due to setting up calibration 

calibrationData = CCalibration(5, 1, 0, 0, 1, 250, 220, 2, 20, b"")

res = myGazeAPI.iV_SetupCalibration(byref(calibrationData))

print "iV_SetupCalibration " + str(res)

# start the calibration process 

res = myGazeAPI.iV_Calibrate()

print "iV_Calibrate " + str(res)

# start the validation process 

res = myGazeAPI.iV_Validate()

print "iV_Validate " + str(res)

# read out the accuracy values 

res = myGazeAPI.iV_GetAccuracy(byref(accuracyData))

print "iV_GetAccuracy " + str(res)

print "accuracy left X: " + str(accuracyData.deviationLX) + " left Y: " + str(accuracyData.deviationLY)

print "accuracy right X: " + str(accuracyData.deviationRX) + " left Y: " + str(accuracyData.deviationRY)

# show tracking monitor 

res = myGazeAPI.iV_ShowTrackingMonitor()

print "iV_ShowTrackingMonitor " + str(res)

# ---------------------------------------------------------------------------- 

# ---- accessing eye tracking data stream 

# ---------------------------------------------------------------------------- 

# output samples

a = 0;

while a < 1000:

    # get gaze data sample

    res = myGazeAPI.iV_GetSample(byref(sampleData))

    if res == 1:

       # a = a + 1

        #print "Gaze Data - GazeX: " + str(sampleData.leftEye.gazeX) + " GazeY: " + str(sampleData.leftEye.gazeY) 

        ws.send("{\"x\":"+str(sampleData.leftEye.gazeX)+",\"y\":"+str(sampleData.leftEye.gazeY)+"}")

        #ws.send("{\"x\":"+str(sampleData.rightEye.gazeX)+",\"y\":"+str(sampleData.rightEye.gazeY)+"}")

    # get gaze data sample

    res = myGazeAPI.iV_GetEvent(byref(eventData))

    #if res == 1:

        #print "Fixation " + str(eventData.eye) + " - X: " + str(eventData.positionX) + " Y: " + str(eventData.positionY) 

# ---------------------------------------------------------------------------- 

# ---- disconnect from myGaze eyetracking server 

# ---------------------------------------------------------------------------- 

res = myGazeAPI.iV_Disconnect()

ws.close()

#end of the trial 

#window.close()

#core.quit()

DeviceServer_MyGaze

===================

[Download](https://opensource.cit-ec.de/projects/gazetk/repository/gazetk)

License

-------

DeviceServer_MyGaze is free and open source software distributed under the terms of the [GNU General Public License](http://www.gnu.org/licenses/).

Description

-----------

Welcome to DeviceServer_MyGaze!

This python-based server connects your MyGaze eye tracking device with the GazeTk DesktopConnector. 

Requirements

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

- Python 2.7 32bit

- Python module websocket

Installation

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

1. Install Python 2.7 32bit

2. Install websocket-client by running the following script from PYTHONDIR/Scripts:

$ pip install websocket-client

Starting DeviceServer_MyGaze

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

1. Start the myGaze application provided with the device.

2. Make sure you have the myGazeAPI.dll on your PATH, they come with the MyGaze installation package.

3. Start the DeviceServer_MyGaze:

$ python DeviceServer_MyGaze.py

# myGazeAPI.py 

#

# (C) Copyright 2013, Visual Interaction GmbH 

# All rights reserved. This work contains unpublished proprietary 

# information of Visual Interaction GmbH and is copy protected by law. 

# (see accompanying file eula.pdf)

#

# Author: Visual Interaction GmbH 

# November, 2012 

from ctypes import *

# ---------------------------------------------------------------------------- 

# ---- Struct Definitions 

# ---- (for detailed information due to the data  

# ---- structuresplease refer to the myGaze SDK Manual) 

# ---------------------------------------------------------------------------- 

class CSystem(Structure):

	_fields_ = [("samplerate", c_int),

	("iV_MajorVersion", c_int),

	("iV_MinorVersion", c_int),

	("iV_Buildnumber", c_int),

	("API_MajorVersion", c_int),

	("API_MinorVersion", c_int),

	("API_Buildnumber", c_int),

	("iV_ETDevice", c_int)]

class CCalibrationPoint(Structure):

	_fields_ = [("number", c_int),

	("positionX", c_int),

	("positionY", c_int)]

class CEye(Structure):

	_fields_ = [("gazeX", c_double),

	("gazeY", c_double),

	("diam", c_double),

	("eyePositionX", c_double),

	("eyePositionY", c_double),

	("eyePositionZ", c_double)]

class CSample(Structure):

	_fields_ = [("timestamp", c_longlong),

	("leftEye", CEye),

	("rightEye", CEye)]

class CEvent(Structure):

	_fields_ = [("eventType", c_char),

	("eye", c_char),

	("startTime", c_longlong),

	("endTime", c_longlong),

	("duration", c_longlong),

	("positionX", c_double),

	("positionY", c_double)]

class CAccuracy(Structure):

	_fields_ = [("deviationLX", c_double),

	("deviationLY", c_double),

	("deviationRX", c_double),

	("deviationRY", c_double)]

class CCalibration(Structure):

	_fields_ = [("method", c_int),

	("visualization", c_int),

	("displayDevice", c_int),

	("speed", c_int),

	("autoAccept", c_int),

	("foregroundBrightness", c_int),

	("backgroundBrightness", c_int),

	("targetShape", c_int),

	("targetSize", c_int),

	("targetFilename", c_char * 256)]

class CMonitorAttachedGeometry(Structure):

	_fields_ = [("setupName", c_char * 256),

	("stimX", c_int),

	("stimY", c_int),

	("redStimDistHeight", c_int),

	("redStimDistDepth", c_int),

	("redInclAngle", c_int)]

class CImage(Structure):

	_fields_ = [("imageHeight", c_int),

	("imageWidth", c_int),

	("imageSize", c_int),

	("imageBuffer", c_char)]

class CDate(Structure):

	_fields_ = [("day", c_int),

	("month", c_int),

	("year", c_int)]

# ---------------------------------------------------------------------------- 

# ---- loading myGazeAPI.dll 

# ---------------------------------------------------------------------------- 

myGazeAPI = windll.LoadLibrary("myGazeAPI.dll")

# ---------------------------------------------------------------------------- 

# ---- initializing structs

# ---------------------------------------------------------------------------- 

systemData = CSystem(0, 0, 0, 0, 0, 0, 0, 0)

leftEye = CEye(0, 0, 0, 0, 0, 0)

rightEye = CEye(0, 0, 0, 0, 0, 0)

sampleData = CSample(0, leftEye, rightEye)

eventData = CEvent('F', 'L', 0, 0, 0, 0, 0)

accuracyData = CAccuracy(0,0,0,0)

calibrationData = CCalibration(5, 1, 0, 0, 1, 20, 239, 1, 15, b"")

geometry = CMonitorAttachedGeometry(b"DefaultSetup", 474, 296, 0, 35, 20);

# myGazeAPIReturnCodes.py 

#

# (C) Copyright 2013, Visual Interaction GmbH 

# All rights reserved. This work contains unpublished proprietary 

# information of Visual Interaction GmbH and is copy protected by law. 

# (see accompanying file eula.pdf)

#

# Author: Visual Interaction GmbH 

# March, 2012 

def HandleError(ret):

	switch(ret)

	{

	case 1: 

		break;

	case 2: 

		print "not valid data."

		break;

	case 3: 

		print "Calibration/validation aborted."

		break;

	case 4: 

		print "Server is already running."

		break;

	case 100: 

		print "Connection is not established."

		break;

	case 101: 

		print "Could not establish connection."

		break;

	case 102: 

		print "System is not calibrated."

		break;

	case 103: 

		print "System is not validated."

		break;

	case 104: 

		print "Could not establish connection. Check if Eye Tracker is running."

		break;

	case 112: 

		print "Invalid parameter."

		break;

	case 113: 

		print "Calibration method is not supported."

		break;

	case 114: 

		print "Timeout during calibration."

		break;

	case 115: 

		print "tracking is not stable."

		break;

	case 121: 

		print "Communication problem."

		break;

	case 122: 

		print "Communication problem."

		break;

	case 123: 

		print "Could not establish connection. Another Process is blocking the communication Ports."

		break; 

	case 124: 

		print "Communication problem."

		break;

	case 131: 

		print "Server is not responding."

		break;

	case 132: 

		print "Invalid server version."

		break;

	case 133: 

		print "Wrong server version."

		break;

	case 171: 

		print "File access error."

		break;

	case 181: 

		print "Socket connection error."

		break;

	case 194: 

		print "Server is not ready."

		break;

	case 201: 

		print "Could not establish connection. Check if Eye Tracker is installed and running."

		break;

	case 202: 

		print "Server path not found."

		break;

	case 203: 

		print "Server access denied."

		break;

	case 204: 

		print "Server access error."

		break;

	case 205: 

		print "Server out of memory."

		break;

	case 211: 

		print "Camera not found."

		break;

	case 212: 

		print "Wrong camera."

		break;

	case 213: 

		print "Wrong camera port."

		break;

	case 220: 

		print "Could not open port."

		break;

	case 221: 

		print "Could not close port."

		break;

	case 250: 

		print "Feature not licensed."

		break;

	}

return 

python DeviceServer_MyGaze.py

pause

DesktopConnector

================

[Download](https://opensource.cit-ec.de/projects/gazetk/repository/gazetk)

License

-------

DesktopConnector is free and open source software distributed under the terms of the [GNU General Public License](http://www.gnu.org/licenses/).

Description

-----------

Welcome to DesktopConnector!

DesktopConnector is the bridge between your remote desktop eye tracking device and gaze-enabled applications.

At the moment, DesktopConnector is written in Node.js. It consists of a basic server, which provides the interface to the application, and different DeviceConnectors for certain types of remote eye tracking systems.

Requirements

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

* Node.js

* One of the supported eye tracking systems

** Eyetribe

** MyGaze

** SMI REDm

Installation

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

1. Install Node.js

2. Install the Node.js module nodejs-websocket

$ npm install nodejs-websocket

Starting DesktopConnector

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

1. Use the corresponding bat-file to start the DeviceConnector confiured for your eye tracking device, or start

$ node DesktopConnector.js --tracker=XXX

with XXX standing for smi, eyetribe or mygaze, which are the eye tracking systems that are currently supported.

2. If you are using SMI REDm or MyGaze, you will need to start an additional DeviceServer. You can find them in the subdirectories.

node DesktopConnector.js --tracker=eyetribe

node DesktopConnector.js --tracker=mygaze

pause

node DesktopConnector.js --tracker=smi

GazeTk

======

[Download](https://opensource.cit-ec.de/projects/gazetk/repository/gazetk)

License

-------

GazeTk is free and open source software distributed under the terms of the [GNU General Public License](http://www.gnu.org/licenses/).

Description

-----------

Welcome to GazeTk!

Subprojects

-----------

* **DesktopConnector** provides connectivity to many different remote desktop eye tracking systems.