private void OnNewIPAValueAvailable(object sender, GazeDataEventArgs e)
{
IPALogger.Log(e.RawIPA.ToString("F4"), e.NormalizedIPA.ToString("F4"), e.SmoothIPA.ToString("F4"));
//Do not use debug logger here because of multi-threading.
//DebugLogger.Log(e.RawIPA.ToString("F4"), e.NormalizedIPA.ToString("F4"), e.SmoothIPA.ToString("F4"));
}
// This method will be called on a thread belonging to the SDK, and can not safely change values
// that will be read from the main thread.
private void EnqueueEyeData(object sender, GazeDataEventArgs e)
{
lock (_queue)
{
_queue.Enqueue(e);
}
}
/// <summary>
/// Writes (X, Y) coordinate of gaze point to console if CPU and eyetracker clocks are synchronized.
///
/// Detailed explanation of synchronization available in Tobii SDK 3.0 Developer Guide.
/// http://www.tobii.com/Global/Analysis/Downloads/User_Manuals_and_Guides/Tobii%20SDK%203.0%20Release%20Candidate%201%20Developers%20Guide.pdf
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public override void GazeDataReceived(object sender, GazeDataEventArgs e)
{
if (syncManager.SyncState.StateFlag == SyncStateFlag.Synchronized)
{
Console.WriteLine("GazeData - (" + e.GazeDataItem.LeftEyePosition3D.X + ", " + e.GazeDataItem.LeftEyePosition3D.Y + ")");
}
}
/// <summary>
/// Ensures synchronization before handling receive gaze data
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Contains the gaze data item</param>
public override sealed void GazeDataReceived(object sender, GazeDataEventArgs e)
{
if (syncManager.SyncState.StateFlag == SyncStateFlag.Synchronized)
{
GazeDataReceivedSynchronized(sender, e.GazeDataItem);
}
}
public static double CalculateVelocity(GazeDataEventArgs prevGaze, GazeDataEventArgs currentGaze, String option)
{
double velocity = 0;
if (prevGaze == null)
{
return(velocity);
}
double visualAngleDegrees = 0;
if (option.Equals("Average"))
{
Point3D prevAveragePoint3D = GetAveragePoint(prevGaze);
Point3D currentAveragePoint3D = GetAveragePoint(currentGaze);
visualAngleDegrees = GetVisualAngle(prevAveragePoint3D, currentAveragePoint3D);
Console.Write("------ Visual angle ");
Console.WriteLine(visualAngleDegrees);
}
double durationSeconds = (currentGaze.DeviceTimeStamp - prevGaze.DeviceTimeStamp) / 1000000d;
if (durationSeconds > 0d)
{
velocity = visualAngleDegrees / durationSeconds;
}
return(velocity);
}
/// <summary>
/// Writes (X, Y) coordinate of gaze point to console if CPU and eyetracker clocks are synchronized.
///
/// Detailed explanation of synchronization available in Tobii SDK 3.0 Developer Guide.
/// http://www.tobii.com/Global/Analysis/Downloads/User_Manuals_and_Guides/Tobii%20SDK%203.0%20Release%20Candidate%201%20Developers%20Guide.pdf
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public override void GazeDataReceived(object sender, GazeDataEventArgs e)
{
if (syncManager.SyncState.StateFlag == SyncStateFlag.Synchronized)
{
Console.WriteLine("GazeData - (" + e.GazeDataItem.LeftEyePosition3D.X + ", " + e.GazeDataItem.LeftEyePosition3D.Y + ")");
}
}
private void OnEyeTrackerGazeData(object sender, GazeDataEventArgs e)
{
EventHandler <GazeEventArgs> handler = GazeEvent;
if (handler != null)
{
Point2D gazePoint;
var gazeData = e.GazeData;
switch (gazeData.TrackingStatus)
{
case TrackingStatus.BothEyesTracked:
gazePoint = new Point2D((gazeData.Left.GazePointOnDisplayNormalized.X + gazeData.Right.GazePointOnDisplayNormalized.X) / 2.0,
(gazeData.Left.GazePointOnDisplayNormalized.Y + gazeData.Right.GazePointOnDisplayNormalized.Y) / 2.0);
break;
case TrackingStatus.OnlyLeftEyeTracked:
case TrackingStatus.OneEyeTrackedProbablyLeft:
gazePoint = gazeData.Left.GazePointOnDisplayNormalized;
break;
case TrackingStatus.OnlyRightEyeTracked:
case TrackingStatus.OneEyeTrackedProbablyRight:
gazePoint = gazeData.Right.GazePointOnDisplayNormalized;
break;
default:
return;
}
GazeEventArgs gazeEventArgs = new GazeEventArgs(gazePoint.X, gazePoint.Y, gazeData.Timestamp / 1000, Fixation.Unknown, true);
handler(this, gazeEventArgs);
}
}
/// <summary>
/// Ensures synchronization before handling receive gaze data
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Contains the gaze data item</param>
public sealed override void GazeDataReceived(object sender, GazeDataEventArgs e)
{
if (syncManager.SyncState.StateFlag == SyncStateFlag.Synchronized)
{
GazeDataReceivedSynchronized(sender, e.GazeDataItem);
}
}
private void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
var gazePoint = e.LeftEye.GazePoint;
if (gazePoint.Validity == Validity.Valid)
{
if (_lastLeftPoint != null)
{
var tmp = ToPoint(gazePoint.PositionOnDisplayArea);
DrawLine(_lastLeftPoint.Value, tmp, _blueBrush);
_lastLeftPoint = tmp;
}
else
{
_lastLeftPoint = ToPoint(gazePoint.PositionOnDisplayArea);
}
}
gazePoint = e.RightEye.GazePoint;
if (gazePoint.Validity == Validity.Valid)
{
if (_lastRightPoint != null)
{
var tmp = ToPoint(gazePoint.PositionOnDisplayArea);
DrawLine(_lastRightPoint.Value, tmp, _greenBrush);
_lastRightPoint = tmp;
}
else
{
_lastRightPoint = ToPoint(gazePoint.PositionOnDisplayArea);
}
}
}));
}
internal GazeData(GazeDataEventArgs originalGaze)
{
TimeStamp = originalGaze.SystemTimeStamp;
Left = new GazeDataEye(originalGaze.LeftEye);
Right = new GazeDataEye(originalGaze.RightEye);
OriginalGaze = originalGaze;
}
private void OnGazeData(object sender, GazeDataEventArgs gazeDataEventArgs)
{
var gazeData = gazeDataEventArgs.GazeData;
if (gazeData.TrackingStatus == TrackingStatus.BothEyesTracked ||
gazeData.TrackingStatus == TrackingStatus.OneEyeTrackedUnknownWhich)
{
var p = new Point2D(
(gazeData.Left.GazePointOnDisplayNormalized.X +
gazeData.Right.GazePointOnDisplayNormalized.X) / 2,
(gazeData.Left.GazePointOnDisplayNormalized.Y +
gazeData.Right.GazePointOnDisplayNormalized.Y) / 2);
RaiseGazePoint(p);
}
else if (gazeData.TrackingStatus == TrackingStatus.OnlyLeftEyeTracked ||
gazeData.TrackingStatus == TrackingStatus.OneEyeTrackedProbablyLeft)
{
RaiseGazePoint(gazeData.Left.GazePointOnDisplayNormalized);
}
else if (gazeData.TrackingStatus == TrackingStatus.OnlyRightEyeTracked ||
gazeData.TrackingStatus == TrackingStatus.OneEyeTrackedProbablyRight)
{
RaiseGazePoint(gazeData.Right.GazePointOnDisplayNormalized);
}
}
private static void EyeTrackerGazeData(object sender, GazeDataEventArgs e)
{
var gazeData = e.GazeData;
Console.Write("{0} ", gazeData.Timestamp / 1e6); // in seconds
Console.Write("{0} ", gazeData.TrackingStatus);
if (gazeData.TrackingStatus == TrackingStatus.BothEyesTracked ||
gazeData.TrackingStatus == TrackingStatus.OnlyLeftEyeTracked ||
gazeData.TrackingStatus == TrackingStatus.OneEyeTrackedProbablyLeft)
{
Console.Write("[{0:N4},{1:N4}] ", gazeData.Left.GazePointOnDisplayNormalized.X, gazeData.Left.GazePointOnDisplayNormalized.Y);
}
else
{
Console.Write("[-,-] ");
}
if (gazeData.TrackingStatus == TrackingStatus.BothEyesTracked ||
gazeData.TrackingStatus == TrackingStatus.OnlyRightEyeTracked ||
gazeData.TrackingStatus == TrackingStatus.OneEyeTrackedProbablyRight)
{
Console.Write("[{0:N4},{1:N4}] ", gazeData.Right.GazePointOnDisplayNormalized.X, gazeData.Right.GazePointOnDisplayNormalized.Y);
}
else
{
Console.Write("[-,-] ");
}
Console.WriteLine();
}
// OnGazeDataReceive handler
void GazeDataReceive(object sender, GazeDataEventArgs e)
{
if (FSliceCount > 0)
{
CustomGazeData cgd = new CustomGazeData(e.GazeDataItem);
FOutputTimeStamp[0] = e.GazeDataItem.TimeStamp;
FOutputLeftEyePos[0] = cgd.LEPos3D;
FOutputLeftEyePosRel[0] = cgd.LEPos3DRel;
FOutputLeftEyeGazePoint[0] = cgd.LEGazePoint;
FOutputLeftEyePupilDiameter[0] = cgd.LEPupilDiameter;
FOutputLeftEyeValidity[0] = cgd.LEValidity;
FOutputRightEyePos[0] = cgd.REPos3D;
FOutputRightEyePosRel[0] = cgd.REPos3DRel;
FOutputRightEyeGazePoint[0] = cgd.REGazePoint;
FOutputRightEyePupilDiameter[0] = cgd.REPupilDiameter;
FOutputRightEyeValidity[0] = cgd.REValidity;
Vector2D?gazeVec = GetAverageGazePoint(e.GazeDataItem);
if (gazeVec.HasValue)
{
FOutputGazePoint2D[0] = MapValue_ETToVVVV(gazeVec.Value);
}
}
}
private static Point3D GetAveragePoint(GazeDataEventArgs gazeEvent)
{
float gazeX = 0;
float gazeY = 0;
float gazeZ = 0;
if (gazeEvent.LeftEye.GazePoint.Validity == Validity.Valid &&
gazeEvent.RightEye.GazePoint.Validity == Validity.Valid)
{
gazeX = (gazeEvent.LeftEye.GazePoint.PositionInUserCoordinates.X + gazeEvent.RightEye.GazePoint.PositionInUserCoordinates.X) / 2;
gazeY = (gazeEvent.LeftEye.GazePoint.PositionInUserCoordinates.Y + gazeEvent.RightEye.GazePoint.PositionInUserCoordinates.Y) / 2;
gazeY = (gazeEvent.LeftEye.GazePoint.PositionInUserCoordinates.Z + gazeEvent.RightEye.GazePoint.PositionInUserCoordinates.Z) / 2;
}
else if (gazeEvent.LeftEye.GazePoint.Validity == Validity.Valid)
{
gazeX = gazeEvent.LeftEye.GazePoint.PositionInUserCoordinates.X;
gazeY = gazeEvent.LeftEye.GazePoint.PositionInUserCoordinates.Y;
gazeZ = gazeEvent.LeftEye.GazePoint.PositionInUserCoordinates.Y;
}
else if (gazeEvent.RightEye.GazePoint.Validity == Validity.Valid)
{
gazeX = gazeEvent.RightEye.GazePoint.PositionInUserCoordinates.X;
gazeY = gazeEvent.RightEye.GazePoint.PositionInUserCoordinates.Y;
gazeZ = gazeEvent.RightEye.GazePoint.PositionInUserCoordinates.Y;
}
return(new Point3D(gazeX, gazeY, gazeZ));
}
private void OnGazeData(object sender, GazeDataEventArgs e)
{
// mirror the x coordinate to make the visualization make sense.
var left = new Point2D(1 - e.GazeData.Left.EyePositionInTrackBoxNormalized.X, e.GazeData.Left.EyePositionInTrackBoxNormalized.Y);
var right = new Point2D(1 - e.GazeData.Right.EyePositionInTrackBoxNormalized.X, e.GazeData.Right.EyePositionInTrackBoxNormalized.Y);
var z = 1.1;
switch (e.GazeData.TrackingStatus)
{
case TrackingStatus.BothEyesTracked:
z = (e.GazeData.Left.EyePositionInTrackBoxNormalized.Z + e.GazeData.Right.EyePositionInTrackBoxNormalized.Z) / 2;
break;
case TrackingStatus.OnlyLeftEyeTracked:
z = e.GazeData.Left.EyePositionInTrackBoxNormalized.Z;
right = new Point2D(double.NaN, double.NaN);
break;
case TrackingStatus.OnlyRightEyeTracked:
z = e.GazeData.Right.EyePositionInTrackBoxNormalized.Z;
left = new Point2D(double.NaN, double.NaN);
break;
default:
left = right = new Point2D(double.NaN, double.NaN);
break;
}
_dispatcher.BeginInvoke(new Action(() =>
{
SetEyePositions(left, right, z);
}));
}
private void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
int w = Screen.PrimaryScreen.Bounds.Width;
int h = Screen.PrimaryScreen.Bounds.Height;
//if we become information from two Eye
if (e.LeftEye.GazePoint.Validity == Validity.Valid && e.RightEye.GazePoint.Validity == Validity.Valid)
{
sampleCount++;
sampleIndex++;
if (sampleIndex >= samples.Length)
{
sampleIndex = 0;
}
//combine to eye using tobii pro
int x = ((int)(e.LeftEye.GazePoint.PositionOnDisplayArea.X * w) + (int)(e.RightEye.GazePoint.PositionOnDisplayArea.X * w)) / 2;
int y = ((int)(e.LeftEye.GazePoint.PositionOnDisplayArea.Y * h) + (int)(e.RightEye.GazePoint.PositionOnDisplayArea.Y * h)) / 2;
samples[sampleIndex] = new Point(x, y);
hasNoGaze = false;
}
else if (e.LeftEye.GazePoint.Validity == Validity.Valid && e.RightEye.GazePoint.Validity == Validity.Invalid)
{
sampleCount++;
sampleIndex++;
if (sampleIndex >= samples.Length)
{
sampleIndex = 0;
}
//combine to eye using tobii pro
int x = (int)(e.LeftEye.GazePoint.PositionOnDisplayArea.X * w);
int y = (int)(e.LeftEye.GazePoint.PositionOnDisplayArea.Y * h);
samples[sampleIndex] = new Point(x, y);
hasNoGaze = false;
}
else if (e.LeftEye.GazePoint.Validity == Validity.Invalid && e.RightEye.GazePoint.Validity == Validity.Valid)
{
sampleCount++;
sampleIndex++;
if (sampleIndex >= samples.Length)
{
sampleIndex = 0;
}
//combine to eye using tobii pro
int x = (int)(e.RightEye.GazePoint.PositionOnDisplayArea.X * w);
int y = (int)(e.RightEye.GazePoint.PositionOnDisplayArea.Y * h);
samples[sampleIndex] = new Point(x, y);
hasNoGaze = false;
}
else if (e.LeftEye.GazePoint.Validity == Validity.Invalid && e.RightEye.GazePoint.Validity == Validity.Invalid)
{
hasNoGaze = true;
}
}
private void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
//this.Dispatcher.Invoke(() =>
//{
// Connect.Text = $"Got gaze data with {e.LeftEye.GazeOrigin.Validity} left eye origin at point ({e.LeftEye.GazeOrigin.PositionInUserCoordinates.X}," +
// $" {e.LeftEye.GazeOrigin.PositionInUserCoordinates.Y}, {e.LeftEye.GazeOrigin.PositionInUserCoordinates.Z}) in the user coordinate system.";
//});
}
//--------------------------------------------------------------------
// Low Level Functions
//--------------------------------------------------------------------
private void GazeDataReceived(object sender, GazeDataEventArgs e)
{
lock (ScreenGaze)
{
this.UpdateGazePoint(e);
this.UpdateGazeRect();
}
}
private void OnGazeData(object sender, GazeDataEventArgs gazeDataEventArgs)
{
var gazeData = gazeDataEventArgs.GazeData;
detectorDeOjos.dataReceived(gazeData.TrackingStatus);
RaiseGazePoint(gazeData);
}
public void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
_leftGaze = e.GazeDataItem.LeftGazePoint2D;
_rightGaze = e.GazeDataItem.RightGazePoint2D;
_time = e.GazeDataItem.Timestamp;
swt.WriteLine("{0}, {1}, {2}, {3}, {4}", _time, _leftGaze.X, _leftGaze.Y, _rightGaze.X, _rightGaze.Y);
Console.WriteLine("{0}, {1}, {2}, {3}, {4}", _time, _leftGaze.X, _leftGaze.Y, _rightGaze.X, _rightGaze.Y);
}
//'##################################################################################################
private void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
Console.WriteLine(e.LeftEye.GazePoint.PositionOnDisplayArea.X);
Console.WriteLine(e.LeftEye.GazePoint.PositionOnDisplayArea.Y);
Console.WriteLine();
// mTargetPoint =
//mTimer.Enabled = true;
}
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Convert to centimeters
const double D = 10.0;
_leftPos.X = e.GazeDataItem.LeftEyePosition3D.X / D;
_leftPos.Y = e.GazeDataItem.LeftEyePosition3D.Y / D;
_leftPos.Z = e.GazeDataItem.LeftEyePosition3D.Z / D;
_rightPos.X = e.GazeDataItem.RightEyePosition3D.X / D;
_rightPos.Y = e.GazeDataItem.RightEyePosition3D.Y / D;
_rightPos.Z = e.GazeDataItem.RightEyePosition3D.Z / D;
_leftGaze.X = e.GazeDataItem.LeftGazePoint3D.X / D;
_leftGaze.Y = e.GazeDataItem.LeftGazePoint3D.Y / D;
_leftGaze.Z = e.GazeDataItem.LeftGazePoint3D.Z / D;
_rightGaze.X = e.GazeDataItem.RightGazePoint3D.X / D;
_rightGaze.Y = e.GazeDataItem.RightGazePoint3D.Y / D;
_rightGaze.Z = e.GazeDataItem.RightGazePoint3D.Z / D;
// Set which eyes to show
_showLeft = e.GazeDataItem.LeftValidity < 2;
_showRight = e.GazeDataItem.RightValidity < 2;
Action update = delegate()
{
if (_showLeft)
{
_eyePair.LeftEyePosition = _leftPos;
_leftGazeVector.Point1 = _leftPos;
_leftGazeVector.Point2 = _leftGaze;
}
else
{
Point3D farAway = new Point3D(1000.0, 1000.0, 1000.0);
_eyePair.LeftEyePosition = farAway;
_leftGazeVector.Point1 = farAway;
_leftGazeVector.Point2 = farAway;
}
if (_showRight)
{
_eyePair.RightEyePosition = _rightPos;
_rightGazeVector.Point1 = _rightPos;
_rightGazeVector.Point2 = _rightGaze;
}
else
{
Point3D farAway = new Point3D(1000.0, 1000.0, 1000.0);
_eyePair.RightEyePosition = farAway;
_rightGazeVector.Point1 = farAway;
_rightGazeVector.Point2 = farAway;
}
};
Dispatcher.BeginInvoke(update);
}
internal static void WriteRawGaze(this XmlWriter file, GazeDataEventArgs originalGaze)
{
file.WriteStartElement("OriginalGaze");
file.WriteAttributeString("DeviceTimeStamp", originalGaze.DeviceTimeStamp.ToString());
file.WriteAttributeString("SystemTimeStamp", originalGaze.SystemTimeStamp.ToString());
file.WriteEyeData(originalGaze.LeftEye, "LeftEye");
file.WriteEyeData(originalGaze.RightEye, "RightEye");
file.WriteEndElement();
}
private void MyEyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Write the data to the console.
double x = e.LeftEye.GazePoint.PositionOnDisplayArea.X;
double y = e.LeftEye.GazePoint.PositionOnDisplayArea.Y;
Console.WriteLine("Gaze point at ({0:0.0}, {1:0.0}) @{2:0}", x, y, e.SystemTimeStamp);
linesGaze.Add(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.FFF") + ";" + e.SystemTimeStamp + ";" + x * width + ";" + y * height + ";" + e.LeftEye.Pupil.PupilDiameter);
}
/// <summary>
/// Collects gaze point events
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Contains gaze data item</param>
protected override void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e)
{
lock (this)
{
if (collectingData)
{
events.AddLast(new EyetrackerEvent(e.GazeDataItem));
}
}
}
// This method will be called on the main Unity thread
private void HandleGazeData(GazeDataEventArgs e)
{
// Do something with gaze data
// Debug.Log(string.Format(
// "Got gaze data with {0} left eye origin at point ({1}, {2}, {3}) in the user coordinate system.",
// e.LeftEye.GazeOrigin.Validity,
// e.LeftEye.GazeOrigin.PositionInUserCoordinates.X,
// e.LeftEye.GazeOrigin.PositionInUserCoordinates.Y,
// e.LeftEye.GazeOrigin.PositionInUserCoordinates.Z));
}
private static void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
int w = Screen.PrimaryScreen.Bounds.Width;
int h = Screen.PrimaryScreen.Bounds.Height;
Console.WriteLine(
"Got gaze data with {0} left eye origin at point ({1}, {2}) in the user coordinate system.",
e.LeftEye.GazePoint.Validity,
e.LeftEye.GazePoint.PositionOnDisplayArea.X * w,
e.LeftEye.GazePoint.PositionOnDisplayArea.Y * h);
}
private static void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
var local_timestamp = DateTimeOffset.Now.ToString("MM/dd/yyyy hh:mm:ss.fff").ToString();
var UnixTimestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds().ToString();
var t_str = String.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12}\r\n",
e.LeftEye.GazeOrigin.Validity,
e.LeftEye.GazeOrigin.PositionInUserCoordinates.X,
e.LeftEye.GazeOrigin.PositionInUserCoordinates.Y,
e.LeftEye.GazeOrigin.PositionInUserCoordinates.Z,
e.LeftEye.GazePoint.PositionOnDisplayArea.X,
e.LeftEye.GazePoint.PositionOnDisplayArea.Y,
e.RightEye.GazePoint.PositionOnDisplayArea.X,
e.RightEye.GazePoint.PositionOnDisplayArea.Y,
e.LeftEye.Pupil.Validity,
e.LeftEye.Pupil.PupilDiameter,
e.RightEye.Pupil.PupilDiameter,
UnixTimestamp,
local_timestamp);
//project eye tracking data to form image
// eye tracking data: screen center point (0,0)
m_eyegazex = e.LeftEye.GazePoint.PositionOnDisplayArea.X;
m_eyegazey = e.LeftEye.GazePoint.PositionOnDisplayArea.Y;
m_eyegazestr = String.Format("{0},{1},{2}",
m_eyegazex,
m_eyegazey,
UnixTimestamp);
//m_eyegazey = e.LeftEye.GazeOrigin.PositionInUserCoordinates.Y;
/*
* (
* "Gaze data with {0} left eye origin at point ({1}, {2}, {3}) in the user coordinate system. TimeStamp: {4}",
* e.LeftEye.GazeOrigin.Validity,
* e.LeftEye.GazeOrigin.PositionInUserCoordinates.X,
* e.LeftEye.GazeOrigin.PositionInUserCoordinates.Y,
* e.LeftEye.GazeOrigin.PositionInUserCoordinates.Z,
* systemTimeStamp);
*/
//System.IO.File.WriteAllText(filename, t_str);
if (eyetrackingrecordenabled)
{
System.IO.File.AppendAllText(gazedatasavingpath, t_str);
}
}
private void HandleGazeData(object sender, GazeDataEventArgs gazeEvent)
{
try
{
if (gazeEvent.LeftEye.Pupil.Validity == Validity.Valid || gazeEvent.RightEye.Pupil.Validity == Validity.Valid)
{
GazeEventQueue.Enqueue(gazeEvent);
}
}
catch (Exception exp)
{
Console.Write(exp);
}
}
private void _connectedTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
if (s.Elapsed < TimeSpan.FromSeconds(5))
{
currentDataItem.GazeData.Add(e.GazeDataItem);
currentDataItem.Timestamp.Add(DateTime.Now);
}
else
{
_connectedTracker.StopTracking();
_isTracking = false;
rc.Close();
}
}
void tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Manages the data received by the eye tracker
leftGaze_X = e.GazeDataItem.LeftGazePoint2D.X;
leftGaze_Y = e.GazeDataItem.LeftGazePoint2D.Y;
//leftGaze_Z = e.GazeDataItem.LeftGazePoint3D.Z;
rightGaze_X = e.GazeDataItem.RightGazePoint2D.X;
rightGaze_Y = e.GazeDataItem.RightGazePoint2D.Y;
//rightGaze_Z = e.GazeDataItem.RightGazePoint3D.Z;
left_pupil_diameter = e.GazeDataItem.LeftPupilDiameter;
right_pupil_diameter = e.GazeDataItem.RightPupilDiameter;
}
private static void EyeTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
if (e.LeftEye.GazePoint.PositionOnDisplayArea.X >= 0.49f && e.LeftEye.GazePoint.PositionOnDisplayArea.X <= 0.51f &&
e.LeftEye.GazePoint.PositionOnDisplayArea.Y >= 0.49f && e.LeftEye.GazePoint.PositionOnDisplayArea.Y <= 0.51f)
{
Console.WriteLine(
"Got gaze data with {0} left eye origin at point ({1}, {2}, ) in the user coordinate system.",
e.LeftEye.GazePoint.Validity,
e.LeftEye.GazePoint.PositionOnDisplayArea.X,
e.LeftEye.GazePoint.PositionOnDisplayArea.Y
);
calibrationBegin2++;
mEyeTracker.GazeDataReceived -= EyeTracker_GazeDataReceived;
}
}
private void EyeTrackerGazeData(object sender, GazeDataEventArgs e)
{
var gazeData = e.GazeData;
var point1 = e.GazeData.Left.GazePointOnDisplayNormalized;
var point2 = e.GazeData.Right.GazePointOnDisplayNormalized;
var p1 = new Point((int)(point1.X * Screen.PrimaryScreen.WorkingArea.Width), (int)(point1.Y * Screen.PrimaryScreen.WorkingArea.Height));
var p2 = new Point((int)(point2.X * Screen.PrimaryScreen.WorkingArea.Width), (int)(point2.Y * Screen.PrimaryScreen.WorkingArea.Height));
//var p1 = new Point((int)gazeData.Left.GazePointOnDisplayNormalized.X, (int)gazeData.Left.GazePointOnDisplayNormalized.Y);
p1 = (Point)this.boardControl.Invoke((Delegate)(Func<object>)(() => this.boardControl.PointToClient(p1)));
p2 = (Point)this.boardControl.Invoke((Delegate)(Func<object>)(() => this.boardControl.PointToClient(p2)));
//var p2 = new Point((int)gazeData.Right.GazePointOnDisplayNormalized.X, (int)gazeData.Right.GazePointOnDisplayNormalized.Y);
//p2 = (Point)this.boardControl.Invoke((Delegate)(Func<object>)(() => this.boardControl.PointToClient(p2)));
//System.Diagnostics.Debug.Write("\r"+ p1);
this.OnDataAvailable(new EyeTrackerSensorData(p1, p2));
}
private void OnGazeData(object sender, GazeDataEventArgs gazeDataEventArgs)
{
var gazeData = gazeDataEventArgs.GazeData;
detectorDeOjos.dataReceived(gazeData.TrackingStatus);
RaiseGazePoint(gazeData);
}
/// <summary>
/// Writes (X, Y) coordinate of gaze point to console if CPU and eyetracker clocks are synchronized.
///
/// Detailed explanation of synchronization available in Tobii SDK 3.0 Developer Guide.
/// http://www.tobii.com/Global/Analysis/Downloads/User_Manuals_and_Guides/Tobii%20SDK%203.0%20Release%20Candidate%201%20Developers%20Guide.pdf
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e)
{
Print(e.GazeDataItem);
}
/// <summary>
/// Writes (X, Y) coordinate of gaze point to console if CPU and eyetracker clocks are synchronized.
///
/// Detailed explanation of synchronization available in Tobii SDK 3.0 Developer Guide.
/// http://www.tobii.com/Global/Analysis/Downloads/User_Manuals_and_Guides/Tobii%20SDK%203.0%20Release%20Candidate%201%20Developers%20Guide.pdf
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e)
{
Console.WriteLine("GazeData - (" + e.GazeDataItem.LeftEyePosition3D.X + ", " + e.GazeDataItem.LeftEyePosition3D.Y + ")");
}
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
var gd = e.GazeDataItem;
_leftGaze.X = gd.LeftGazePoint2D.X * 1920;
_leftGaze.Y = gd.LeftGazePoint2D.Y * 1200;
_rightGaze.X = gd.RightGazePoint2D.X * 1920;
_rightGaze.Y = gd.RightGazePoint2D.Y * 1200;
if (!GazeHelper.SetCurrentPoint(ref _current, _leftGaze, _rightGaze))
return;
_current = PointFromScreen(_current);
if (GazeHaveMoved(_current) && _sw.ElapsedMilliseconds > 750)
{
if (IsGazeLeftSide() && _isSwipeAllowed)
{
// SWIPE RIGHT ~>>~>>~>> (PREV)
Debug.WriteLine("Prev");
_isSwipeAllowed = false;
if (ImageContainer.SelectedIndex == 0)
{
ImageContainer.SelectedIndex = ImageContainer.Items.Count - 1;
}
else
{
ImageContainer.SelectedIndex--;
}
ImageContainer.RunSlideAnimation(ActualWidth);
}
else if (IsGazeRightSide() && _isSwipeAllowed)
{
// SWIPE LEFT <<~<<~<<~ (NEXT)
Debug.WriteLine("Next");
_isSwipeAllowed = false;
if (ImageContainer.SelectedIndex == ImageContainer.Items.Count - 1)
{
ImageContainer.SelectedIndex = 0;
}
else
{
ImageContainer.SelectedIndex++;
}
ImageContainer.RunSlideAnimation(-ActualWidth);
}
_isSwipeAllowed = true;
_previous = _current;
Debug.WriteLine(_sw.ElapsedMilliseconds);
_sw.Restart();
}
}
/// <summary>
/// This is the function that handles the gaze data received from the tracker
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// 'left' and 'right' are the eyes
Point2D leftGaze = e.GazeDataItem.LeftGazePoint2D;
Point2D rightGaze = e.GazeDataItem.RightGazePoint2D;
if (leftGaze.X == -1)
leftGaze = rightGaze;
if (rightGaze.X == -1)
rightGaze = leftGaze;
Point gazePoint = new Point((leftGaze.X + rightGaze.X)/2, (leftGaze.Y + rightGaze.Y)/2);
Point screenPoint = new Point(gazePoint.X*SystemParameters.PrimaryScreenWidth,
gazePoint.Y*SystemParameters.PrimaryScreenHeight);
Point clientPoint = window.PointFromScreen(screenPoint);
Point smoothedPoint = smoother.Smooth(clientPoint);
GazePoint = new Vector2((float) smoothedPoint.X, (float) smoothedPoint.Y);
OnGazeDataReceived(this, new GazeEventArgs(GazePoint, e.GazeDataItem.LeftValidity, e.GazeDataItem.RightValidity));
}
/// <summary>
/// OnGazeData event handler for connected tracker.
/// This event fires whenever there are new gaze data
/// to receive.
/// It converts the interface internal gaze structure into
/// a OGAMA readable format and fires the <see cref="Tracker.OnGazeDataChanged"/>
/// event to the recorder.
/// </summary>
/// <param name="sender">
/// Source of the event
/// </param>
/// <param name="e">
/// The <see cref="GazeDataEventArgs"/> with the new gaze data
/// from the device.
/// </param>
private void ConnectedTrackerGazeDataReceived(object sender, GazeDataEventArgs e)
{
// Send the gaze data to the track status control.
GazeDataItem gd = e.GazeDataItem;
this.tobiiTrackStatus.OnGazeData(gd);
if (this.dlgTrackStatus != null && this.dlgTrackStatus.Visible)
{
this.dlgTrackStatus.Update(gd);
}
// Convert Tobii gazestamp in milliseconds.
var newGazeData = new GazeData { Time = gd.TimeStamp / 1000 };
// The validity code takes one of five values for each eye ranging from 0 to 4, with the
// following interpretation:
// 0 - The eye tracker is certain that the data for this eye is right. There is no risk of
// confusing data from the other eye.
// 1 - The eye tracker has only recorded one eye, and has made some assumptions and
// estimations regarding which is the left and which is the right eye. However, it is still
// very likely that the assumption made is correct. The validity code for the other eye is
// in this case always set to 3.
// 2 - The eye tracker has only recorded one eye, and has no way of determining which
// one is left eye and which one is right eye. The validity code for both eyes is set to 2.
// 3 - The eye tracker is fairly confident that the actual gaze data belongs to the other
// eye. The other eye will always have validity code 1.
// 4 - The actual gaze data is missing or definitely belonging to the other eye.
// Hence, there are a limited number of possible combinations of validity codes for the
// two eyes:
// Code Description
// 0 - 0 Both eyes found. Data is valid for both eyes.
// 0 - 4 or 4 - 0 One eye found. Gaze data is the same for both eyes.
// 1 – 3 or 3 - 1 One eye found. Gaze data is the same for both eyes.
// 2 – 2 One eye found. Gaze data is the same for both eyes.
// 4 – 4 No eye found. Gaze data for both eyes are invalid.
// Use data only if both left and right eye was found by the eye tracker
// It is recommended that the validity codes are always used for data filtering,
// to remove data points which are obviously incorrect.
// Normally, we recommend removing all data points with a validity code of 2 or higher.
if (gd.LeftValidity == 0 && gd.RightValidity == 0)
{
// Let the x, y and distance be the right and left eye average
newGazeData.GazePosX = (float)((gd.LeftGazePoint2D.X + gd.RightGazePoint2D.X) / 2);
newGazeData.GazePosY = (float)((gd.LeftGazePoint2D.Y + gd.RightGazePoint2D.Y) / 2);
newGazeData.PupilDiaX = gd.LeftPupilDiameter;
newGazeData.PupilDiaY = gd.RightPupilDiameter;
}
else if (gd.LeftValidity == 4 && gd.RightValidity == 4)
{
newGazeData.GazePosX = 0;
newGazeData.GazePosY = 0;
newGazeData.PupilDiaX = 0;
newGazeData.PupilDiaY = 0;
}
else if (gd.LeftValidity == 2 && gd.RightValidity == 2)
{
newGazeData.GazePosX = 0;
newGazeData.GazePosY = 0;
newGazeData.PupilDiaX = 0;
newGazeData.PupilDiaY = 0;
}
else if (gd.LeftValidity == 1 && gd.RightValidity == 3)
{
newGazeData.GazePosX = (float)gd.LeftGazePoint2D.X;
newGazeData.GazePosY = (float)gd.LeftGazePoint2D.Y;
newGazeData.PupilDiaX = gd.LeftPupilDiameter;
newGazeData.PupilDiaY = null;
}
else if (gd.LeftValidity == 3 && gd.RightValidity == 1)
{
newGazeData.GazePosX = (float)gd.RightGazePoint2D.X;
newGazeData.GazePosY = (float)gd.RightGazePoint2D.Y;
newGazeData.PupilDiaX = null;
newGazeData.PupilDiaY = gd.RightPupilDiameter;
}
else if (gd.LeftValidity == 0 && gd.RightValidity == 4)
{
newGazeData.GazePosX = (float)gd.LeftGazePoint2D.X;
newGazeData.GazePosY = (float)gd.LeftGazePoint2D.Y;
newGazeData.PupilDiaX = gd.LeftPupilDiameter;
newGazeData.PupilDiaY = null;
}
else if (gd.LeftValidity == 4 && gd.RightValidity == 0)
{
newGazeData.GazePosX = (float)gd.RightGazePoint2D.X;
newGazeData.GazePosY = (float)gd.RightGazePoint2D.Y;
newGazeData.PupilDiaX = null;
newGazeData.PupilDiaY = gd.RightPupilDiameter;
}
else
{
newGazeData.GazePosX = null;
newGazeData.GazePosY = null;
newGazeData.PupilDiaX = null;
newGazeData.PupilDiaY = null;
}
this.OnGazeDataChanged(new GazeDataChangedEventArgs(newGazeData));
}
private void _connectedTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
int trigSignal;
if (e.GazeDataItem.TryGetExtensionValue(IntegerExtensionValue.TrigSignal, out trigSignal))
{
Console.WriteLine(string.Format("Trig signal: {0}", trigSignal));
}
// Send the gaze data to the track status control.
var gd = e.GazeDataItem;
_trackStatus.OnGazeData(gd.LeftGazePoint2D, gd.RightGazePoint2D);
if (_syncManager.CurrentSyncState.Status == SyncStatus.Synchronized)
{
Int64 convertedTime = _syncManager.RemoteToLocal(gd.Timestamp);
Int64 localTime = _clock.Time;
}
else
{
Console.WriteLine("Warning. Sync state is " + _syncManager.CurrentSyncState.Status);
}
}
private void _connectedTracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Send the gaze data to the track status control.
GazeDataItem gd = e.GazeDataItem;
_trackStatus.OnGazeData(gd);
if (_syncManager.SyncState.StateFlag == SyncStateFlag.Synchronized)
{
Int64 convertedTime = _syncManager.RemoteToLocal(gd.TimeStamp);
Int64 localTime = _clock.GetTime();
}
else
{
Console.WriteLine("Warning. Sync state is " + _syncManager.SyncState.StateFlag);
}
}
/// <summary> /// Method to implement that handles the received eyetracker gaze data. /// </summary> /// <param name="sender"></param> /// <param name="e">Contains the gaze data item</param> protected abstract void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e);
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Convert to centimeters
const double D = 10.0;
_leftPos.X = e.GazeDataItem.LeftEyePosition3D.X / D;
_leftPos.Y = e.GazeDataItem.LeftEyePosition3D.Y / D;
_leftPos.Z = e.GazeDataItem.LeftEyePosition3D.Z / D;
_rightPos.X = e.GazeDataItem.RightEyePosition3D.X / D;
_rightPos.Y = e.GazeDataItem.RightEyePosition3D.Y / D;
_rightPos.Z = e.GazeDataItem.RightEyePosition3D.Z / D;
_leftGaze.X = e.GazeDataItem.LeftGazePoint3D.X / D;
_leftGaze.Y = e.GazeDataItem.LeftGazePoint3D.Y / D;
_leftGaze.Z = e.GazeDataItem.LeftGazePoint3D.Z / D;
_rightGaze.X = e.GazeDataItem.RightGazePoint3D.X / D;
_rightGaze.Y = e.GazeDataItem.RightGazePoint3D.Y / D;
_rightGaze.Z = e.GazeDataItem.RightGazePoint3D.Z / D;
// Set which eyes to show
_showLeft = e.GazeDataItem.LeftValidity < 2;
_showRight = e.GazeDataItem.RightValidity < 2;
Action update = delegate()
{
if (_showLeft)
{
_eyePair.LeftEyePosition = _leftPos;
_leftGazeVector.Point1 = _leftPos;
_leftGazeVector.Point2 = _leftGaze;
}
else
{
Point3D farAway = new Point3D(1000.0, 1000.0, 1000.0);
_eyePair.LeftEyePosition = farAway;
_leftGazeVector.Point1 = farAway;
_leftGazeVector.Point2 = farAway;
}
if (_showRight)
{
_eyePair.RightEyePosition = _rightPos;
_rightGazeVector.Point1 = _rightPos;
_rightGazeVector.Point2 = _rightGaze;
}
else
{
Point3D farAway = new Point3D(1000.0, 1000.0, 1000.0);
_eyePair.RightEyePosition = farAway;
_rightGazeVector.Point1 = farAway;
_rightGazeVector.Point2 = farAway;
}
};
Dispatcher.BeginInvoke(update);
}
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Convert to centimeters
var gd = e.GazeDataItem;
_leftGaze.X = gd.LeftGazePoint2D.X * 1920;
_leftGaze.Y = gd.LeftGazePoint2D.Y * 1200;
_rightGaze.X = gd.RightGazePoint2D.X * 1920;
_rightGaze.Y = gd.RightGazePoint2D.Y * 1200;
if (!SetCurrentPoint(ref _current, _leftGaze, _rightGaze))
return;
_current = PointFromScreen(_current);
if (GazeHaveMoved(_current))
{
MoveCursor();
}
if (_current.Y > Height * 0.72 || _current.Y < Height * 0.28)
{
var scrollSpeed = ScrollSpeed();
ScrollAction(scrollSpeed);
}
_previous = _current;
}
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
var gd = e.GazeDataItem;
//_leftGaze.X = gd.LeftGazePoint2D.X * Width;
//_leftGaze.Y = gd.LeftGazePoint2D.Y * Height;
//_rightGaze.X = gd.RightGazePoint2D.X * Width;
//_rightGaze.Y = gd.RightGazePoint2D.Y * Height;
_leftGaze.X = gd.LeftGazePoint2D.X * 1920;
_leftGaze.Y = gd.LeftGazePoint2D.Y * 1200;
_rightGaze.X = gd.RightGazePoint2D.X * 1920;
_rightGaze.Y = gd.RightGazePoint2D.Y * 1200;
if (!GazeHelper.SetCurrentPoint(ref _current, _leftGaze, _rightGaze))
return;
_current = PointFromScreen(_current);
_headPos.Z = gd.LeftEyePosition3D.Z / 10;
switch (windowType)
{
case WindowType.Map:
var zoomFactor = _headPos.Z - _initialHeadPos.Z;
MapControll.MapInteraction(_zoomActionButtonDown, _current, zoomFactor);
break;
case WindowType.Swipe:
SwipeControl.MapInteraction(_current);
break;
case WindowType.Scroll:
ScrollControl.MapInteraction(_current);
break;
}
}
void tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Manages the data received by the eye tracker
leftGaze_X = e.GazeDataItem.LeftGazePoint2D.X;
leftGaze_Y = e.GazeDataItem.LeftGazePoint2D.Y;
//leftGaze_Z = e.GazeDataItem.LeftGazePoint3D.Z;
rightGaze_X = e.GazeDataItem.RightGazePoint2D.X;
rightGaze_Y = e.GazeDataItem.RightGazePoint2D.Y;
//rightGaze_Z = e.GazeDataItem.RightGazePoint3D.Z;
left_pupil_diameter = e.GazeDataItem.LeftPupilDiameter;
right_pupil_diameter = e.GazeDataItem.RightPupilDiameter;
}
/// <summary> /// Handles a gaze data received from eyetracker event /// </summary> /// <param name="sender"></param> /// <param name="e">Contains the GazeDataItem</param> public abstract void GazeDataReceived(object sender, GazeDataEventArgs e);
/// <summary>
/// Forwards 2D gaze points to fixation detector. Gaze points are only forwarded
/// if CPU and Eyetracker clocks are synchronized.
///
/// Detailed explanation of synchronization available in Tobii SDK 3.0 Developer Guide.
/// http://www.tobii.com/Global/Analysis/Downloads/User_Manuals_and_Guides/Tobii%20SDK%203.0%20Release%20Candidate%201%20Developers%20Guide.pdf
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e)
{
int time = (int)syncManager.RemoteToLocal(e.GazeDataItem.TimeStamp);
int x = (int)e.GazeDataItem.LeftGazePoint3D.X; // TODO Determine which of LeftGazePoint2D, LeftGazePoint3D, RightGazePoint2D, RightGazePoint3D or combination thereof is same as Tobii Studio
int y = (int)e.GazeDataItem.LeftGazePoint3D.Y;
fixationDetector.addPoint(time, x, y);
// testing
/*GazeDataItem gdi = e.GazeDataItem;
Console.WriteLine("GazeDataItem:\r\n" +
"LeftEyePosition3D (" + gdi.LeftEyePosition3D.X + ", " + gdi.LeftEyePosition3D.Y + ", " + gdi.LeftEyePosition3D.Z + ")\r\n" +
"LeftEyePosition3DRelative (" + gdi.LeftEyePosition3DRelative.X + ", " + gdi.LeftEyePosition3DRelative.Y + ", " + gdi.LeftEyePosition3DRelative.Z + ")\r\n" +
"LeftGazePoint2D (" + gdi.LeftGazePoint2D.X + ", " + gdi.LeftGazePoint2D.Y + ")\r\n" +
"LeftGazePoint3D (" + gdi.LeftGazePoint3D.X + ", " + gdi.LeftGazePoint3D.Y + ", " + gdi.LeftGazePoint3D.Z + ")\r\n" +
"RightEyePosition3D (" + gdi.RightEyePosition3D.X + ", " + gdi.RightEyePosition3D.Y + ", " + gdi.RightEyePosition3D.Z + ")\r\n" +
"RightEyePosition3DRelative (" + gdi.RightEyePosition3DRelative.X + ", " + gdi.RightEyePosition3DRelative.Y + ", " + gdi.RightEyePosition3DRelative.Z + ")\r\n" +
"RightGazePoint2D (" + gdi.RightGazePoint2D.X + ", " + gdi.RightGazePoint2D.Y + ")\r\n" +
"RightGazePoint3D (" + gdi.RightGazePoint3D.X + ", " + gdi.RightGazePoint3D.Y + ", " + gdi.RightGazePoint3D.Z + ")");
count++;*/
}
private void et_GazeDataRecieved(object sender, GazeDataEventArgs e)
{
if (e.GazeDataItem.RightValidity != BEST_VALIDITY && e.GazeDataItem.LeftValidity != BEST_VALIDITY)
{
return;
}
GetPoint point = Henshin(e.GazeDataItem);
point.Timestamp = e.GazeDataItem.Timestamp;
if (EtEventHandlers != null)
EtEventHandlers(point);
}
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Convert to centimeters
var gd = e.GazeDataItem;
_leftGaze.X = gd.LeftGazePoint2D.X* Width;
_leftGaze.Y = gd.LeftGazePoint2D.Y * Height;
_rightGaze.X = gd.RightGazePoint2D.X * Width;
_rightGaze.Y = gd.RightGazePoint2D.Y * Height;
_headPos.Z = gd.LeftEyePosition3D.Z / 10;
if ((_leftGaze.X < 0 && _rightGaze.X < 0 )|| _headPos.Z < 0) return;
if (!SetCurrentPoint(ref _current, _leftGaze, _rightGaze))
return;
if ((_current.X > 1400 || _current.X < 500 || _current.Y > 700 || _current.Y < 500))
{
EyeMoveDuringAction();
}
if (HeadHaveMoved(_initialHeadPos.Z) && actionButtonDown)
{
var zoomFactor = _headPos.Z - _initialHeadPos.Z;
zoom_event(zoomFactor);
}
}
protected override void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e)
{
lock (this)
{
if (collectingData)
{
gazePoints.AddLast(e.GazeDataItem);
}
}
}
internal void EyeTrackerGazeData(object sender, GazeDataEventArgs e)
{
Dispatcher.Invoke(
System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate() { DisplayGaze(e.GazeData); }));
}
private void _tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Convert to centimeters
var gd = e.GazeDataItem;
_leftGaze.X = gd.LeftGazePoint2D.X*Width;
_leftGaze.Y = gd.LeftGazePoint2D.Y*Height;
_rightGaze.X = gd.RightGazePoint2D.X*Width;
_rightGaze.Y = gd.RightGazePoint2D.Y*Height;
if (_leftGaze.X < 0 && _rightGaze.X < 0) return;
if (_leftGaze.X > 0 && _rightGaze.X > 0)
{
_current = new Point2D((_leftGaze.X + _rightGaze.X) / 2, (_leftGaze.Y + _rightGaze.Y) / 2);
}
else if (_rightGaze.X > 0)
{
_current = new Point2D(_rightGaze.X, _rightGaze.Y);
}
else if (_leftGaze.X > 0)
{
_current = new Point2D(_leftGaze.X, _leftGaze.Y);
}
if (!StaticValues.developerMode)
{
SaveData(_current, gd.RightEyePosition3D.Z/10);
}
if (GazeHaveMoved(_current))
{
Point = new Point(_current.X, _current.Y);
_previous = _current;
}
InvalidateVisual();
}
/// <summary>
/// Forwards 2D gaze points to fixation detector. Gaze points are only forwarded
/// if CPU and Eyetracker clocks are synchronized and validity is < 2. If both eyes are valid gaze point coordinates are averaged,
/// if only one eye is valid, only that eye's gaze point is used.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">GazeDataItem to process</param>
protected override void GazeDataReceivedSynchronized(object sender, GazeDataEventArgs e)
{
// ignore gaze data with low validity
if (e.GazeDataItem.LeftValidity < 2 || e.GazeDataItem.RightValidity < 2)
{
// convert timestamp
long microseconds = e.GazeDataItem.TimeStamp;
int milliseconds = (int)(microseconds / 1000);
milliseconds -= getTimestampOffset(milliseconds);
int time = milliseconds;
if (((microseconds / 100) % 10) >= 5) time++; // round
// convert normalized screen coordinates (float between [0 - 1]) to pixel coordinates
// coordinates (0, 0) designate the top left corner
double leftX = e.GazeDataItem.LeftGazePoint2D.X * SCREEN_WIDTH;
double leftY = e.GazeDataItem.LeftGazePoint2D.Y * SCREEN_HEIGHT;
double rightX = e.GazeDataItem.RightGazePoint2D.X * SCREEN_WIDTH;
double rightY = e.GazeDataItem.RightGazePoint2D.Y * SCREEN_HEIGHT;
if (e.GazeDataItem.LeftValidity < 2 && e.GazeDataItem.RightValidity < 2)
{
// average left and right eyes
int x = (int)((leftX + rightX) / 2);
int y = (int)((leftY + rightY) / 2);
fixationDetector.addPoint(time, x, y);
}
else if (e.GazeDataItem.LeftValidity < 2)
{
// use only left eye
fixationDetector.addPoint(time, (int)leftX, (int)leftY);
}
else if (e.GazeDataItem.RightValidity < 2)
{
// use only right eye
fixationDetector.addPoint(time, (int)rightX, (int)rightY);
}
}
}
private void tracker_GazeDataReceived(object sender, GazeDataEventArgs e)
{
// Send the gaze data to the track status control.
GazeDataItem gd = e.GazeDataItem;
Point2D leftGaze= e.GazeDataItem.LeftGazePoint2D;
Point2D rightGaze = e.GazeDataItem.RightGazePoint2D;
Point gazePoint = new Point((leftGaze.X + rightGaze.X) / 2, (leftGaze.Y + rightGaze.Y) / 2);
Vector delta = Point.Subtract(gazePoint, previousGazePoint);
//gazePoint = new Point((gazePoint.X + previousGazePoint.X) / 2, (gazePoint.Y + previousGazePoint.Y / 2));
previousGazePoint = gazePoint;
//if (delta.LengthSquared < 0.001)
// return;
Point screenPoint = new Point(gazePoint.X * SystemParameters.PrimaryScreenWidth, gazePoint.Y * SystemParameters.PrimaryScreenHeight);
if (syncManager.SyncState.StateFlag == SyncStateFlag.Synchronized)
{
Int64 convertedTime = syncManager.RemoteToLocal(gd.TimeStamp);
Int64 localTime = clock.GetTime();
Point clientPoint = canvas.PointFromScreen(new Point(screenPoint.X - crosshair.Width/2, screenPoint.Y - crosshair.Height/2)) ;
Canvas.SetLeft(crosshair, clientPoint.X);
Canvas.SetTop(crosshair, clientPoint.Y);
}
else
{
StatusText.Text = string.Format("Warning. Sync state is {0}", syncManager.SyncState.StateFlag);
}
}
