private void Update()
{
//if (SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.WORKING &&
// SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.NOT_SUPPORT) return;
//if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == true && eye_callback_registered == false)
//{
// SRanipal_Eye.WrapperRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye.CallbackBasic)EyeCallback));
// eye_callback_registered = true;
// test = 1;
//}
//else if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == false && eye_callback_registered == true)
//{
// SRanipal_Eye.WrapperUnRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye.CallbackBasic)EyeCallback));
// eye_callback_registered = false;
// test = 2;
//}
//else
//{
// SRanipal_Eye.WrapperUnRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye.CallbackBasic)EyeCallback));
// test = 3;
//}
SRanipal_Eye_API.GetEyeData(ref eye_data);
left_width = eye_data.verbose_data.left.pupil_diameter_mm;
right_width = eye_data.verbose_data.right.pupil_diameter_mm;
}
// ********************************************************************************************************************
//
// Calibration is performed if the calibration is necessary.
//
// ********************************************************************************************************************
void Calibration()
{
SRanipal_Eye_API.IsUserNeedCalibration(ref cal_need); // Check the calibration status. If needed, we perform the calibration.
if (cal_need == true)
{
result_cal = SRanipal_Eye_v2.LaunchEyeCalibration();
if (result_cal == true)
{
Debug.Log("Calibration is done successfully.");
}
else
{
Debug.Log("Calibration is failed.");
if (UnityEditor.EditorApplication.isPlaying)
{
UnityEditor.EditorApplication.isPlaying = false; // Stops Unity editor if the calibration if failed.
}
}
}
if (cal_need == false)
{
Debug.Log("Calibration is not necessary");
}
}
// ********************************************************************************************************************
//
// Check if the system works properly.
//
// ********************************************************************************************************************
void SystemCheck()
{
if (SRanipal_Eye_API.GetEyeData_v2(ref eyeData) == ViveSR.Error.WORK)
{
Debug.Log("Device is working properly.");
}
if (SRanipal_Eye_API.GetEyeParameter(ref eye_parameter) == ViveSR.Error.WORK)
{
Debug.Log("Eye parameters are measured.");
}
// Check again if the initialisation of eye tracking functions successfully. If not, we stop playing Unity.
Error result_eye_init = SRanipal_API.Initial(SRanipal_Eye_v2.ANIPAL_TYPE_EYE_V2, IntPtr.Zero);
if (result_eye_init == Error.WORK)
{
Debug.Log("[SRanipal] Initial Eye v2: " + result_eye_init);
}
else
{
Debug.LogError("[SRanipal] Initial Eye v2: " + result_eye_init);
if (UnityEditor.EditorApplication.isPlaying)
{
UnityEditor.EditorApplication.isPlaying = false; // Stops Unity editor.
}
}
}
public bool Initialize()
{
if (!SRanipal_Eye_API.IsViveProEye())
{
return(false);
}
// InitializeSranipal();
return(SRanipal_Eye_Framework.Status == SRanipal_Eye_Framework.FrameworkStatus.WORKING);
}
private void ApplyEyeTracking()
{
if (workable != true)
{
return;
}
EyeData EyeData_ = new EyeData();
var result = SRanipal_Eye_API.GetEyeData(ref EyeData_);
UpdateEye(EyeData_);
}
public bool Initialize(FieldOfUse fieldOfUse)
{
if (!SRanipal_Eye_API.IsViveProEye())
{
return(false);
}
_hmdToWorldTransformer = new HmdToWorldTransformer(estimatedEyeTrackerLatency_s: 0.040f);
EnsureHTCFrameworkRunning();
return(SRanipal_Eye_Framework.Status == SRanipal_Eye_Framework.FrameworkStatus.WORKING);
}
private void Start()
{
if (!SRanipal_Eye_API.IsViveProEye())
{
_logger.Trace($"Is not ProEye, exit.");
return;
}
_eyeMgr = GetComponentInChildren <EyeTrackingManager>();
if (_eyeMgr)
{
_logger.Trace($"Found EyeTrackingManager.");
}
_mesh = _eyeMgr.targetMesh;
if (_mesh)
{
_logger.Trace($"Found SkinnedMeshRenderer.");
}
_animator = GetComponentInChildren <Animator>();
if (!_animator)
{
return;
}
var leftEyeTransform = _animator.GetBoneTransform(HumanBodyBones.LeftEye);
var rightEyeTransform = _animator.GetBoneTransform(HumanBodyBones.RightEye);
if (!leftEyeTransform || !rightEyeTransform)
{
_logger.Trace($"Eye Tracking: Cannnot get Eye Transform.");
return;
}
basicLeftEyeRot = leftEyeTransform.localRotation;
basicRightEyeRot = rightEyeTransform.localRotation;
if (SRStatus == FrameworkStatus.WORKING)
{
workable = true;
return;
}
Error result = SRanipal_API.Initial(SRanipal_Eye.ANIPAL_TYPE_EYE, IntPtr.Zero);
if (result == Error.WORK)
{
_logger.Trace($"Initial Eye: {result}");
SRStatus = FrameworkStatus.WORKING;
workable = true;
}
else
{
_logger.Error($"Initial Eye: {result}");
SRStatus = FrameworkStatus.ERROR;
}
}
private void Update()
{
//listen to key control inputs
if (runCalibrationOnKeypress && Input.GetKeyDown(CalibrationKey))
{
SRanipal_Eye_API.LaunchEyeCalibration(System.IntPtr.Zero);
}
if (Input.GetKeyDown(GazeVisualizationKey))
{
drawGazeSphere = !drawGazeSphere;
gazeSphere.SetActive(drawGazeSphere);
}
}
private static bool UpdateData()
{
if (Time.frameCount == LastUpdateFrame)
{
return(LastUpdateResult == Error.WORK);
}
else
{
LastUpdateFrame = Time.frameCount;
}
LastUpdateResult = SRanipal_Eye_API.GetEyeData(ref EyeData_);
return(LastUpdateResult == Error.WORK);
}
private static void UpdateEye()
{
SRanipal_Eye_API.GetEyeData_v2(ref LatestEyeData);
if (LatestEyeData.verbose_data.right.GetValidity(SingleEyeDataValidity
.SINGLE_EYE_DATA_PUPIL_DIAMETER_VALIDITY))
{
CurrentDiameter = LatestEyeData.verbose_data.right.pupil_diameter_mm;
UpdateMinMaxDilation(LatestEyeData.verbose_data.right.pupil_diameter_mm);
}
else if (LatestEyeData.verbose_data.left.GetValidity(SingleEyeDataValidity
.SINGLE_EYE_DATA_PUPIL_DIAMETER_VALIDITY))
{
CurrentDiameter = LatestEyeData.verbose_data.left.pupil_diameter_mm;
UpdateMinMaxDilation(LatestEyeData.verbose_data.left.pupil_diameter_mm);
}
}
private static bool UpdateData()
{
if (Time.frameCount == LastUpdateFrame)
{
return(LastUpdateResult == Error.WORK);
}
else
{
LastUpdateFrame = Time.frameCount;
}
LastUpdateResult = SRanipal_Eye_API.GetEyeData_v2(ref EyeData_);
//Debug.Log("[EYE V2] LeftWide = " + EyeData_.verbose_data.left.eye_wide);
//Debug.Log("[EYE V2] RightWide = " + EyeData_.verbose_data.right.eye_wide);
return(LastUpdateResult == Error.WORK);
}
public void StartFramework()
{
if (!EnableEye)
{
return;
}
if (Status == FrameworkStatus.WORKING)
{
return;
}
if (!SRanipal_Eye_API.IsViveProEye())
{
Status = FrameworkStatus.NOT_SUPPORT;
return;
}
Status = FrameworkStatus.START;
if (EnableEyeVersion == SupportedEyeVersion.version1)
{
Error result = SRanipal_API.Initial(SRanipal_Eye.ANIPAL_TYPE_EYE, IntPtr.Zero);
if (result == Error.WORK)
{
Debug.Log("[SRanipal] Initial Eye : " + result);
Status = FrameworkStatus.WORKING;
}
else
{
Debug.LogError("[SRanipal] Initial Eye : " + result);
Status = FrameworkStatus.ERROR;
}
}
else
{
Error result = SRanipal_API.Initial(SRanipal_Eye_v2.ANIPAL_TYPE_EYE_V2, IntPtr.Zero);
if (result == Error.WORK)
{
Debug.Log("[SRanipal] Initial Eye v2: " + result);
Status = FrameworkStatus.WORKING;
}
else
{
Debug.LogError("[SRanipal] Initial Eye v2: " + result);
Status = FrameworkStatus.ERROR;
}
}
}
private void Awake()
{
// Tobi XR Settings
TobiiXR.Start(Settings);
// Get the Participant Name
_participantName = PlayerPrefs.HasKey("playerName")
? PlayerPrefs.GetString("playerName")
: "DemoParticipant-" + DateTime.Now.ToFileTime();
if (_participantName.Equals(""))
{
_participantName = "DemoParticipant-" + DateTime.Now.ToFileTime();
}
// Check eye calibration is required.
bool isEyeCalibrationRequired = false;
if (SRanipal_Eye_API.IsViveProEye())
{
int error = SRanipal_Eye_API.IsUserNeedCalibration(ref isEyeCalibrationRequired);
if (isEyeCalibrationRequired)
{
Debug.Log("Eye Calibration Required!");
Logger.Log(LogLevel.INFO, "Eye Calibration Required!");
SRanipal_Eye.LaunchEyeCalibration();
Debug.Log("Eye Calibration error: " + error);
Logger.Log(LogLevel.DEBUG, "Eye Calibration error: " + error);
}
else
{
Debug.Log("Eye Calibration Not Required!");
Logger.Log(LogLevel.INFO, "Eye Calibration Not Required!");
}
}
else
{
Debug.Log("Eye Tracking not supported in this device! Device is not HTC-Vive Pro Eye.");
Logger.Log(LogLevel.INFO, "Eye Tracking not supported in this device! Device is not HTC-Vive Pro Eye.");
enableEyeTracking = false;
}
}
// ********************************************************************************************************************
//
// Measure eye movements in a callback function that HTC SRanipal provides.
//
// ********************************************************************************************************************
void Measurement()
{
EyeParameter eye_parameter = new EyeParameter();
SRanipal_Eye_API.GetEyeParameter(ref eye_parameter);
Data_txt();
if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == true && eye_callback_registered == false)
{
SRanipal_Eye_v2.WrapperRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye_v2.CallbackBasic)EyeCallback));
eye_callback_registered = true;
}
else if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == false && eye_callback_registered == true)
{
SRanipal_Eye_v2.WrapperUnRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye_v2.CallbackBasic)EyeCallback));
eye_callback_registered = false;
}
}
// Update is called once per frame
void Update()
{
var error = SRanipal_Eye_API.GetEyeData(ref EyeData);
var newData = SRanipal_Eye.GetVerboseData(out EyeData.verbose_data);
//No new data received from camera sensor - skip step
if (!newData)
{
return;
}
//Show error only once and not every frame
if (error != ViveSR.Error.WORK && lastError != error)
{
Debug.LogError("An error happened: " + error.ToString());
}
lastError = error;
var leftEye = EyeData.verbose_data.left.gaze_direction_normalized;
var rightEye = EyeData.verbose_data.right.gaze_direction_normalized;
// if (leftEye != Vector3.zero && rightEye != Vector3.zero)
// Debug.Log("Eyes: LEFT:=" + leftEye + ", RIGHT:=" + rightEye);
if (leftEye != Vector3.zero)
{
this.validTracking = true;
CalculateWorldSpace(leftEye);
}
else if (rightEye != Vector3.zero)
{
this.validTracking = true;
CalculateWorldSpace(rightEye);
}
else
{
this.validTracking = false;
}
}
void recordCsv()
{
List <String> data = new List <String>();
data.Add(currentIndex.ToString());
data.Add(currentColor);
data.Add((startedTalking && !stoppedTalking).ToString());
Action <Vector3> addVector3ToCsv = (Vector3 vector3) =>
{
data.Add(vector3.x.ToString());
data.Add(vector3.y.ToString());
data.Add(vector3.z.ToString());
};
Ray cameraRay = Camera.main.ViewportPointToRay(new Vector3(0.5F, 0.5F, 0));
addVector3ToCsv(cameraRay.direction);
Ray gazeRay = new Ray();
SRanipal_Eye.GetGazeRay(GazeIndex.COMBINE, out gazeRay);
addVector3ToCsv(gazeRay.direction);
//EyeData eyeData = new EyeData();
ViveSR.anipal.Eye.EyeData eyeData = new ViveSR.anipal.Eye.EyeData();
SRanipal_Eye_API.GetEyeData(ref eyeData);
data.Add(eyeData.verbose_data.left.pupil_diameter_mm.ToString());
data.Add(eyeData.verbose_data.left.pupil_diameter_mm.ToString());
data.Add(eyeData.verbose_data.left.eye_openness.ToString());
data.Add(eyeData.verbose_data.right.eye_openness.ToString());
csv.Row(data);
}
public void StopFramework()
{
if (SRanipal_Eye_API.IsViveProEye())
{
if (Status != FrameworkStatus.STOP)
{
if (EnableEyeVersion == SupportedEyeVersion.version1)
{
Error result = SRanipal_API.Release(SRanipal_Eye.ANIPAL_TYPE_EYE);
if (result == Error.WORK)
{
Debug.Log("[SRanipal] Release Eye : " + result);
}
else
{
Debug.LogError("[SRanipal] Release Eye : " + result);
}
}
else
{
Error result = SRanipal_API.Release(SRanipal_Eye_v2.ANIPAL_TYPE_EYE_V2);
if (result == Error.WORK)
{
Debug.Log("[SRanipal] Release Eye v2: " + result);
}
else
{
Debug.LogError("[SRanipal] Release Eye v2: " + result);
}
}
}
else
{
Debug.Log("[SRanipal] Stop Framework : module not on");
}
}
Status = FrameworkStatus.STOP;
}
private void OnGUI()
{
if (GUILayout.Button("Set Parameter"))
{
EyeParameter parameter = new EyeParameter
{
gaze_ray_parameter = new GazeRayParameter(),
};
Error error = SRanipal_Eye_API.GetEyeParameter(ref parameter);
Debug.Log("GetEyeParameter: " + error + "\n" +
"sensitive_factor: " + parameter.gaze_ray_parameter.sensitive_factor);
parameter.gaze_ray_parameter.sensitive_factor = parameter.gaze_ray_parameter.sensitive_factor == 1 ? 0.015f : 1;
error = SRanipal_Eye_API.SetEyeParameter(parameter);
Debug.Log("SetEyeParameter: " + error + "\n" +
"sensitive_factor: " + parameter.gaze_ray_parameter.sensitive_factor);
}
if (GUILayout.Button("Launch Calibration"))
{
SRanipal_Eye_API.LaunchEyeCalibration(IntPtr.Zero);
}
}
// ********************************************************************************************************************
//
// Callback function to record the eye movement data.
// Note that SRanipal_Eye_v2 does not work in the function below. It only works under UnityEngine.
//
// ********************************************************************************************************************
private static void EyeCallback(ref EyeData_v2 eye_data)
{
EyeParameter eye_parameter = new EyeParameter();
SRanipal_Eye_API.GetEyeParameter(ref eye_parameter);
eyeData = eye_data;
// ----------------------------------------------------------------------------------------------------------------
// Measure eye movements at the frequency of 120Hz until framecount reaches the maxframe count set.
// ----------------------------------------------------------------------------------------------------------------
while (cnt_callback < maxframe_count)
{
ViveSR.Error error = SRanipal_Eye_API.GetEyeData_v2(ref eyeData);
if (error == ViveSR.Error.WORK)
{
// --------------------------------------------------------------------------------------------------------
// Measure each parameter of eye data that are specified in the guideline of SRanipal SDK.
// --------------------------------------------------------------------------------------------------------
MeasureTime = DateTime.Now.Ticks;
time_stamp = eyeData.timestamp;
frame = eyeData.frame_sequence;
eye_valid_L = eyeData.verbose_data.left.eye_data_validata_bit_mask;
eye_valid_R = eyeData.verbose_data.right.eye_data_validata_bit_mask;
openness_L = eyeData.verbose_data.left.eye_openness;
openness_R = eyeData.verbose_data.right.eye_openness;
pupil_diameter_L = eyeData.verbose_data.left.pupil_diameter_mm;
pupil_diameter_R = eyeData.verbose_data.right.pupil_diameter_mm;
pos_sensor_L = eyeData.verbose_data.left.pupil_position_in_sensor_area;
pos_sensor_R = eyeData.verbose_data.right.pupil_position_in_sensor_area;
gaze_origin_L = eyeData.verbose_data.left.gaze_origin_mm;
gaze_origin_R = eyeData.verbose_data.right.gaze_origin_mm;
gaze_direct_L = eyeData.verbose_data.left.gaze_direction_normalized;
gaze_direct_R = eyeData.verbose_data.right.gaze_direction_normalized;
gaze_sensitive = eye_parameter.gaze_ray_parameter.sensitive_factor;
frown_L = eyeData.expression_data.left.eye_frown;
frown_R = eyeData.expression_data.right.eye_frown;
squeeze_L = eyeData.expression_data.left.eye_squeeze;
squeeze_R = eyeData.expression_data.right.eye_squeeze;
wide_L = eyeData.expression_data.left.eye_wide;
wide_R = eyeData.expression_data.right.eye_wide;
distance_valid_C = eyeData.verbose_data.combined.convergence_distance_validity;
distance_C = eyeData.verbose_data.combined.convergence_distance_mm;
track_imp_cnt = eyeData.verbose_data.tracking_improvements.count;
////track_imp_item = eyeData.verbose_data.tracking_improvements.items;
// Convert the measured data to string data to write in a text file.
string value =
MeasureTime.ToString() + "," +
time_stamp.ToString() + "," +
frame.ToString() + "," +
eye_valid_L.ToString() + "," +
eye_valid_R.ToString() + "," +
openness_L.ToString() + "," +
openness_R.ToString() + "," +
pupil_diameter_L.ToString() + "," +
pupil_diameter_R.ToString() + "," +
pos_sensor_L.x.ToString() + "," +
pos_sensor_L.y.ToString() + "," +
pos_sensor_R.x.ToString() + "," +
pos_sensor_R.y.ToString() + "," +
gaze_origin_L.x.ToString() + "," +
gaze_origin_L.y.ToString() + "," +
gaze_origin_L.z.ToString() + "," +
gaze_origin_R.x.ToString() + "," +
gaze_origin_R.y.ToString() + "," +
gaze_origin_R.z.ToString() + "," +
gaze_direct_L.x.ToString() + "," +
gaze_direct_L.y.ToString() + "," +
gaze_direct_L.z.ToString() + "," +
gaze_direct_R.x.ToString() + "," +
gaze_direct_R.y.ToString() + "," +
gaze_direct_R.z.ToString() + "," +
gaze_sensitive.ToString() + "," +
frown_L.ToString() + "," +
frown_R.ToString() + "," +
squeeze_L.ToString() + "," +
squeeze_R.ToString() + "," +
wide_L.ToString() + "," +
wide_R.ToString() + "," +
distance_valid_C.ToString() + "," +
distance_C.ToString() + "," +
track_imp_cnt.ToString() +
//track_imp_item.ToString() +
Environment.NewLine;
File.AppendAllText("StandardSaccade_" + UserID + ".txt", value);
cnt_callback++;
}
// Break while loop 3 seconds after the saccade tasks are completed. We know the timing at this point by time information.
CurrentTime = DateTime.Now.Ticks;
MeasureEndTime = GetSaccadeEndTime();
if ((CurrentTime - MeasureEndTime > 3 * 10000000) && MeasureEndTime != 0)
{
break;
}
}
}
/// <summary>
/// Unregister a callback function to receive eye camera related data when the module has new outputs.
/// </summary>
/// <param name="callback">function pointer of callback</param>
/// <returns>error code. please refer Error in ViveSR_Enums.h.</returns>
public static int WrapperUnRegisterEyeDataCallback(System.IntPtr callback)
{
return(SRanipal_Eye_API.UnregisterEyeDataCallback(callback));
}
private void Start()
{
if (!SRanipal_Eye_Framework.Instance.EnableEye)
{
enabled = false;
return;
}
if (runCalibrationOnStart)
{
SRanipal_Eye_API.LaunchEyeCalibration(System.IntPtr.Zero);
}
/*GazeRayParameter param = new GazeRayParameter();
* param.sensitive_factor = 1;
* EyeParameter eyeParam = new EyeParameter();
* eyeParam.gaze_ray_parameter = param;
* SRanipal_Eye_API.SetEyeParameter(eyeParam);*/
//instantiate the gaze sphere (either to be usede or not)
gazeSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
Collider gazeSphereCollider = gazeSphere.GetComponent <Collider>();
gazeSphereCollider.enabled = false;
gazeSphere.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
gazeSphere.transform.position = gazeSphereHiddenPosition;
gazeSphere.SetActive(drawGazeSphere);
/*
* ignoreLayer is a bit mask that tells which layers should be subjected to Physics.Raycast function,
* this way it is inverted, so only the layer with id of ignoreLayer is really ignored.
*/
ignoreLayerBitMask = 1 << ignoreLayer;
ignoreLayerBitMask = ~ignoreLayerBitMask;
//init the logger (PathScript, in this case)
if (Logger != null && Logger.GetComponent <PathScript>() != null)
{
LoggerFormatDictionary = Logger.GetComponent <PathScript>().getLogFormat();
//set number format, per what is specified in logger
numberFormat = new NumberFormatInfo();
numberFormat.NumberDecimalSeparator = LoggerFormatDictionary["decimalFormat"];
generateCustomLogVariables();
Logger.GetComponent <PathScript>().generateCustomFileNames(customLogVariables, logName, this.name);
loggerInitialized = true;
//init the stringbuilder
logDataSb = new StringBuilder("", 256);
}
else
{
Debug.LogWarning("No eyetracking logger found on " + Logger.name +
". Therefore, HTC ET script on " + this.name + " not logging.");
}
//init the Canvas GUI fixation logger
if (FixationCanvas == null && logFixationToCanvas)
{
Debug.LogWarning("No fixation canvas for ET logging. Disabling this functionality");
logFixationToCanvas = false;
}
}
private static void Update()
{
for (;;)
{
try
{
if (SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.WORKING &&
SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.NOT_SUPPORT)
{
Thread.Sleep(50);
continue;
}
SRanipal_Eye_API.GetEyeData_v2(ref _latestEyeData);
var CombinedEyeReverse = Vector3.Scale(
_latestEyeData.verbose_data.combined.eye_data.gaze_direction_normalized,
new Vector3(-1, 1, 1));
var LeftEyeReverse = Vector3.Scale(_latestEyeData.verbose_data.left.gaze_direction_normalized,
new Vector3(-1, 1, 1));
var RightEyeReverse = Vector3.Scale(_latestEyeData.verbose_data.right.gaze_direction_normalized,
new Vector3(-1, 1, 1));
if (CombinedEyeReverse != new Vector3(1.0f, -1.0f, -1.0f))
{
SRanipalData["EyesX"] = CombinedEyeReverse.x;
SRanipalData["EyesY"] = CombinedEyeReverse.y;
SRanipalData["LeftEyeX"] = LeftEyeReverse.x;
SRanipalData["LeftEyeY"] = LeftEyeReverse.y;
SRanipalData["RightEyeX"] = RightEyeReverse.x;
SRanipalData["RightEyeY"] = RightEyeReverse.y;
}
SRanipalData["LeftEyeLid"] = _latestEyeData.verbose_data.left.eye_openness;
SRanipalData["RightEyeLid"] = _latestEyeData.verbose_data.right.eye_openness;
if (_latestEyeData.verbose_data.right.GetValidity(SingleEyeDataValidity
.SINGLE_EYE_DATA_PUPIL_DIAMETER_VALIDITY))
{
CurrentDiameter = _latestEyeData.verbose_data.right.pupil_diameter_mm;
if (_latestEyeData.verbose_data.right.eye_openness >= 1f)
{
UpdateMinMaxDilation(_latestEyeData.verbose_data.right.pupil_diameter_mm);
}
}
else if (_latestEyeData.verbose_data.left.GetValidity(SingleEyeDataValidity
.SINGLE_EYE_DATA_PUPIL_DIAMETER_VALIDITY))
{
CurrentDiameter = _latestEyeData.verbose_data.left.pupil_diameter_mm;
if (_latestEyeData.verbose_data.left.eye_openness >= 1f)
{
UpdateMinMaxDilation(_latestEyeData.verbose_data.left.pupil_diameter_mm);
}
}
var normalizedFloat = CurrentDiameter / MinOpen / (MaxOpen - MinOpen);
SRanipalData["EyesDilation"] = Mathf.Clamp(normalizedFloat, 0, 1);
SRanipalData["EyesWiden"] = _latestEyeData.expression_data.left.eye_wide >
_latestEyeData.expression_data.right.eye_wide
? _latestEyeData.expression_data.left.eye_wide
: _latestEyeData.expression_data.right.eye_wide;
SRanipalData["LeftEyeWiden"] = _latestEyeData.expression_data.left.eye_wide;
SRanipalData["RightEyeWiden"] = _latestEyeData.expression_data.right.eye_wide;
SRanipalData["LeftEyeSqueeze"] = _latestEyeData.expression_data.left.eye_squeeze;
SRanipalData["RightEyeSqueeze"] = _latestEyeData.expression_data.right.eye_squeeze;
SRanipalData["EyesSqueeze"] = _latestEyeData.expression_data.left.eye_squeeze >
_latestEyeData.expression_data.right.eye_squeeze
? _latestEyeData.expression_data.left.eye_squeeze
: _latestEyeData.expression_data.right.eye_squeeze;
}
catch (Exception e)
{
if (!(e.InnerException is ThreadAbortException))
{
MelonLogger.LogError("Threading error occured in SRanipalTrack.Update: " + e.Message);
}
}
Thread.Sleep(5);
}
}
public StringBuilder StartTracking(String time, int frameCount, StringBuilder csvLogger)
{
// Get Eye data from TOBI API
TobiiXR_EyeTrackingData localEyeData = TobiiXR.GetEyeTrackingData(TobiiXR_TrackingSpace.Local);
TobiiXR_EyeTrackingData worldEyeData = TobiiXR.GetEyeTrackingData(TobiiXR_TrackingSpace.World);
// Get Eye data from SRNipal
ViveSR.Error error = SRanipal_Eye_API.GetEyeData(ref _eyeData);
if (error == Error.WORK)
{
_sRanipalEyeVerboseData = _eyeData.verbose_data;
// Left Eye Data
SingleEyeData sRleftEyeData = _sRanipalEyeVerboseData.left;
// Right Eye
SingleEyeData sRrightEyeData = _sRanipalEyeVerboseData.right;
// Write in the CSV file
csvLogger.AppendFormat(
"{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}," +
"{19}, {20}, {21}, {22}, {23}, {24}, {25},{26}, {27}, {28}, {29}, {30}, {31}, {32}, {33}, {34}, {35}," +
"{36}, {37}, {38}, {39}",
// Time and Frame count
time, frameCount,
// Convergence Distance
worldEyeData.ConvergenceDistanceIsValid,
worldEyeData.ConvergenceDistance,
// Eye Openness
sRleftEyeData.eye_openness,
sRrightEyeData.eye_openness,
// Eye blinking
localEyeData.IsLeftEyeBlinking,
localEyeData.IsRightEyeBlinking,
// Pupil Diameter
sRleftEyeData.pupil_diameter_mm,
sRrightEyeData.pupil_diameter_mm,
// Pupil Position in Sensor area (x, y)
sRleftEyeData.pupil_position_in_sensor_area.x,
sRleftEyeData.pupil_position_in_sensor_area.y,
sRrightEyeData.pupil_position_in_sensor_area.x,
sRrightEyeData.pupil_position_in_sensor_area.y,
// IS local Gaze Valid
localEyeData.GazeRay.IsValid,
// Local Space Gaze Origin Combined
localEyeData.GazeRay.Origin.x,
localEyeData.GazeRay.Origin.y,
localEyeData.GazeRay.Origin.z,
// Local Space Gaze Direction Combined
localEyeData.GazeRay.Direction.x,
localEyeData.GazeRay.Direction.y,
localEyeData.GazeRay.Direction.z,
// IS World Gaze Valid
worldEyeData.GazeRay.IsValid,
//world space Gaze Origin Combined
worldEyeData.GazeRay.Origin.x,
worldEyeData.GazeRay.Origin.y,
worldEyeData.GazeRay.Origin.z,
// world space Gaze Direction Combined
worldEyeData.GazeRay.Direction.x,
worldEyeData.GazeRay.Direction.y,
worldEyeData.GazeRay.Direction.z,
// Gaze Origin in mm
sRleftEyeData.gaze_origin_mm.x,
sRleftEyeData.gaze_origin_mm.y,
sRleftEyeData.gaze_origin_mm.z,
sRrightEyeData.gaze_origin_mm.x,
sRrightEyeData.gaze_origin_mm.y,
sRrightEyeData.gaze_origin_mm.z,
// Normalized Gaze direction
sRleftEyeData.gaze_direction_normalized.x,
sRleftEyeData.gaze_direction_normalized.y,
sRleftEyeData.gaze_direction_normalized.z,
sRrightEyeData.gaze_direction_normalized.x,
sRrightEyeData.gaze_direction_normalized.y,
sRrightEyeData.gaze_direction_normalized.z
);
csvLogger.AppendLine();
}
return(csvLogger);
}
private void Update()
{
if (SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.WORKING &&
SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.NOT_SUPPORT)
{
return;
}
if (NeededToGetData)
{
if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == true && eye_callback_registered == false)
{
SRanipal_Eye_v2.WrapperRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye_v2.CallbackBasic)EyeCallback));
eye_callback_registered = true;
}
else if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == false && eye_callback_registered == true)
{
SRanipal_Eye_v2.WrapperUnRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye_v2.CallbackBasic)EyeCallback));
eye_callback_registered = false;
}
else if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == false)
{
SRanipal_Eye_API.GetEyeData_v2(ref eyeData);
}
//Debug.Log("[Eye v2] Openness = " + eyeData.verbose_data.left.eye_openness + ", " + eyeData.verbose_data.right.eye_openness);
bool isLeftEyeActive = false;
bool isRightEyeAcitve = false;
if (SRanipal_Eye_Framework.Status == SRanipal_Eye_Framework.FrameworkStatus.WORKING)
{
isLeftEyeActive = eyeData.verbose_data.left.GetValidity(SingleEyeDataValidity.SINGLE_EYE_DATA_GAZE_ORIGIN_VALIDITY);
isRightEyeAcitve = eyeData.verbose_data.right.GetValidity(SingleEyeDataValidity.SINGLE_EYE_DATA_GAZE_ORIGIN_VALIDITY);
}
else if (SRanipal_Eye_Framework.Status == SRanipal_Eye_Framework.FrameworkStatus.NOT_SUPPORT)
{
isLeftEyeActive = true;
isRightEyeAcitve = true;
}
if (isLeftEyeActive || isRightEyeAcitve)
{
if (eye_callback_registered == true)
{
SRanipal_Eye_v2.GetEyeWeightings(out EyeWeightings, eyeData);
}
else
{
SRanipal_Eye_v2.GetEyeWeightings(out EyeWeightings);
}
UpdateEyeShapes(EyeWeightings);
}
else
{
for (int i = 0; i < (int)EyeShape.Max; ++i)
{
bool isBlink = ((EyeShape)i == EyeShape.Eye_Left_Blink || (EyeShape)i == EyeShape.Eye_Right_Blink);
EyeWeightings[(EyeShape)i] = isBlink ? 1 : 0;
}
UpdateEyeShapes(EyeWeightings);
return;
}
Vector3 GazeOriginCombinedLocal, GazeDirectionCombinedLocal = Vector3.zero;
if (eye_callback_registered == true)
{
if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.COMBINE, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal, eyeData))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.LEFT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal, eyeData))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.RIGHT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal, eyeData))
{
}
}
else
{
if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.COMBINE, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.LEFT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.RIGHT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal))
{
}
}
UpdateGazeRay(GazeDirectionCombinedLocal);
}
}
/// <summary>
/// This method launches the eye-tracking calibration process of the Vive Pro Eye.
/// This method can be hooked to a 3D Button
/// </summary>
public void Execute()
{
#if VIVESR
SRanipal_Eye_API.LaunchEyeCalibration(IntPtr.Zero);
#endif
}
/// <summary>
/// This method launches the eye-tracking calibration process of the Vive Pro Eye.
/// This method can be hooked to a 3D Button
/// </summary>
public void Execute()
{
SRanipal_Eye_API.LaunchEyeCalibration(IntPtr.Zero);
}
private void Update()
{
SRanipal_Eye_API.GetEyeData(ref eye);
eyeStatistic.Add(new EyeExportStatistic(eye));
}
/// <summary>
/// Launches anipal's Eye Calibration feature (an overlay program).
/// </summary>
/// <returns>Indicates the resulting ViveSR.Error status of this method.</returns>
public static bool LaunchEyeCalibration()
{
int result = SRanipal_Eye_API.LaunchEyeCalibration(IntPtr.Zero);
return(result == (int)Error.WORK);
}
private void Update()
{
if (SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.WORKING &&
SRanipal_Eye_Framework.Status != SRanipal_Eye_Framework.FrameworkStatus.NOT_SUPPORT)
{
return;
}
if (NeededToGetData)
{
if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == true && eye_callback_registered == false)
{
SRanipal_Eye_v2.WrapperRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye_v2.CallbackBasic)EyeCallback));
eye_callback_registered = true;
}
else if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == false && eye_callback_registered == true)
{
SRanipal_Eye_v2.WrapperUnRegisterEyeDataCallback(Marshal.GetFunctionPointerForDelegate((SRanipal_Eye_v2.CallbackBasic)EyeCallback));
eye_callback_registered = false;
}
else if (SRanipal_Eye_Framework.Instance.EnableEyeDataCallback == false)
{
SRanipal_Eye_API.GetEyeData_v2(ref eyeData);
}
bool isLeftEyeActive = false;
bool isRightEyeAcitve = false;
if (SRanipal_Eye_Framework.Status == SRanipal_Eye_Framework.FrameworkStatus.WORKING)
{
isLeftEyeActive = eyeData.no_user;
isRightEyeAcitve = eyeData.no_user;
}
else if (SRanipal_Eye_Framework.Status == SRanipal_Eye_Framework.FrameworkStatus.NOT_SUPPORT)
{
isLeftEyeActive = true;
isRightEyeAcitve = true;
}
if (isLeftEyeActive || isRightEyeAcitve)
{
if (eye_callback_registered == true)
{
SRanipal_Eye_v2.GetEyeWeightings(out EyeWeightings, eyeData);
}
else
{
SRanipal_Eye_v2.GetEyeWeightings(out EyeWeightings);
}
UpdateEyeShapes(EyeWeightings);
}
else
{
for (int i = 0; i < (int)EyeShape_v2.Max; ++i)
{
bool isBlink = ((EyeShape_v2)i == EyeShape_v2.Eye_Left_Blink || (EyeShape_v2)i == EyeShape_v2.Eye_Right_Blink);
EyeWeightings[(EyeShape_v2)i] = isBlink ? 1 : 0;
}
UpdateEyeShapes(EyeWeightings);
return;
}
Vector3 GazeOriginCombinedLocal, GazeDirectionCombinedLocal = Vector3.zero;
if (eye_callback_registered == true)
{
if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.COMBINE, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal, eyeData))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.LEFT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal, eyeData))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.RIGHT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal, eyeData))
{
}
}
else
{
if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.COMBINE, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.LEFT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal))
{
}
else if (SRanipal_Eye_v2.GetGazeRay(GazeIndex.RIGHT, out GazeOriginCombinedLocal, out GazeDirectionCombinedLocal))
{
}
}
UpdateGazeRay(GazeDirectionCombinedLocal);
}
}
