/// <summary>
/// This method initializes the control with the given
/// calibration result.
/// </summary>
/// <param name="newCalibrationResult">
/// The calibration result with information about the calibration
/// </param>
public void Initialize(CalibrationResult newCalibrationResult)
{
this.calibrationResult = newCalibrationResult;
this.ExtractCalibrationPoints();
this.Invalidate();
}
private string RatingFunction(CalibrationResult result)
{
if (result == null)
return "";
double accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
{
return "PERFECT";
}
if (accuracy < 0.7)
{
return "GOOD";
//return "Calibration Quality: GOOD";
}
if (accuracy < 1)
{
return "MODERATE";
}
if (accuracy < 1.5)
{
return "POOR";
}
return "REDO";
}
private string RatingFunction(CalibrationResult result)
{
if (result == null)
{
return("");
}
double accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
{
return("Qualidade da Calibração: EXCELENTE");
}
if (accuracy < 0.7)
{
return("Qualidade da Calibração: BOA");
}
if (accuracy < 1)
{
return("Qualidade da Calibração: MODERADA");
}
if (accuracy < 1.5)
{
return("Qualidade da Calibração: RUIM");
}
return("Qualidade da Calibração: REFAZER");
}
public string RatingFunction(CalibrationResult result)
{
if (result == null)
{
return("");
}
var accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
{
return("Calibration Quality: PERFECT");
}
if (accuracy < 0.7)
{
return("Calibration Quality: GOOD");
}
if (accuracy < 1)
{
return("Calibration Quality: MODERATE");
}
if (accuracy < 1.5)
{
return("Calibration Quality: POOR");
}
return("Calibration Quality: REDO");
}
private string RatingFunction(CalibrationResult result)
{
if (result == null)
{
return("");
}
double accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
{
return("Qualidade da calibragem: PERFEITA");
}
if (accuracy < 0.7)
{
return("Qualidade da calibragem: BOA");
}
if (accuracy < 1)
{
return("Qualidade da calibragem: MODERADA");
}
if (accuracy < 1.5)
{
return("Qualidade da calibragem: BAIXA");
}
return("Qualidade da calibragem: REFAZER");
}
public static CalibrationRatingEnum GetRating(this CalibrationResult result)
{
if (result == null)
{
return(CalibrationRatingEnum.Redo);
}
var accuracy = result.AverageErrorDegree;
if (accuracy < PerfectRange)
{
return(CalibrationRatingEnum.Perfect);
}
if (accuracy < GoodRange)
{
return(CalibrationRatingEnum.Good);
}
if (accuracy < ModerateRange)
{
return(CalibrationRatingEnum.Moderate);
}
if (accuracy < PoorRange)
{
return(CalibrationRatingEnum.Poor);
}
return(CalibrationRatingEnum.Redo);
}
public void OnCalibrationResult(CalibrationResult res)
{
// Invoke on UI thread
if (this.Dispatcher.Thread != Thread.CurrentThread)
{
Dispatcher.BeginInvoke(new MethodInvoker(() => OnCalibrationResult(res)));
return;
}
// No result?
if (res == null || res.Calibpoints == null)
{
RaiseResult(CalibrationRunnerResult.Error, "Calibration result is empty.");
StopAndClose();
return;
}
Console.Out.WriteLine("CalibrationResult, avg: " + res.AverageErrorDegree + " left: " + res.AverageErrorDegreeLeft + " right: " + res.AverageErrorDegreeRight);
// Success, check results for bad points
foreach (CalibrationPoint cp in res.Calibpoints)
{
if (cp == null || cp.Coordinates == null)
{
continue;
}
// Tracker tells us to resample this point, enque it
if (cp.State == CalibrationPoint.STATE_RESAMPLE || cp.State == CalibrationPoint.STATE_NO_DATA)
{
points.Enqueue(new PointF((float)cp.Coordinates.X, (float)cp.Coordinates.Y));
Console.Out.WriteLine("Recal adding " + cp.Coordinates.X + " " + cp.Coordinates.Y + " PointsInQueue: " + points.Count);
}
}
// Time to stop?
if (reSamplingCount > NUM_MAX_CALIBRATION_ATTEMPTS || points.Count > NUM_MAX_RESAMPLE_POINTS)
{
AbortCalibration(CalibrationRunnerResult.Failure, "Unable to calibrate.");
StopAndClose();
return;
}
// Resample?
if (points != null && points.Count > 0)
{
reSamplingCount++;
// Transition from last point to first resample point
PointF nextPos = points.Peek(); // peek here, RunPointSequence pulls out of queue
DoubleAnimation cX = CreateTransitionAnimation(DPI * currentPoint.X, DPI * nextPos.X, transitionTimeMs);
DoubleAnimation cY = CreateTransitionAnimation(DPI * currentPoint.Y, DPI * nextPos.Y, transitionTimeMs);
cX.Completed += delegate { RunPointSequence(); }; // once moved, start sequence
calPointWpf.BeginAnimation(Canvas.LeftProperty, cX);
calPointWpf.BeginAnimation(Canvas.TopProperty, cY);
return;
}
RaiseResult(CalibrationRunnerResult.Success, string.Empty, res);
StopAndClose();
}
private void Execution_CalibrationFinished(object sender, CalibrationResult e)
{
if (e != null)
{
_calibrations.Add(e);
}
}
private void RaiseResult(CalibrationRunnerResult result, string message, CalibrationResult calibrationReport)
{
if (OnResult != null)
{
OnResult(this, new CalibrationRunnerEventArgs(result, message, calibrationReport));
}
}
public void OnCalibrationChange(bool isCalibrated, CalibrationResult calibResult)
{
/*
* if (isCalibrated)
* _StateNotifyer.ShowState("Calib Result: " + calibResult.AverageErrorDegree.ToString("0.00"));
*/
}
/// <summary>
/// Returns a string with a description that represents the given overall accuracy.
/// </summary>
/// <param name="result">The calibration result to encode.</param>
/// <returns>A string with a description that represents the given overall accuracy.</returns>
private string RatingFunction(CalibrationResult result)
{
var accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
{
return("Quality: Perfect");
}
if (accuracy < 0.7)
{
return("Quality: Good");
}
if (accuracy < 1)
{
return("Quality: Moderate");
}
if (accuracy < 1.5)
{
return("Quality: Poor");
}
return("Quality: Redo");
}
private string RatingFunction(CalibrationResult result)
{
if (result == null)
{
return("FAILED");
}
double accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
{
return("PERFECT");
}
if (accuracy < 0.7)
{
return("GOOD");
}
if (accuracy < 1)
{
return("MODERATE");
}
if (accuracy < 1.5)
{
return("POOR");
}
return("REDO");
}
public CalibrationRunnerEventArgs(CalibrationRunnerResult result, string message, string rating, CalibrationResult calibrationResult)
{
this.result = result;
this.message = message;
this.rating = rating;
this.calibrationResult = calibrationResult;
}
public void OnCalibrationResult(CalibrationResult calibResult)
{
calResult = calibResult;
if (!calibResult.Result)
{
//Evaluate results
foreach (var calPoint in calibResult.Calibpoints)
{
if (calPoint.State == CalibrationPoint.STATE_RESAMPLE || calPoint.State == CalibrationPoint.STATE_NO_DATA)
{
calibrationPoints.Enqueue(new Point2D(calPoint.Coordinates.X, calPoint.Coordinates.Y));
}
}
//Should we abort?
if (reSamplingCount++ >= NUM_MAX_CALIBRATION_ATTEMPTS || calibrationPoints.Count >= NUM_MAX_RESAMPLE_POINTS)
{
AbortCalibration();
return;
}
// Let us continue
CurrentPoint = PickNextPoint();
MoveToPoint(CurrentPoint);
}
else
{
StopAndClose();
}
}
/// <summary>
/// Simple rating of a given calibration.
/// </summary>
/// <param name="result">Any given CalibrationResult</param>
/// <param name="rating">A number between 1 - 5 where 5 is the best othervise -1.</param>
/// <param name="strRating">A string with a rating name othervise ERROR.</param>
public void CalibrationRatingFunction(CalibrationResult result, out int rating, out string strRating)
{
if (result == null)
{
rating = -1;
strRating = "ERROR";
return;
}
if (result.AverageErrorDegree < 0.5)
{
rating = 5;
strRating = "PERFECT";
return;
}
if (result.AverageErrorDegree < 0.7)
{
rating = 4;
strRating = "GOOD";
return;
}
if (result.AverageErrorDegree < 1)
{
rating = 3;
strRating = "MODERATE";
return;
}
if (result.AverageErrorDegree < 1.5)
{
rating = 2;
strRating = "POOR";
return;
}
rating = 1;
strRating = "REDO";
}
public string RatingFunction(CalibrationResult result)
{
var accuracy = result.AverageErrorDegree;
var acc = " (" + Math.Round(accuracy, 2).ToString() + ")";
if (accuracy < 0.2)
{
return("Calibration Quality: PERFECT" + acc);
}
if (accuracy < 0.5)
{
return("Calibration Quality: VERY GOOD" + acc);
}
if (accuracy < 0.7)
{
return("Calibration Quality: GOOD" + acc);
}
if (accuracy < 1)
{
return("Calibration Quality: MODERATE" + acc);
}
if (accuracy < 1.5)
{
return("Calibration Quality: POOR" + acc);
}
return("Calibration Quality: REDO" + acc);
}
public void OnCalibrationChange(bool isCalibrated, CalibrationResult calibResult)
{
lock (_UpdateLock)
{
ResetUiState();
UpdateGUIState();
}
}
public CalibrationResultViewModel(CalibratorViewModel calibrator, CalibrationPlan plan, CalibrationResult result)
{
Calibrator = calibrator;
_plan = plan;
_result = result;
Status = result.Status;
Validate(result.Points);
}
public void OnCalibrationChanged(bool isCalibrated, CalibrationResult calibResult)
{
_Dispatcher.Dispatch(() =>
{
if (OnCalibrationResult != null)
{
OnCalibrationResult(isCalibrated, calibResult);
}
});
}
private void UpdateUiVrMode()
{
if (!GazeManager.Instance.IsActivated)
{
// GazeManager not connected
_QualityText.enabled = true;
_InfoText.enabled = true;
_InfoText.text = "Unable to connect to Server";
}
else
{
if (GazeManager.Instance.IsCalibrating)
{
// Hide UI during calibration
if (GazeGUIController.ShowGazeIndicator)
{
_ToggleIndicatorState = true;
GazeGUIController.ToggleIndicatorMode();
}
}
else
{
// Update main calibration info text
string calibrate;
if (!GazeManager.Instance.IsCalibrated)
{
calibrate = "Press <b>FIRE1*</b> or <b>SWIPE FORWARD</b>\nto begin calibration";
}
else
{
calibrate = "Press <b>FIRE1*</b> or <b>SWIPE FORWARD</b>\nto begin re-calibration\n\nPress <b>FIRE2</b> or <b>SWIPE DOWN</b> to start demo";
}
_InfoText.text = calibrate;
_InfoText.enabled = true;
// Update Calibration quality
CalibrationResult result = GazeManager.Instance.LastCalibrationResult;
string calibText = UnityCalibUtils.GetCalibString(result);
if (null != result)
{
_QualityText.rectTransform.SetRendererEnabled(true);
_QualityText.text = "<b>Calibration Quality: </b>" + calibText;
}
//restore pre-calibration indicator state
if (_ToggleIndicatorState)
{
_ToggleIndicatorState = !_ToggleIndicatorState;
GazeGUIController.ToggleIndicatorMode();
}
}
}
}
public virtual void OnCalibrationResult(CalibrationResult calibResult)
{
// Dispatch to Unity main thread
_Dispatcher.Dispatch(() =>
{
Debug.Log("OnCalibrationResult: result: " + calibResult.Result + ", Avg error: " + calibResult.AverageErrorDegree);
//Should we resample?
if (!calibResult.Result)
{
//Evaluate results
foreach (var calPoint in calibResult.Calibpoints)
{
if (calPoint.State == CalibrationPoint.STATE_RESAMPLE || calPoint.State == CalibrationPoint.STATE_NO_DATA)
{
_CalibrationPoints.Add(new Point2D(calPoint.Coordinates.X, calPoint.Coordinates.Y));
}
}
//Should we abort?
if (_ResampleCount++ >= NUM_MAX_CALIBRATION_ATTEMPTS || _CalibrationPoints.Count == 0 || _CalibrationPoints.Count >= NUM_MAX_RESAMPLE_POINTS)
{
_CalibrationPoints.Clear();
GazeManager.Instance.CalibrationAbort();
StartCoroutine(_CalibUIRemoteFader.InteruptAndFadeIn());
Debug.Log("Calibration FAIL");
}
else
{
Invoke("ShowNextCalibrationPoint", CALIB_SHOW_NEXT_POINT_DELAY);
}
}
else
{
if (calibResult.AverageErrorDegree < 1.5)
{
Debug.Log("Calibration SUCCESS");
LoadNextScene();
}
else
{
_CalibrationPoints.Clear();
GazeManager.Instance.CalibrationAbort();
StartCoroutine(_CalibUIRemoteFader.InteruptAndFadeIn());
Debug.Log("Calibration FAIL");
}
}
});
}
private static void Calibrate(IEyeTracker eyeTracker)
{
// Create a calibration object.
var calibration = new ScreenBasedCalibration(eyeTracker);
// Define the points on screen we should calibrate at.
// The coordinates are normalized, i.e. (0.0f, 0.0f) is the upper left corner and (1.0f, 1.0f) is the lower right corner.
var 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),
};
// Enter calibration mode.
calibration.EnterCalibrationMode();
// Collect data.
foreach (var point in pointsToCalibrate)
{
// Show an image on screen where you want to calibrate.
Console.WriteLine("Show point on screen at ({0}, {1})", point.X, point.Y);
// Wait a little for user to focus.
//System.Threading.Thread.Sleep(700);
// Collect data.,,
CalibrationStatus status = calibration.CollectData(point);
if (status != CalibrationStatus.Success)
{
// Try again if it didn't go well the first time.
// Not all eye tracker models will fail at this point, but instead fail on ComputeAndApply.
calibration.CollectData(point);
}
}
// Compute and apply the calibration.
CalibrationResult calibrationResult = calibration.ComputeAndApply();
Console.WriteLine("Compute and apply returned {0} and collected at {1} points.",
calibrationResult.Status, calibrationResult.CalibrationPoints.Count);
// Analyze the data and maybe remove points that weren't good.
calibration.DiscardData(new NormalizedPoint2D(0.1f, 0.1f));
// Redo collection at the discarded point.
Console.WriteLine("Show point on screen at ({0}, {1})", 0.1f, 0.1f);
calibration.CollectData(new NormalizedPoint2D(0.1f, 0.1f));
// Compute and apply again.
calibrationResult = calibration.ComputeAndApply();
Console.WriteLine("Second compute and apply returned {0} and collected at {1} points.",
calibrationResult.Status, calibrationResult.CalibrationPoints.Count);
// See that you're happy with the result.
// The calibration is done. Leave calibration mode.
calibration.LeaveCalibrationMode();
}
public Calibration(string vinNumber)
{
InitializeComponent();
StackVinDisplay.SetValue(IsVisibleProperty, false);
CalibrationResult.SetValue(IsVisibleProperty, false);
vinEnterLayout.SetValue(IsVisibleProperty, true);
actIndicator2.IsRunning = false;
VehicleDetailsLabel.SetValue(IsVisibleProperty, false);
VinNumberScan = vinNumber;
}
private int GetStringId(CalibrationResult result)
{
switch (result)
{
default:
case CalibrationResult.Completed:
throw new ArgumentException();
case CalibrationResult.StandardDeviationTooHigh:
return(Resource.String.Vernacular_P0_error_calibration_high_deviation);
}
}
private string GetString(CalibrationResult result)
{
switch (result)
{
default:
case CalibrationResult.Completed:
throw new ArgumentException();
case CalibrationResult.StandardDeviationTooHigh:
return(NSBundle.MainBundle.LocalizedString("Vernacular_P0_error_calibration_high_deviation", null).PrepareForLabel());
}
}
private void CalibrationTerminated(CalibrationResult result)
{
// Hide progress
BTProgressHUD.Dismiss();
if (result != CalibrationResult.Completed)
{
_failedAttempts++;
var title = NSBundle.MainBundle.LocalizedString("Vernacular_P0_error_calibration_high_deviation", null).PrepareForLabel();
var ok = NSBundle.MainBundle.LocalizedString("Vernacular_P0_dialog_ok", null).PrepareForLabel();
//Create Alert
var alertController = UIAlertController.Create(title, GetString(result), UIAlertControllerStyle.Alert);
//Add Actions
alertController.AddAction(UIAlertAction.Create(ok, UIAlertActionStyle.Default, null));
//Present Alert
PresentViewController(alertController, true, null);
if (_failedAttempts >= 3)
{
var errorTitle = NSBundle.MainBundle.LocalizedString("Vernacular_P0_error_generic_reflective", null).PrepareForLabel();
var errorMessage = NSBundle.MainBundle.LocalizedString("Vernacular_P0_error_calibration_several_attempts", null).PrepareForLabel();
//Create Alert
var errorAlertController = UIAlertController.Create(errorTitle, errorMessage, UIAlertControllerStyle.Alert);
//Add Actions
errorAlertController.AddAction(UIAlertAction.Create(ok, UIAlertActionStyle.Default, null));
//Present Alert
PresentViewController(errorAlertController, true, null);
}
}
else
{
SetUiState(Settings.CalibrationDone);
#if DEBUG
//Create Alert
var errorAlertController = UIAlertController.Create("CALIBRATION INFO", string.Format("SCALE FACTOR: {0:F3}", Settings.CalibrationScaleFactor), UIAlertControllerStyle.Alert);
//Add Actions
errorAlertController.AddAction(UIAlertAction.Create("ok", UIAlertActionStyle.Default, null));
//Present Alert
PresentViewController(errorAlertController, true, null);
#endif
}
_calibrating = false;
}
public void OnCalibrationChanged(Boolean isCalibrated,
CalibrationResult calibResult)
{
if (!hasRecievedCalibrationResultChange)
{
hasRecievedCalibrationResultChange = !hasRecievedCalibrationResultChange;
}
if (GazeManager.DebugMode)
{
Debug.WriteLine("Thread: " + Thread.CurrentThread.Name + ", onCalibrationChanged: " + isCalibrated + ", " + calibResult.ToString());
}
}
//called when calibration results are finished processing
public void OnCalibrationResult(CalibrationResult theCalibrationResult)
{
//UnityEngine.Debug.Log("Calibration results: " + theCalibrationResult);
//check for invalid result
if (theCalibrationResult.Result == false)
{
UnityEngine.Debug.Log("Calibration Result Invalid - Resample");
//validate points
foreach (var calPoint in theCalibrationResult.Calibpoints)
{
//if point is flagged for resampling or without data
if (calPoint.State == CalibrationPoint.STATE_RESAMPLE ||
calPoint.State == CalibrationPoint.STATE_NO_DATA)
{
//add point back to calibration list
calPointList.Add(new Point2D(calPoint.Coordinates.X, calPoint.Coordinates.Y));
} //end if
} //end foreach
//abort calibration if max attempts or calibration points exceeded
calAttempts++;
if (calAttempts >= MAX_CAL_ATTEMPT ||
calPointList.Count >= MAX_CAL_RESAMPLE)
{
//clear list
calPointList.Clear();
//abort
GazeManager.Instance.CalibrationAbort();
//show GUI so calibration can be attempted again
hideGUI = false;
//return (exit)
return;
}
//handle in task queue
addTaskToQueue(new taskDelegate(delegate {
//get next calibration point after given delay
Invoke("nextCalPoint", CAL_SAMPLE_SWITCH_DELAY);
}));
} //end outer if
//valid result, handle post-calibration activity
else
{
UnityEngine.Debug.Log("Calibration Result Valid");
//toggle calibration success flag
calSuccess = true;
//show GUI so player can advance to next scene
hideGUI = false;
} //end outer else
} //end function
public void OnCalibrationResult(CalibrationResult calibResult)
{
//Should we resample?
if (!calibResult.Result)
{
//Evaluate results
foreach (CalibrationPoint calPoint in calibResult.Calibpoints)
{
if (calPoint.State == CalibrationPoint.STATE_RESAMPLE || calPoint.State == CalibrationPoint.STATE_NO_DATA)
{
calibrationPoints.Add(new Point2D(calPoint.Coordinates.X, calPoint.Coordinates.Y));
}
}
if (resampleCount++ >= MaxCalibrationAttempts)
{
calibrationPoints.Clear();
DispatchResult(CalibrationRunnerResult.Failure, "Exceeded max calibration attempts: " + MaxCalibrationAttempts);
return;
}
if (calibrationPoints.Count >= MaxResamplePoints)
{
calibrationPoints.Clear();
DispatchResult(CalibrationRunnerResult.Failure, "Exceeded max resample of calibration points: " + MaxResamplePoints);
return;
}
//Handle on main UI thread
QueueCallback(new Callback(delegate
{
Invoke("MoveToNextCalibrationPoint", EyeSettleDuration);
}));
}
else
{
int ratingValue;
string ratingText;
CalibrationRatingFunction(calibResult, out ratingValue, out ratingText);
DispatchResult(CalibrationRunnerResult.Success,
string.Format("Successfully calibrated TheEyeTribe eye tracker.\nCalibration rating: {0}\nAverageErrorDegree = {1}\nAverageErrorDegreeLeft = {2}\nAverageErrorDegreeRight = {3}\n",
ratingText,
calibResult.AverageErrorDegree,
calibResult.AverageErrorDegreeLeft,
calibResult.AverageErrorDegreeRight),
ratingText,
calibResult);
}
}
public void OnCalibrationResult(CalibrationResult calibResult)
{
//Should we resample?
if (!calibResult.Result)
{
//Evaluate results
foreach (var calPoint in calibResult.Calibpoints)
{
if (calPoint.State == CalibrationPoint.STATE_RESAMPLE || calPoint.State == CalibrationPoint.STATE_NO_DATA)
{
_CalibrationPoints.Add(new Point2D(calPoint.Coordinates.X, calPoint.Coordinates.Y));
}
}
//Should we abort?
if (_ResampleCount++ >= NUM_MAX_CALIBRATION_ATTEMPTS || _CalibrationPoints.Count >= NUM_MAX_RESAMPLE_POINTS)
{
_CalibrationPoints.Clear();
GazeManager.Instance.CalibrationAbort();
return;
}
//Handle on main UI thread
QueueCallback(new Callback(delegate
{
Invoke("showNextCalibrationPoint", .25f);
}));
}
else
{
if (calibResult.AverageErrorDegree < 1.5)
{
//Handle on main UI thread
QueueCallback(new Callback(delegate
{
Controller.Instance.mouse = false;
SceneManager.LoadScene("MainMenu");
}));
}
else
{
_CalibrationPoints.Clear();
GazeManager.Instance.CalibrationAbort();
return;
}
}
}
private string RatingFunction(CalibrationResult result)
{
if (result == null)
return "";
double accuracy = result.AverageErrorDegree;
if (accuracy < 0.5)
return "Calibration Quality: PERFECT";
if (accuracy < 0.7)
return "Calibration Quality: GOOD";
if (accuracy < 1)
return "Calibration Quality: MODERATE";
if (accuracy < 1.5)
return "Calibration Quality: POOR";
return "Calibration Quality: REDO";
}
public void TestCalibrationResult()
{
CalibrationResult cr = new CalibrationResult();
cr.AverageErrorDegree = 11.1d;
cr.AverageErrorDegreeRight = 800.13d;
CalibrationPoint cp = new CalibrationPoint();
cp.StandardDeviation.Left = 123.123d;
cp.Accuracy.Left = 324.159d;
cp.MeanError.Left = 657.159d;
cp.Coordinates = new Point2D(321.123f, 432.234f);
cr.Calibpoints = new CalibrationPoint[] { cp };
String json = JsonConvert.SerializeObject(cr);
CalibrationResult cr2 = JsonConvert.DeserializeObject<CalibrationResult>(json);
Assert.AreEqual(cr, cr2);
Assert.AreEqual(cr.GetHashCode(), cr2.GetHashCode());
}
public void OnCalibrationResult(CalibrationResult calibResult)
{
resultWasCalled = true;
result = calibResult;
}
public void OnCalibrationChanged(Boolean isCalibrated,
CalibrationResult calibResult)
{
if (!hasRecievedCalibrationResultChange)
hasRecievedCalibrationResultChange = !hasRecievedCalibrationResultChange;
if (GazeManager.DebugMode)
Debug.WriteLine("Thread: " + Thread.CurrentThread.Name + ", onCalibrationChanged: " + isCalibrated + ", " + calibResult.ToString());
}
