/// <summary>
/// Returns the pixel positions of the four corners of the object's 2D bounding box on the image.
/// <para>Like most of Unity, the Y values are relative to the bottom of the image, which is unlike the
/// raw imageBoundingBox data from the ObjectData struct.</para>
/// 0 ------- 1
/// | obj |
/// 3-------- 2
/// </summary>
/// <param name="scaleForCanvasUnityError">Adds an optional scaling factor to handle a bug in 2018.3 and greater where the
/// canvas set to Screen Space - Camera has very weird offsets when its projection matrix has certain small changes made to it directly.</param>
public Vector2[] Get2DBoundingBoxCorners_Image(float scaleForCanvasUnityError = 1)
{
//Shorthand.
float zedimagewidth = detectingZEDManager.zedCamera.ImageWidth;
float zedimageheight = detectingZEDManager.zedCamera.ImageHeight;
//Canvas offsets from horizontal and vertical calibration offsets (cx/cy).
CalibrationParameters calib = detectingZEDManager.zedCamera.GetCalibrationParameters();
float cxoffset = zedimagewidth * scaleForCanvasUnityError / 2f - calib.leftCam.cx * scaleForCanvasUnityError;
float cyoffset = 0 - (zedimageheight / 2f - calib.leftCam.cy);
Vector2[] flippedYimagecoords = new Vector2[4];
for (int i = 0; i < 4; i++)
{
Vector2 rawcoord;
rawcoord.x = objectData.imageBoundingBox[i].x * scaleForCanvasUnityError + cxoffset;
rawcoord.y = detectingZEDManager.zedCamera.ImageHeight - objectData.imageBoundingBox[i].y + cyoffset;
#if UNITY_2018_1_OR_NEWER
//Terrible hack to compensate for bug in Unity that scales the Canvas very improperly if you have certain (necessary) values on the projection matrix.
rawcoord.y = (rawcoord.y - (zedimageheight / 2f)) * scaleForCanvasUnityError + (zedimageheight / 2f);
#endif
flippedYimagecoords[i] = rawcoord;
}
return(flippedYimagecoords);
}
public CameraParas GetCameraPara()
{
ZEDCamera zedCam = zedManager.zedCamera;
CalibrationParameters para = zedCam.GetCalibrationParameters();
CameraParas fypPara = new CameraParas();
fypPara.cx = para.leftCam.cx;
fypPara.cy = para.leftCam.cy;
fypPara.fx = para.leftCam.fx;
fypPara.fy = para.leftCam.fy;
fypPara.ResolutionWidth = (int)para.leftCam.resolution.width;
fypPara.ResolutionHeight = (int)para.leftCam.resolution.height;
return(fypPara);
}
private float[] AdjustSensorData(int[] rawData, CalibrationParameters calParams)
{
float[] calibratedValues = new float[rawData.Length];
float[] rotatedValues = new float[rawData.Length];
//Apply the calibration parameters
for (int i = 0; i < rawData.Length; i++)
{
calibratedValues[i] = (float)rawData[i];
calibratedValues[i] -= calParams.LevelShift;
calibratedValues[i] -= calParams.ChannelOffset[i];
calibratedValues[i] *= calParams.CalFactor;
calibratedValues[i] /= calParams.CalDivisor;
}
// Apply the rotation matrix
// [Rotation] * [XYZ]
rotatedValues[0] = (calParams.RotationMatrix[0, 0] * calibratedValues[0]) + (calParams.RotationMatrix[0, 1] * calibratedValues[1]) + (calParams.RotationMatrix[0, 2] * calibratedValues[2]);
rotatedValues[1] = (calParams.RotationMatrix[1, 0] * calibratedValues[0]) + (calParams.RotationMatrix[1, 1] * calibratedValues[1]) + (calParams.RotationMatrix[1, 2] * calibratedValues[2]);
rotatedValues[2] = (calParams.RotationMatrix[2, 0] * calibratedValues[0]) + (calParams.RotationMatrix[2, 1] * calibratedValues[1]) + (calParams.RotationMatrix[2, 2] * calibratedValues[2]);
return(rotatedValues);
}
private void tcpipServer_OnCalibrationParameters(CalibrationParameters calParams)
{
// Todo: Should be sent from the tracker after applying settings everywhere..
Tracker.Instance.Server.SendMessage(Commands.CalibrationParameters, calParams.ParametersAsString);
}
///<summary>
/// Event fired when a data is received from the Alchemy Websockets server instance.
/// Parses data as JSON and calls the appropriate message or sends an error message.
/// </summary>
/// <param name="context">The user's connection context</param>
public static void OnReceive(UserContext context)
{
try
{
cont = context;
var json = context.DataFrame.ToString();
Console.WriteLine(json);
dynamic obj = JsonConvert.DeserializeObject(json);
Console.WriteLine(obj.TYPE);
if ((obj.TYPE) == ("IDENTIFICATION"))
{
string name = "EyeTrackerClient";
var r = new Response {
TYPE = "IDENTIFICATION", DATA = name
};
context.Send(JsonConvert.SerializeObject(r));
}
if ((obj.TYPE) == ("IDENTIFICATION_COMPLETE"))
{
// devo recuperare ID salvato su file ini per esempio!
// se è vuoto restituisco stringa vuota
// se c'è invece restituisco stringa con id: TYPE: MACHINE_ID, DATA: valore
XmlReader reader = XmlReader.Create("Settings.xml");
string ID = "";
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "EyeTracker")
{
ID = reader.GetAttribute(0);
}
}
if (ID.Equals(""))
{
var r = new Response {
TYPE = "MACHINE_ID", DATA = ""
};
context.Send(JsonConvert.SerializeObject(r));
}
else
{
var r = new Response {
TYPE = "MACHINE_ID", DATA = ID
};
context.Send(JsonConvert.SerializeObject(r));
}
}
if ((obj.TYPE) == ("OFFSET_CALCULATION"))
{
if ((obj.TODO) == ("true"))
{
var r = new Response {
TYPE = "START_OFFSET_CALCULATION", DATA = ""
};
context.Send(JsonConvert.SerializeObject(r));
}
else
{
var r = new Response {
TYPE = "READY_TO_PLAY", DATA = ""
};
context.Send(JsonConvert.SerializeObject(r));
}
}
if ((obj.TYPE) == ("CALCULATING"))
{
// spedisco pacchetto TYPE: CALCULATING, DATA: data corrente in mill dal 1970
DateTime baseDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
TimeSpan diff = DateTime.UtcNow - baseDate;
var r = new Response {
TYPE = "CALCULATING", DATA = (long)(diff.TotalMilliseconds)
};
context.Send(JsonConvert.SerializeObject(r));
}
if ((obj.TYPE) == ("OFFSET_CALCULATION_COMPLETE"))
{
int id = obj.MACHINE_ID;
//devo salvare valore ID dell'EyeTracker dentro il file xml
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter writer = XmlWriter.Create("Settings.xml", settings);
writer.WriteStartDocument();
writer.WriteComment("This file is generated by the program.");
writer.WriteStartElement("EyeTracker");
writer.WriteAttributeString("ID", id.ToString());
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
var r = new Response {
TYPE = "READY_TO_PLAY", DATA = ""
};
context.Send(JsonConvert.SerializeObject(r));
}
if ((obj.TYPE) == ("TRAINING_SESSION"))
{
int pID = obj.PATIENT_ID;
if (IDSession == pID)
{
var r = new Response {
TYPE = "TRAINING_SESSION", DATA = "false"
};
context.Send(JsonConvert.SerializeObject(r));
}
else
{
IDSession = pID;
var r = new Response {
TYPE = "TRAINING_SESSION", DATA = "true"
};
context.Send(JsonConvert.SerializeObject(r));
}
}
if ((obj.TYPE) == ("SCREEN_MEASURES"))
{
receivedWidth = obj.SCREEN_WIDTH;
receivedHeight = obj.SCREEN_HEIGHT;
gtClient.Calibration.AreaSize(receivedWidth, receivedHeight);
}
if ((obj.TYPE) == ("START_TRAINING"))
{
CalibrationParameters parametri = new CalibrationParameters();
parametri.NumberOfPoints = obj.POINTS;
parametri.PointDiameter = obj.POINT_DIAMETER;
parametri.PointDuration = obj.POINT_DURATION;
parametri.PointTransitionDuration = obj.TRANSITION_DURATION;
gtClient.Calibration.CalibrationParameters(parametri);
gtClient.Calibration.Start();
}
if ((obj.TYPE) == ("TRAINING_VALIDATION"))
{
if ((obj.DATA) == "true")
{
gtClient.Calibration.Validate();
}
else
{
gtClient.Calibration.Abort();
}
}
if ((obj.TYPE) == ("START_WORKING"))
{
// Devo Partire tra START_TIME - ora attuale millisecondi
StartTime = new DateTime(1970, 01, 01).AddMilliseconds((double)obj.START_TIME);
TimeSpan time = StartTime - DateTime.UtcNow;
System.Threading.Thread.Sleep(time);
gtClient.Stream.StreamStart();
onStream = true;
}
if ((obj.TYPE) == ("STOP_GAME"))
{
gtClient.Stream.StreamStop();
onStream = false;
}
}
catch (Exception e) // Bad JSON! For shame.
{
var r = new Response {
TYPE = "Errore: ", DATA = new { e.Message }
};
context.Send(JsonConvert.SerializeObject(r));
}
}
public virtual bool setCalibrationParameters(int axis, CalibrationParameters arg1)
{
bool ret = yarpPINVOKE.IControlCalibration2_setCalibrationParameters(swigCPtr, axis, CalibrationParameters.getCPtr(arg1));
if (yarpPINVOKE.SWIGPendingException.Pending) throw yarpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void SendCommand(string command)
{
UpdateCommandLog(InstanceCommand);
char[] seperator = { ' ' };
string[] cmds = command.Split(seperator, 2);
string cmdStr = cmds[0];
string paramStr = "";
if (cmds.Length > 1)
{
paramStr = cmds[1];
}
switch (cmdStr)
{
// Calibration
case Commands.CalibrationStart:
client.Calibration.Start();
WindowState = WindowState.Minimized;
break;
case Commands.CalibrationAbort:
client.Calibration.Abort();
break;
case Commands.CalibrationParameters:
var calParams = new CalibrationParameters();
calParams.ExtractParametersFromString(paramStr);
client.Calibration.CalibrationParameters(calParams);
break;
// Stream
case Commands.StreamStart:
client.Stream.StreamStart();
break;
case Commands.StreamStop:
client.Stream.StreamStop();
break;
// Log
case Commands.LogStart:
client.Log.Start();
break;
case Commands.LogStop:
client.Log.Stop();
break;
case Commands.LogPathSet:
client.Log.SetLogPath(paramStr);
break;
case Commands.LogPathGet:
client.Log.GetLogPath();
break;
case Commands.LogWriteLine:
client.Log.WriteLine(paramStr);
break;
// Camera
case Commands.CameraParameters:
client.Camera.ApplyParameters(paramStr);
// available as override w/ string, eg. Brightness=100,Contrast=255 etc.
break;
// U.I
case Commands.UIMinimize:
client.UIControl.Minimize();
break;
case Commands.UIRestore:
client.UIControl.Restore();
break;
case Commands.UISettings:
client.UIControl.Settings();
break;
case Commands.UISettingsCamera:
client.UIControl.SettingsCamera();
break;
// Mouse control
case "MouseControl_Enable:":
client.MouseControl.IsEnabled = true;
break;
case "MouseControl_Disable:":
client.MouseControl.IsEnabled = false;
break;
}
}
private void Calibration_OnParameters(CalibrationParameters calParams)
{
Show("Calibration parameters changed.", calParams.ParametersAsString);
}
public System.Collections.Generic.List <Tuple <int, int> > GetBadPixels()
{
var calibrationParameters = new CalibrationParameters();
return(calibrationParameters.badPixels);
}
public void GateWriteCalibrationParameters(CalibrationParameters Parameters)
{
Channel.GateWriteCalibrationParameters(Parameters);
}
internal static HandleRef getCPtr(CalibrationParameters obj)
{
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
