public Record(string filenameWithoutExtention, IEyeTracker myEyeTracker)
{
this.filenameWithoutExtention = filenameWithoutExtention;
myEyetracker = myEyeTracker;
width = Screen.PrimaryScreen.Bounds.Width;
height = Screen.PrimaryScreen.Bounds.Height;
}
public CalibrationTobii(IEyeTracker eyeTracker, Configuration configuration, String calibrationMode)
{
InitializeComponent();
this.KeyPreview = true;
this.KeyDown += new KeyEventHandler(HandleEsc);
FormBorderStyle = FormBorderStyle.None;
mEyeTracker = eyeTracker;
mConfiguration = configuration;
combineEyeGaze = new combineEyes(mConfiguration);
oneEyeRight = new OneEyeRight(mConfiguration);
oneEyeLeft = new OneEyeLeft(mConfiguration);
mCalibrationMode = calibrationMode;
BufferedGraphicsContext context = BufferedGraphicsManager.Current;
bufferedGraphics = context.Allocate(this.CreateGraphics(), new Rectangle(0, 0, this.Width, this.Height));
Width = Screen.PrimaryScreen.Bounds.Width;
Height = Screen.PrimaryScreen.Bounds.Height;
FormBorderStyle = FormBorderStyle.None;
timer.Enabled = true;
// timer.Tick += new EventHandler(doCalibration);
timer.Interval = 40; // 40 images per second.
timer.Start();
}
private void CalibrateBtn_Click(object sender, EventArgs e)
{
try
{
//create calibration interface
NormalizedPoint2D[] pointsToCalibrate = new NormalizedPoint2D[] {
new NormalizedPoint2D(0.5f, 0.5f),
new NormalizedPoint2D(0.1f, 0.1f),
new NormalizedPoint2D(0.1f, 0.9f),
new NormalizedPoint2D(0.9f, 0.1f),
new NormalizedPoint2D(0.9f, 0.9f),
};
Form CalibrationForm = CreateCalibrationForm(pointsToCalibrate);
IEyeTracker SelectedTracker = AvailableTrackers.ElementAt(TrackerListComboBox.SelectedIndex);
CalibrationForm.KeyPress += (keySender, keyEvent) =>
{
if (keyEvent.KeyChar == ' ')
{
Calibrate(CalibrationForm, SelectedTracker);
}
};
CalibrationForm.Show();
}
catch (Exception exp)
{
//do nothing
Console.Write(exp);
}
}
internal static void Execute(IEyeTracker eyeTracker)
{
if (eyeTracker != null)
{
CallEyeTrackerManagerExample(eyeTracker);
}
}
public Task StartAsync(IDialogContext context)
{
message_count = 0;
EyeTrackerCollection ec = EyeTrackingOperations.FindAllEyeTrackers(); // もしくはGetEyeTracker で URI指定できるらしい
eyeTracker = null;
int i = ec.Count;
//Console.WriteLine(
System.Diagnostics.Debug.WriteLine("FindAllEyeTrackers()... {0} devices found.", i.ToString());
//label1.Text = i.ToString();
if (i > 0)
{
eyeTracker = ec[0];
}
//label2.Text = eyeTracker.Address.ToString();
//label2.Text = label2.Text + ", " + eyeTracker.DeviceName;
// return our reply to the user
if (eyeTracker != null)
{
ApplyLicense(eyeTracker, @"c:\tobii\license\license_key_00401181_-_Kyoto_University_IS404-100106332951");
GazeData(eyeTracker);
}
context.Wait(MessageReceivedAsync);
return(Task.CompletedTask);
}
public static void Execute(IEyeTracker eyeTracker, Form1 formObject)
{
if (eyeTracker != null)
{
GazeData(eyeTracker);
}
}
public MainWindow(ApplicationConfiguration configuration, IEyeTracker eyeTracker, ILogger logger, IEnumerable <IOverlay> overlays)
{
if (configuration is null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (eyeTracker is null)
{
throw new ArgumentNullException(nameof(eyeTracker));
}
if (logger is null)
{
throw new ArgumentNullException(nameof(logger));
}
if (overlays is null)
{
throw new ArgumentNullException(nameof(overlays));
}
_configuration = configuration;
_eyeTracker = eyeTracker;
_logger = logger;
_overlays = overlays;
_eyeTracker.EyePositionChanged += _eyeTracker_EyePositionChanged;
InitializeComponent();
}
private void ConnectToTracker(EyeTrackerInfo info)
{
try
{
_connectedTracker = info.Factory.CreateEyeTracker();
_connectedTracker.ConnectionError += HandleConnectionError;
_connectionName = info.ProductId;
_syncManager = info.Factory.CreateSyncManager(_clock);
_connectedTracker.GazeDataReceived += _connectedTracker_GazeDataReceived;
}
catch (EyeTrackerException ee)
{
if (ee.ErrorCode == 0x20000402)
{
MessageBox.Show("Failed to upgrade protocol. " +
"This probably means that the firmware needs" +
" to be upgraded to a version that supports the new sdk.", "Upgrade Failed", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else
{
MessageBox.Show("Eyetracker responded with error " + ee, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
DisconnectTracker();
}
catch (Exception)
{
MessageBox.Show("Could not connect to eyetracker.", "Connection Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
DisconnectTracker();
}
}
public Calibration RunCalibration(IEyeTracker tracker)
{
CreatePointList();
try
{
_tracker = tracker;
_tracker.ConnectionError += HandleConnectionError;
_tracker.ComputeCalibrationCompleted += ComputeCompleted;
_tracker.AddCalibrationPointCompleted += PointCompleted;
// Inform the eyetracker that we want to run a calibration
_tracker.StartCalibration();
_calibrationForm.ClearCalibrationPoint();
_calibrationForm.ShowDialog();
}
finally
{
// Inform the eyetracker that we have finished
// the calibration routine
_tracker.StopCalibration();
_tracker.ConnectionError -= HandleConnectionError;
_tracker.ComputeCalibrationCompleted -= ComputeCompleted;
_tracker.AddCalibrationPointCompleted -= PointCompleted;
_tracker = null;
}
return _calibrationResult;
}
public CalibrationWindow(IEyeTracker eyeTracker)
{
InitializeComponent();
this.KeyPreview = true;
this.KeyDown += new KeyEventHandler(HandleEsc);
calibrationBegin2 = 0;
mEyeTracker = eyeTracker;
//BackColor = Color.Black;
Width = Screen.PrimaryScreen.Bounds.Width;
Height = Screen.PrimaryScreen.Bounds.Height;
//FormBorderStyle = FormBorderStyle.None;
Timer refreshTimer = new Timer();
refreshTimer.Tick += new EventHandler(RefreshScreen);
refreshTimer.Interval = 33;
//refreshTimer.Start();
}
public Keyhole(Keys overlayKey)
{
m_overlayKey = overlayKey;
m_Ts = new ThreadStart(DrawLoop);
m_DrawThread = new Thread(m_Ts);
// setup eye tracker
m_EyeTracker = EyeTrackingOperations.FindAllEyeTrackers().FirstOrDefault();
m_EyeTracker.GazeDataReceived += GazeDataReceived;
// init gaze points
ScreenGaze = new ScreenGaze();
GazeTargets = new List <GazeTarget>();
Screen = System.Windows.Forms.Screen.PrimaryScreen.Bounds;
window = new Form1(this);
m_Active = false;
// keyboard / mouse
m_Events = Hook.GlobalEvents();
m_Events.KeyDown += OnKeyDown;
//m_Events.KeyUp += OnKeyUp;
//m_Events.KeyPress += HookManager_KeyPress;
m_Events.MouseMove += OnMouseMove;
m_DrawThread.Start();
}
private void InitializeEyeTrackerAndRunEventLoop()
{
if (State != EyeTrackingState.ConfigurationInitialized)
{
throw new InvalidOperationException("Can not initialize eye tracker and run event loop when not in state ConfigurationInitialized");
}
if (_eyeTracker == null)
{
try
{
_eyeTracker = new EyeTracker(_eyeTrackerUrl);
_eyeTracker.EyeTrackerError += OnEyeTrackerError;
_eyeTracker.GazeData += OnGazeData;
CreateAndRunEventLoopThread();
State = EyeTrackingState.EyeTrackerInitialized;
}
catch (EyeTrackerException)
{
State = EyeTrackingState.ConnectionFailed;
}
}
}
//############################################################################################
// <BeginExample>
private void GazeData(IEyeTracker eyeTracker)
{
eyetrackerFind = true;
/* if(mConfiguration.bothEyeAndHead || mConfiguration.bothEye)
* eyeTracker.GazeDataReceived += EyeTrackerBothEye_GazeDataReceived;
*
* else if (mConfiguration.leftEye || mConfiguration.leftEyeAndHead)
* eyeTracker.GazeDataReceived += EyeTrackerLeftEye_GazeDataReceived;
*
* else if (mConfiguration.rightEye || mConfiguration.rightEyeAndHead)
* eyeTracker.GazeDataReceived += EyeTrackerRightEye_GazeDataReceived;
*
* /* else
* {
* DialogResult result = MessageBox.Show("Cant Find any Eyetracker.\n Do you want To retry?",
* "Critical Warning",
* MessageBoxButtons.YesNo,
* MessageBoxIcon.Question,
* MessageBoxDefaultButton.Button2);
*
* if (result == DialogResult.Yes)
* {
* Execute();
* }
*
* if (result == DialogResult.No)
* {
* Console.WriteLine("Problem is in get Gaze Class");
* Application.Exit();
* }
* }*/
}
private void StartAutoConnectThread()
{
if (_autoConnectThread != null)
{
return;
}
_autoConnectThread = new Thread(() => {
AutoConnectThreadRunning = true;
while (AutoConnectThreadRunning)
{
var eyeTrackers = EyeTrackingOperations.FindAllEyeTrackers();
foreach (var eyeTrackerEntry in eyeTrackers)
{
if (eyeTrackerEntry.SerialNumber.StartsWith("VR"))
{
FoundEyeTracker = eyeTrackerEntry;
AutoConnectThreadRunning = false;
return;
}
}
Thread.Sleep(200);
}
});
_autoConnectThread.IsBackground = true;
_autoConnectThread.Start();
}
// Use this for initialization
void Awake()
{
if (_instance == null)
{
_instance = this;
bool result = false;
var trackers = EyeTrackingOperations.FindAllEyeTrackers();
EyeTrackerInstance = trackers.FirstOrDefault(s => (s.DeviceCapabilities & Capabilities.HasHMDGazeData) != 0);
if (EyeTrackerInstance == null)
{
result = false;
Debug.Log("No HMD eye tracker detected!");
}
else
{
result = true;
isEyeTrackerConnected = true;
Debug.Log("Selected eye tracker with serial number {0}" + EyeTrackerInstance.SerialNumber);
}
if (result == false)
{
Debug.LogError("TobiiPro: Failed to create tracker.");
}
}
}
public Calibration RunCalibration(IEyeTracker tracker, int _calib_flag)
{
CreatePointList(_calib_flag);
try
{
_tracker = tracker;
_tracker.ConnectionError += HandleConnectionError;
_tracker.ComputeCalibrationCompleted += ComputeCompleted;
_tracker.AddCalibrationPointCompleted += PointCompleted;
// Inform the eyetracker that we want to run a calibration
_tracker.StartCalibration();
_calibrationForm.ClearCalibrationPoint();
_calibrationForm.ShowDialog();
}
finally
{
// Inform the eyetracker that we have finished
// the calibration routine
_tracker.StopCalibration();
_tracker.ConnectionError -= HandleConnectionError;
_tracker.ComputeCalibrationCompleted -= ComputeCompleted;
_tracker.AddCalibrationPointCompleted -= PointCompleted;
_tracker = null;
}
return(_calibrationResult);
}
protected override void OnStartup(StartupEventArgs e)
{
try
{
var config = ApplicationConfiguration.FromJsonFile(_configFilename);
IEyeTracker eyeTracker = null;
switch (config.EyeTrackerName.ToUpper())
{
case "TOBII4C":
eyeTracker = new TobiiEyeTracker4C();
break;
default:
throw new NotImplementedException($"Eye tracker {config.EyeTrackerName} not supported");
}
var logger = new TextFileLogger();
App.Current.DispatcherUnhandledException += (sender, ev) =>
{
#if DEBUG
ev.Handled = true;
#endif
logger.Log(ev.Exception);
};
var overlays = new List <IOverlay>();
overlays.Add(new PositionOverlay());
var window = new MainWindow(config, eyeTracker, logger, overlays);
window.Show();
}
catch (Exception exception)
{
throw new StartupException("Initialization error", exception);
}
}
private static void ApplyLicense(IEyeTracker eyeTracker, string licensePath)
{
// Create a collection with the license.
var licenseCollection = new LicenseCollection(
new System.Collections.Generic.List <LicenseKey>
{
new LicenseKey(System.IO.File.ReadAllBytes(licensePath))
});
// See if we can apply the license.
FailedLicenseCollection failedLicenses;
if (eyeTracker.TryApplyLicenses(licenseCollection, out failedLicenses))
{
//Console.WriteLine(
System.Diagnostics.Debug.WriteLine("Successfully applied license from {0} on eye tracker with serial number {1}.",
licensePath, eyeTracker.SerialNumber);
}
else
{
//Console.WriteLine(
System.Diagnostics.Debug.WriteLine("Failed to apply license from {0} on eye tracker with serial number {1}.\n" +
"The validation result is {2}.",
licensePath, eyeTracker.SerialNumber, failedLicenses[0].ValidationResult);
}
}
public void SelectFromUxf()
{
var sessionSettingsDict = Session.instance.settings.GetDict("SessionSettings");
var tracker = (string)sessionSettingsDict["EyeTracker"];
switch (char.ToLower(tracker[0]))
{
case 'd':
ChosenTracker = _dummyEyeTracker;
selection = ETrackerSelection.Dummy;
break;
case 'p':
pupilEyeTracker.SetActive(true);
ChosenTracker = pupilEyeTracker.GetComponent <IEyeTracker>();
selection = ETrackerSelection.PupilLabs;
break;
case 'v':
viveProEye.SetActive(true);
ChosenTracker = viveProEye.GetComponent <IEyeTracker>();
selection = ETrackerSelection.ViveProEye;
break;
}
}
/// <summary>
/// Connects to Tobii Pro Eye-Tracker
/// </summary>
/// <returns>Connection Success Message</returns>
public override async Task <ApiResponseData> ConnectAsync()
{
IPAdress = "tet-tcp://" + Settings.Default.EyeTrackerIP + "/";
try
{
EyeTracker = EyeTrackingOperations.GetEyeTracker(IPAdress);
}
catch (Exception ex)
{
// Likely wrong URI Format
return(new ApiResponseData {
Message = ex.Message
});
}
if (EyeTracker != null)
{
// Connection established
Logger.Debug("Connected to " + EyeTracker.DeviceName + " width IP " + IPAdress);
Console.WriteLine("Connected to " + EyeTracker.DeviceName + " width IP " + IPAdress);
SubscribeToGazeDataAsync();
IsConnected = true;
return(new ApiResponseData {
Success = true
});
}
else
{
return(new ApiResponseData {
Message = "Unable to connect to EyeTracker with IP " + IPAdress
});
}
}
private void InitializeEyeTrackerAndRunEventLoop()
{
try
{
_eyeTrackerUrl = new EyeTrackerCoreLibrary().GetConnectedEyeTracker();
if (_eyeTrackerUrl == null)
{
return;
}
}
catch (EyeTrackerException)
{
return;
}
try
{
_eyeTracker = new EyeTracker(_eyeTrackerUrl);
_eyeTracker.EyeTrackerError += OnEyeTrackerError;
_eyeTracker.GazeData += OnGazeData;
CreateAndRunEventLoopThread();
_eyeTracker.ConnectAsync(OnConnectFinished);
}
catch (EyeTrackerException)
{
}
}
// <BeginExample>
internal static void GazeOutputFrequencies(IEyeTracker eyeTracker)
{
Console.WriteLine("\nGaze output frequencies.");
// Get and store current frequency so it can be restored.
var initialGazeOutputFrequency = eyeTracker.GetGazeOutputFrequency();
Console.WriteLine("Gaze output frequency is: {0} hertz.", initialGazeOutputFrequency);
try
{
// Get all gaze output frequencies.
var allGazeOutputFrequencies = eyeTracker.GetAllGazeOutputFrequencies();
foreach (var gazeOutputFrequency in allGazeOutputFrequencies)
{
if (gazeOutputFrequency < 110.0f)
{
initialGazeOutputFrequency = gazeOutputFrequency;
eyeTracker.SetGazeOutputFrequency(gazeOutputFrequency);
m_eyetrackerfrequency = gazeOutputFrequency;
}
//eyeTracker.SetGazeOutputFrequency(gazeOutputFrequency);
//Console.WriteLine("New gaze output frequency is: {0} hertz.", gazeOutputFrequency.ToString());
}
}
finally
{
eyeTracker.SetGazeOutputFrequency(initialGazeOutputFrequency);
Console.WriteLine("Gaze output frequency reset to: {0} hertz.", eyeTracker.GetGazeOutputFrequency());
}
}
private bool InitializeEyeTracker()
{
Uri url = new EyeTrackerCoreLibrary().GetConnectedEyeTracker();
if (url == null)
{
return(false);
}
_eyeTracker = new EyeTracker(url);
if (_eyeTracker == null)
{
return(false);
}
_eyeTracker.EyeTrackerError += OnEyeTrackerError;
_eyeTracker.GazeData += OnEyeTrackerGazeData;
_trackingThread = new Thread(new ThreadStart(EyeTrackerEventLoop));
_trackingThread.Start();
if (!_eyeTracker.Connected)
{
_eyeTracker.Connect();
_eyeTracker.StartTracking();
}
return(true);
}
public Calibration RunCalibration(IEyeTracker tracker)
{
CreatePointList();
try
{
_tracker = tracker;
_tracker.ConnectionError += HandleConnectionError;
_tracker.ComputeCalibrationCompleted += ComputeCompleted;
_tracker.AddCalibrationPointCompleted += PointCompleted;
_tracker.StartCalibration();
_calibrationWindow.ShowDialog();
}
finally
{
_tracker.StopCalibration();
_tracker.ConnectionError -= HandleConnectionError;
_tracker.ComputeCalibrationCompleted -= ComputeCompleted;
_tracker.AddCalibrationPointCompleted -= PointCompleted;
_tracker = null;
}
return(_calibrationResult);
}
private void _trackButton_Click(object sender, RoutedEventArgs e)
{
if (_tracking)
{
_tracker.GazeDataReceived -= _tracker_GazeDataReceived;
_tracker.StopTracking();
_tracker.Dispose();
_trackButton.Content = "Track";
_tracking = false;
}
else
{
EyeTrackerInfo etInfo = _trackerCombo.SelectedItem as EyeTrackerInfo;
if (etInfo != null)
{
_tracker = etInfo.Factory.CreateEyeTracker();
UpdateTrackBox();
UpdateScreen();
_tracker.StartTracking();
_tracker.GazeDataReceived += _tracker_GazeDataReceived;
_tracker.TrackBoxChanged += _tracker_TrackBoxChanged;
_tracker.XConfigurationChanged += _tracker_XConfigurationChanged;
_trackButton.Content = "Stop";
_tracking = true;
}
}
}
// internal methods
async void SearchEyeTrackers()
{
var collection = await EyeTrackingOperations.FindAllEyeTrackersAsync();
if (collection.Count > 0)
{
var tracker = collection[0];
try
{
_eyeTracker = EyeTrackingOperations.GetEyeTracker(tracker.Address);
}
catch (Exception ex)
{
Error(this, ex.Message);
}
if (_eyeTracker != null)
{
Ready(this, _eyeTracker.DeviceName);
}
}
else
{
Invoke(nameof(SearchEyeTrackers), 5);
}
}
/// <summary>
/// Constructor that creates and starts the calibration thread.
/// </summary>
public CalibrationThread(IEyeTracker eyeTracker, bool screenBased)
{
ScreenBased = screenBased;
EyeTrackerIF = eyeTracker;
_thread = new Thread(ThreadFunction);
_thread.IsBackground = true;
_thread.Start();
}
public void OnEnable()
{
_eyeTracker = eyeTrackerObject.ChosenTracker;
_cameraTransform = vrCamera.transform;
vrCamera.cullingMask = 1 << LayerMask.NameToLayer(debugSettings.gazeSpectatorOnly ? "Default" : "GazeSphere");
visual.SetActive(true);
}
public void Dispose()
{
if (_tracker != null)
{
_tracker.Dispose();
_tracker = null;
}
}
public void Close()
{
if (_eyeTracker != null)
{
_eyeTracker.Dispose();
_eyeTracker = null;
}
}
public IEnumerator StartTracking(IEyeTracker eyeTracker)
{
while (!eyesAreTracking)
{
yield return(new WaitForSeconds(0.1f));
}
StartCoroutine(Calibrate(eyeTracker));
}
public void Initialize()
{
Uri url = new EyeTrackerCoreLibrary().GetConnectedEyeTracker();
if (url == null)
{
throw new ApplicationException("No eye tracker found, check cable!");
}
else
{
tracker = new EyeTracker(url);
eventLoop = CreateAndRunEventLoopThread(tracker);
tracker.Connect();
}
}
private void browser_EyetrackerFound(object sender, EyeTrackerInfoEventArgs e)
{
// Finds an eye tracker and connects to it, and starts the tracking and calibration.
Debug.Log ("Found one");
tracker = e.EyeTrackerInfo.Factory.CreateEyeTracker(EventThreadingOptions.BackgroundThread);
Debug.Log ("Connected");
tracker.StartTracking();
tracker.GazeDataReceived += tracker_GazeDataReceived;
browser.StopBrowsing();
Debug.Log ("Ready");
tracker.StartCalibration ();
calibrating = true;
}
public Form1()
{
InitializeComponent();
// Get device info
IEyeTrackerInfo[] deviceInfos = EyeTracker.GetEyeTrackers();
IEyeTrackerInfo deviceInfo = deviceInfos.First();
// Connect to device
device = EyeTracker.Connect(deviceInfo);
// Create sensor
sensor = device.CreateSensor("", false);
sensor.Started += new SensorEventHandler(sensor_Started);
sensor.Stopped += new SensorEventHandler(sensor_Stopped);
sensor.DataAvailable += new DataAvailableHandler<Sample<EyeData>>(sensor_DataAvailable);
return;
}
private void ConnectToTracker(EyeTrackerInfo info)
{
try
{
_connectedTracker = info.Factory.CreateEyeTracker();
_connectedTracker.ConnectionError += HandleConnectionError;
_connectionName = info.ProductId;
_syncManager = info.Factory.CreateSyncManager(_clock);
_connectedTracker.GazeDataReceived += _connectedTracker_GazeDataReceived;
_connectedTracker.FrameRateChanged += _connectedTracker_FrameRateChanged;
}
catch (EyeTrackerException ee)
{
if(ee.ErrorCode == 0x20000402)
{
MessageBox.Show("Failed to upgrade protocol. " +
"This probably means that the firmware needs" +
" to be upgraded to a version that supports the new sdk.","Upgrade Failed",MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else
{
MessageBox.Show("Eyetracker responded with error " + ee, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
DisconnectTracker();
}
catch(Exception)
{
MessageBox.Show("Could not connect to eyetracker.","Connection Failed",MessageBoxButtons.OK,MessageBoxIcon.Error);
DisconnectTracker();
}
UpdateUIElements();
}
private void _trackButton_Click(object sender, RoutedEventArgs e)
{
if (_tracking)
{
_tracker.GazeDataReceived -= _tracker_GazeDataReceived;
_tracker.StopTracking();
_tracker.Dispose();
_trackButton.Content = "Track";
_tracking = false;
}
else
{
EyeTrackerInfo etInfo = _trackerCombo.SelectedItem as EyeTrackerInfo;
if (etInfo != null)
{
_tracker = etInfo.Factory.CreateEyeTracker();
_tracker.StartTracking();
_tracker.GazeDataReceived += _tracker_GazeDataReceived;
_trackButton.Content = "Stop";
_tracking = true;
}
}
}
void EyeTracker_EyeTrackerAdded(IEyeTracker eyeTracker)
{
if (EyeTrackerAdded != null)
EyeTrackerAdded(eyeTracker);
}
private Thread CreateAndRunEventLoopThread(IEyeTracker tracker)
{
var thread = new Thread(() =>
{
try
{
tracker.RunEventLoop();
}
catch (EyeTrackerException ex)
{
Debug.WriteLine("An error occurred in the eye tracker event loop: " + ex.Message);
}
Debug.WriteLine("Leaving the event loop.");
});
thread.Start();
return thread;
}
private void _trackButton_Click(object sender, RoutedEventArgs e)
{
if (_tracking)
{
_tracker.GazeDataReceived -= _tracker_GazeDataReceived;
_tracker.StopTracking();
_tracker.Dispose();
_trackButton.Content = "Track";
_tracking = false;
}
else
{
EyeTrackerInfo etInfo = _trackerCombo.SelectedItem as EyeTrackerInfo;
if (etInfo != null)
{
_tracker = etInfo.Factory.CreateEyeTracker();
//UpdateTrackBox();
//UpdateScreen();
_tracker.StartTracking();
_tracker.GazeDataReceived += _tracker_GazeDataReceived;
//_tracker.TrackBoxChanged += _tracker_TrackBoxChanged;
_trackButton.Content = "Stop";
_tracking = true;
}
}
var doc = Browser.Document as mshtml.HTMLDocument;
if (doc != null)
{
IHTMLStyleSheet style = doc.createStyleSheet("", 0);
style.cssText = @"body { cursor: none; } a, > a, a:-webkit-any-link { cursor: none !important; } a:hover { cursor: none !important; } ";
}
}
public IEyeSensor CreateEyeSensor(IEyeTracker eyeTracker)
{
return CreateEyeSensor("Eye", eyeTracker, false);
}
private void DisconnectTracker()
{
if(_connectedTracker != null)
{
_connectedTracker.GazeDataReceived -= _connectedTracker_GazeDataReceived;
_connectedTracker.Dispose();
_connectedTracker = null;
_connectionName = string.Empty;
_isTracking = false;
_syncManager.Dispose();
}
}
/// <summary>
/// Stop eye tracking and dispose eye tracking engine and Tobii EyeTracking
/// </summary>
public void Dispose()
{
if (_eyeTracker != null)
{
_eyeTracker.BreakEventLoop();
if (_thread != null)
{
_thread.Join();
}
_eyeTracker.EyeTrackerError -= OnEyeTrackerError;
_eyeTracker.GazeData -= OnGazeData;
_eyeTracker.Dispose();
_eyeTracker = null;
}
if (_thread != null)
{
_thread.Abort();
_thread = null;
}
}
public IEyeSensor CreateEyeSensor(String sensorName_, IEyeTracker eyeTracker)
{
return CreateEyeSensor(sensorName_, eyeTracker, false);
}
private void InitializeEyeTrackerAndRunEventLoop()
{
try
{
_eyeTrackerUrl = new EyeTrackerCoreLibrary().GetConnectedEyeTracker();
if (_eyeTrackerUrl == null)
{
return;
}
}
catch (EyeTrackerException)
{
return;
}
try
{
_eyeTracker = new EyeTracker(_eyeTrackerUrl);
_eyeTracker.EyeTrackerError += OnEyeTrackerError;
_eyeTracker.GazeData += OnGazeData;
CreateAndRunEventLoopThread();
_eyeTracker.ConnectAsync(OnConnectFinished);
}
catch (EyeTrackerException)
{
}
}
public IEyeSensor CreateEyeSensor(String sensorName_, IEyeTracker eyeTracker, bool queueData)
{
EyeSensor eyeSensor = new EyeSensor(new EyeSensor.Processor(), new EyeSensor.Input(eyeTracker), sensorName_, eyeTracker, queueData);
eyeSensors.Add(eyeSensor);
return eyeSensor;
}
void EyeTracker_EyeTrackerRemoved(IEyeTracker eyeTracker)
{
if (EyeTrackerRemoved != null)
EyeTrackerRemoved(eyeTracker);
}
void browser_EyeTrackerFound(object sender, EyeTrackerInfoEventArgs e)
{
EyeTrackerInfo temp_etinfo = e.EyeTrackerInfo;
if (temp_etinfo.Status == "ok")
{
etid = temp_etinfo.ProductId;
et = e.EyeTrackerInfo.Factory.CreateEyeTracker(EventThreadingOptions.BackgroundThread);
//Setup event handlers for this tracker.
et.CalibrationStarted += et_CalibrationStarted;
et.CalibrationStopped += et_CalibrationStopped;
et.ConnectionError += et_ConnectionError;
et.GazeDataReceived += et_GazeDataRecieved;
if (enabled)
{
et.StartTracking();
}
}
}
void et_ConnectionError(object sender, ConnectionErrorEventArgs e)
{
et.Dispose();
et = null;
}
