void Start()
{
_occludeWorld = false;
_reprojectionError = 0.0;
_height = (int)Screen.height;
_width = (int)Screen.width;
_calibrator = new Calibration(_mainCamera);
_calibrating = true;
}
private void ComputeCompleted(object sender, AsyncCompletedEventArgs<Empty> e)
{
_calibrationForm.Close();
if(e.Error != null)
{
_calibrationResult = null;
}
else
{
_calibrationResult = _tracker.GetCalibration();
}
}
public Recalibration()
{
numTargetsForRecalib = 30;
targetCoordinates = new List<Point>(numTargetsForRecalib);
gazeCoordinates = new List<GTPoint>(numTargetsForRecalib);
numRecalibTargets = 0;
calibration = new Calibration();
//if (Settings.Instance.Processing.TrackingGlints)
// calibration = new CalibPolynomial();
//else
// calibration = new CalibPupil();
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
var calibration = new Calibration(calibrationData);
var points = calibration.GetCalibrationPointDataItems();
foreach (var p in points)
{
DrawCircle(Denormalize(new Point(p.TruePosition.X, p.TruePosition.Y)), 10, false, Brushes.Black);
if(p.LeftStatus == CalibrationPointStatus.CalibrationPointValidAndUsedInCalibration)
DrawCircle(Denormalize(new Point(p.LeftMapPosition.X, p.LeftMapPosition.Y)), 5, true, Brushes.Green);
if (p.RightStatus == CalibrationPointStatus.CalibrationPointValidAndUsedInCalibration)
DrawCircle(Denormalize(new Point(p.RightMapPosition.X, p.RightMapPosition.Y)), 5, true, Brushes.Red);
}
}
public List <Calibration> GetCalibrations(DbCommand command)
{
List <Calibration> calibrations = new List <Calibration>();
using (var reader = DatabaseProvider.ExecuteReader(command))
{
while (reader.Read())
{
Calibration calibration = new Calibration();
calibration.CalibrationTime = reader.GetColumnValue <DateTime>("CalibrationTime");
calibration.Username = reader.GetColumnValue <string>("Username");
calibration.Workstation = reader.GetColumnValue <string>("Workstation");
calibration.Comments = reader.GetColumnValue <string>("Comments");
calibrations.Add(calibration);
}
}
return(calibrations);
}
internal static int Delete(Calibration calibration)
{
SqlConnection conn = null;
SqlCommand cmd = null;
var recordsAffected = 0;
try
{
conn = TwisterConnection();
cmd = CreateCommand(conn, "up_DeleteCalibration");
// add the two parameters needed.
cmd.Parameters.Add(new SqlParameter
{
ParameterName = "@PartNumber",
Value = calibration.PartNumber == null ? DBNull.Value : (object)calibration.PartNumber,
SqlDbType = SqlDbType.NVarChar
});
cmd.Parameters.Add(new SqlParameter
{
ParameterName = "@Revision",
Value = calibration.Revision == null ? DBNull.Value : (object)calibration.Revision,
SqlDbType = SqlDbType.NVarChar
});
recordsAffected = cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
finally
{
// do the cleanup
if (cmd != null)
{
cmd.Dispose();
}
CloseConnection(conn);
}
return(recordsAffected);
}
public RemotePositionsRallyViewModel(RemoteViewModel remoteViewModel, Calibration cal)
{
this.remoteViewModel = remoteViewModel;
this.cal = cal;
cal.StrokePositionCalculated += OnStrokePositionCalculated;
cal.PointAdded += OnPointAdded;
ToogleCalibrationButtonImage = "/resources/visible.png";
DrawnStrokes = new ObservableCollection <DrawElement>();
showBottomLeftArrow = false;
showBottomRightArrow = false;
showTopLeftArrow = false;
showTopRightArrow = false;
maxVisibleStrokes = "ALL";
}
public async Task <List <Calibration> > GetCalibrations(string data)
{
if (!A2LCollection.IsRecordLayoutsLoaded)
{
await GetRecordLayouts(data);
}
if (!A2LCollection.IsCompuMethodsLoaded)
{
A2LCollection.CompuMethods = await GetCompuMethods(data);
}
List <Calibration> Calibrations = new List <Calibration>();
foreach (string calibrationStr in GetFirstInstanceTextBetween(data, C_ST_START, C_ST_END))
{
Calibration calib = new Calibration();
string[] strSplt = calibrationStr.Split('\n');
calib.Name = strSplt[0].Cleanup();
calib.Description = strSplt[1].Cleanup();
calib.Type = strSplt[2].Cleanup().ToEnum <CalibrationType>();
calib.ECU_Address = strSplt[3].Cleanup();
var recordLayoutRefIndex = RecordLayoutRef.IndexOf(strSplt[4].Cleanup());
if (recordLayoutRefIndex != -1)
{
calib.RecordLayoutReference = A2LCollection.RecordLayouts[recordLayoutRefIndex];
}
calib.MaxDifference = double.Parse(strSplt[5].Cleanup());
var compuMethodRefIndex = CompuMethodRef.IndexOf(strSplt[6].Cleanup());
if (compuMethodRefIndex != -1)
{
calib.CompuMethod = A2LCollection.CompuMethods[compuMethodRefIndex];
}
calib.Minimum = double.Parse(strSplt[7].Cleanup());
calib.Maximum = double.Parse(strSplt[8].Cleanup());
if (calib.Type == CalibrationType.CUBE_4 || calib.Type == CalibrationType.CUBE_5 || calib.Type == CalibrationType.CUBOID || calib.Type == CalibrationType.CURVE || calib.Type == CalibrationType.MAP)
{
calib.AxisDescriptors = await GetAxisDescriptors(calibrationStr);
}
CalibrationRef.Add(calib.Name);
Calibrations.Add(calib);
}
A2LCollection.IsCalibrationsLoaded = true;
return(Calibrations);
}
private void DrawPopup()
{
if (popUp)
{
GUI.Box(new Rect(scaledResolutionWidth / 2 - 350, nativeVerticalResolution / 2 - 445, 700, 750), "", "Window");
if (calibrationError)
{
GUI.Box(new Rect(scaledResolutionWidth / 2 - 270, nativeVerticalResolution / 2 - 400, 540, 540), Languages.Instance.GetTranslation("Calibration Error!") + "\n\n" + Languages.Instance.GetTranslation("Make sure the part of the box with 'table' on it is closest to the table."), "EndBox");
if (GUI.Button(new Rect(scaledResolutionWidth / 2 - 150, nativeVerticalResolution - 380, 300, 100), Languages.Instance.GetTranslation("Okay")))
{
popUp = false;
calibrationError = false;
}
}
else
{
GUI.Box(new Rect(scaledResolutionWidth / 2 - 270, nativeVerticalResolution / 2 - 400, 540, 540), Languages.Instance.GetTranslation("Make sure the circle on your calibration box is centered with the patient's body!"), "EndBox");
if (GUI.Button(new Rect(scaledResolutionWidth / 2 - 150, nativeVerticalResolution - 380, 300, 100), Languages.Instance.GetTranslation("Okay")))
{
GameControl.Instance.IsCalibrating = true;
GameControl.Instance.IsCalibrated = false;
try
{
calibration.Kill();
}
catch (Exception)
{ }
EventLogger.Instance.LogData(Languages.Instance.GetTranslation("Calibration Started"));
calibration = new Calibration();
calibration.Calibrate();
popUp = false;
}
}
//if (GUI.Button(new Rect(scaledResolutionWidth / 2 + 15, nativeVerticalResolution - 380, 300, 100), Languages.Instance.GetTranslation("No")))
//{
// popUp = false;
//}
}
}
private void OnGetCalibrationCompleted(Calibration calibration, Tobii.Gaze.Core.ErrorCode errorCode)
{
LookAndPlayForm.Program.datosCompartidos.calibrationDataEyeX = calibration;
CalibrationError errorCalibracion = new CalibrationError(LookAndPlayForm.Program.datosCompartidos.calibrationDataEyeX.GetCalibrationPointDataItems());
LookAndPlayForm.Program.datosCompartidos.meanCalibrationErrorLeftPx = errorCalibracion.meanCalibrationErrorLeftPx;
LookAndPlayForm.Program.datosCompartidos.meanCalibrationErrorRightPx = errorCalibracion.meanCalibrationErrorRightPx;
Console.WriteLine("EyetrackingEngine.OnGetCalibrationCompleted. errorCode: " + errorCode.ToString() +
"error: " +
errorCalibracion.meanCalibrationErrorLeftPx.ToString() + ", " +
errorCalibracion.meanCalibrationErrorRightPx.ToString());
if (OnGetCalibrationCompletedEvent != null)
{
OnGetCalibrationCompletedEvent(this, new CalibrationReadyEventArgs(errorCalibracion.CalibrationPointDataL));
}
}
public bool DeleteCalibration(int id)
{
try
{
Calibration calibration = Entities.Calibrations.SingleOrDefault(x => x.CalibrationId == id);
Entities.Calibrations.DeleteObject(calibration);
if (Entities.SaveChanges() > 0)
{
return(true);
}
}
catch (Exception ex)
{
return(false);
}
return(false);
}
public FormWebCamEmgu()
{
InitializeComponent();
MouseRecognitionModule = new MouseRecognition();
if (USE_RED)
{
vizRed = new FormVisualizer(FormVisualizer.DisplayMode.Emgu, "Red");
}
if (USE_GREEN)
{
vizGreen = new FormVisualizer(FormVisualizer.DisplayMode.Emgu, "Green");
}
if (USE_BLUE)
{
vizBlue = new FormVisualizer(FormVisualizer.DisplayMode.Emgu, "Blue");
}
if (USE_YELLOW)
{
vizYellow = new FormVisualizer(FormVisualizer.DisplayMode.Emgu, "Yellow");
}
if (SHOW_FILTERS)
{
vizFilters = new FormVisualizer(FormVisualizer.DisplayMode.Emgu, "Filtered");
}
vizOriginal = new FormVisualizer(FormVisualizer.DisplayMode.Emgu, "Original");
vizDataText = new FormVisualizer(FormVisualizer.DisplayMode.Text, "Text Data");
// For testing purposes
MouseRecognitionModule.vizDataText = vizDataText;
dataMouse = MouseDataContainer.Instance;
calibrateModule = new Calibration();
TimerDispatchPars = new TimerDispatch(TIMER_DISP_INTERVAL);
TimerDispatchPars.TickMethod += timerDispatch_TickMethod;
ReadRegistryValues();
LoadHSVValues();
}
public void TestGuitar()
{
Calibration.Initialize();
for (int octave = 2; octave <= 4; octave++)
{
string guitarFile = DataManagement.PathForDataFile("Test", $"guitarE{octave}.wav");
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: guitarFile,
stream: InstrumentLookup.GetNote(
set: ReservedSoundSet.ElectricGuitar_Jazz,
note: (byte)(12 * octave + 4),
velocity: 0xF7)
.SafeCache()
.SlowRangeFitter(),
overwrite: true));
}
}
public Recording(string mappingParamsPath, string timingPath, string depthPath, DepthFormat dFormat,
string colourPath, ColourFormat cFormat, string calibrationPath) : this()
{
// open mapping data
var fMapping = new FileStream(mappingParamsPath, FileMode.Open);
this.mappingParams = new byte[fMapping.Length];
fMapping.Read(this.mappingParams, 0, this.mappingParams.Length);
fMapping.Close();
// get image file streams ready
this.fDepth = new FileStream(depthPath, FileMode.Open);
this.fColour = new FileStream(colourPath, FileMode.Open);
// deserialise calibration if required
if (calibrationPath == null)
{
this.IsCalibratedRecording = false;
}
else
{
this.calibration = Calibration.CreateFromFile(calibrationPath);
this.IsCalibratedRecording = true;
}
// read and convert timing data to fractional seconds
var fTiming = new FileStream(timingPath, FileMode.Open);
var timingReader = new BinaryReader(fTiming);
this.Timestamps = new float[fTiming.Length / sizeof(Single)];
for (int i = 0; i < this.Timestamps.Length; i++)
{
this.Timestamps[i] = timingReader.ReadSingle();
}
fTiming.Close();
// set other recording properties
this.cFrameSizeBytes = FormatConvertor.ByteDataLength(cFormat);
this.dFrameSizeShorts = FormatConvertor.PixelDataLength(dFormat);
this.NumberOfFrames = (int)this.fDepth.Length / FormatConvertor.ByteDataLength(dFormat);
}
internal static bool TryCreateTrackerHandle(ref Calibration calibration, out NativeHandles.TrackerHandle trackerHandle, out string message)
{
string runtimePath;
lock (bodyTrackingRuntimeInitializationSync)
{
if (string.IsNullOrEmpty(bodyTrackingRuntimePath))
{
bodyTrackingRuntimePath = GetBodyTrackingRuntimePath(out message);
if (string.IsNullOrEmpty(bodyTrackingRuntimePath))
{
trackerHandle = null;
return(false);
}
}
runtimePath = bodyTrackingRuntimePath;
}
// Force loading of k4a.dll,
// because k4abt.dll depends on it
NativeHandles.NativeApi.CaptureRelease(IntPtr.Zero);
// We have to change current directory,
// because Body Tracking runtime will try to load ONNX file from current directory
// (Adding to Path environment variable doesn't work.)
using (new CurrentDirectoryOverrider(runtimePath))
{
if (BodyTracking.NativeApi.TrackerCreate(ref calibration, out trackerHandle) != NativeCallResults.Result.Succeeded ||
trackerHandle == null || trackerHandle.IsInvalid)
{
if (IsBodyTrackingRuntimeAvailable(out message))
{
message = "Cannot initialize body tracking runtime. See logs for details.";
}
return(false);
}
}
message = null;
return(true);
}
// OnCalibrationDone
void FCalibrationRunner_OnCalibrationDone(Calibration cal, bool IsSuccessful)
{
if (IsSuccessful)
{
FLogger.Log(LogType.Debug, "Calibration state exited, calibration successful");
FOutputLastCalibSuccessful[0] = IsSuccessful;
}
else
{
FLogger.Log(LogType.Error, "Calibration state exited, calibration not successful");
FOutputLastCalibSuccessful[0] = IsSuccessful;
}
if (cal != null)
{
WriteCalibDataToOutput(cal);
}
FOutputIsCalibrationState[0] = false;
FOutputIsCollectingSamples[0] = false;
}
/// <summary>
/// Creates a new instance of Joint.
/// A Joint.Builder must be used to create a joint to enforce required and default properties.
/// </summary>
/// <param name="name">The unique name of the joint</param>
/// <param name="type">The type of the joint</param>
/// <param name="parent">The parent link of the joint</param>
/// <param name="child">The child link of the joint</param>
/// <param name="origin">The transform from parent link to child link</param>
/// <param name="axis">The joint axis in the joint frame of reference</param>
/// <param name="calibration">The reference positions of the joint used to calibrate its absolute position</param>
/// <param name="dynamics">The physical properties of the joint</param>
/// <param name="limit">The physical limitations of the joint's movement</param>
/// <param name="mimic">The specification of a joint to mimic</param>
/// <param name="safetyController">The joint property values where its position becomes limited</param>
private Joint(string name, JointType type, Link parent, Link child, Origin origin, Axis axis,
Calibration calibration, Dynamics dynamics, Limit limit, Mimic mimic, SafetyController safetyController)
{
Preconditions.IsNotEmpty(name, "Joint name property must not be null or empty");
Preconditions.IsNotNull(parent, "Joint parent property must not be null");
Preconditions.IsNotNull(child, "Joint child property must not be null");
Preconditions.IsNotNull(origin, "Joint origin property must not be null"); // Default is identity
Preconditions.IsNotNull(axis, "Joint axis property must not be null"); // Default is (1,0,0)
this.Name = name;
this.Type = type;
this.Parent = parent;
this.Child = child;
this.Origin = origin;
this.Axis = axis;
this.Calibration = calibration;
this.Dynamics = dynamics;
this.Limit = limit;
this.Mimic = mimic;
this.SafetyController = safetyController;
}
public void TestRenderToccataMidi()
{
Calibration.Initialize();
string loadFile = DataManagement.PathForDataFile("Test", "toccata1.mid");
string saveFile = DataManagement.PathForDataFile("Test", "toccata1.wav");
Assert.IsTrue(MidiEncoding.LoadFile(
filePath: loadFile,
midiFile: out MidiFile midiFile,
retainAll: true));
Assert.IsTrue(WaveEncoding.SaveStream(
filepath: saveFile,
stream: new SlowRangeFitterFilter(new MidiFileStream(midiFile).SafeCache()),
overwrite: true));
Assert.IsTrue(File.Exists(saveFile));
}
private void calibrationToolStripMenuItem_Click(object sender, EventArgs e)
{
//enter calibration
conductor.calibrating = true;
joy.calibrating = true;
mic.calibrating = true;
calibrating = true;
Calibration cal = new Calibration();
cal.SetConductor(ref conductor);
cal.SetCalibration(conductor.GetCalibration());
cal.ShowDialog();
// exit calibration
conductor.calibrating = false;
calibrating = false;
joy.calibrating = false;
mic.calibrating = false;
}
//private delegate void DisplayDataCallback(StrideDiagnostics diagnosticData);
public frmUI()
{
InitializeComponent();
this.Text = "StromoLight Diagnostics";
this.Size = new Size(System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Width, this.Height);
//asymmetryAnalyser = new AsymmetryAnalysis();4
//AsymmetryAnalysis.DataAvailable +=
//new AsymmetryAnalysis.AsymmetryEventHandler(Asymmetry_DataAvailable);5
//feetSound = new Sonifier();6
//feetSound.Enabled = false;7
//asymmetryAnalyser.Enabled = false;8
SendStartupNotification();
markerHeightCal = (Calibration)RemotingServices.Connect(typeof(Calibration), "tcp://144.32.137.126:8003/Calibration");
//m_calibration = (Calibration)RemotingServices.Connect(typeof(Calibration),"tcp://144.32.137.126:8003/Calibration");
}
public ActionResult Details(int id)
{
Calibration obj = new Calibration();
obj = equipmentContext.Calibrations.Single(objid => objid.Id == id);
obj.Department = equipmentContext.Equipments.FirstOrDefault(x => x.Id == obj.AssetReference).Department;
GetDropwnListEdit(obj.AssetReference);
JsonResult jsn = Checkphotoexist(obj.AssetReference);
if (jsn.Data != null && jsn.Data.ToString().Length > 0)
{
ViewBag.Photo = "Yes";
ViewBag.PhotoData = jsn.Data;
}
else
{
ViewBag.Photo = "No";
}
return(View(obj));
}
private static void GetTitleKeys(string nandFile)
{
using (var logger = new ProgressBar())
using (var stream = new FileStream(nandFile, FileMode.Open, FileAccess.Read))
{
Keyset keyset = OpenKeyset();
var nand = new Nand(stream, keyset);
Stream prodinfo = nand.OpenProdInfo();
var calibration = new Calibration(prodinfo);
keyset.EticketExtKeyRsa = Crypto.DecryptRsaKey(calibration.EticketExtKeyRsa, keyset.EticketRsaKek);
Ticket[] tickets = GetTickets(keyset, nand, logger);
foreach (Ticket ticket in tickets)
{
byte[] key = ticket.GetTitleKey(keyset);
logger.LogMessage($"{ticket.RightsId.ToHexString()},{key.ToHexString()}");
}
}
}
private void ComputeCompleted(object sender, AsyncCompletedEventArgs e)
{
if (_calibrationWindow.Dispatcher.CheckAccess())
{
_calibrationWindow.Close();
}
else
{
_calibrationWindow.Dispatcher.BeginInvoke(new Action(() => _calibrationWindow.Close()));
}
if (e.Error != null)
{
_calibrationResult = null;
}
else
{
_calibrationResult = _tracker.GetCalibration();
}
}
public static bool Transformation3dTo3d(Calibration calibration, float[] sourcePoint3d,
CalibrationType sourceCamera, CalibrationType targetCamera, ref float[] targetPoint3d)
{
if (sourceCamera == targetCamera)
{
targetPoint3d[0] = sourcePoint3d[0];
targetPoint3d[1] = sourcePoint3d[1];
targetPoint3d[2] = sourcePoint3d[2];
return(true);
}
bool succeeded = ExtrinsicTransformation.ApplyExtrinsicTransformation(calibration.SourceToTargetExtrinsics, sourcePoint3d, ref targetPoint3d);
if (!succeeded)
{
return(false);
}
return(true);
}
public void ParseJoint()
{
string name = "joint";
string type = "continuous";
Origin origin = new Origin.Builder().SetXyz(new XyzAttribute(1, 2, 3)).SetRpy(new RpyAttribute(1, 2, 3)).Build();
Axis axis = new Axis(new XyzAttribute(1, 2, 3));
Calibration calibration = new Calibration(1, 2);
Dynamics dynamics = new Dynamics(1, 2);
Limit limit = new Limit(1, 2);
Mimic mimic = new Mimic(jointDictionary[MIMIC_JOINT_NAME], 2, 3);
SafetyController safetyController = new SafetyController(1);
StringBuilder xmlBuilder = new StringBuilder();
xmlBuilder.Append(String.Format("<joint name='{0}' type='{1}'>", name, type));
xmlBuilder.Append(String.Format("<origin rpy='{0} {1} {2}' xyz='{3} {4} {5}'/>", origin.Xyz.X, origin.Xyz.Y, origin.Xyz.Z, origin.Rpy.R, origin.Rpy.P, origin.Rpy.Y));
xmlBuilder.Append(String.Format("<parent link='{0}'/>", PARENT_JOINT_NAME));
xmlBuilder.Append(String.Format("<child link='{0}'/>", CHILD_JOINT_NAME));
xmlBuilder.Append(String.Format("<axis xyz='{0} {1} {2}'/>", axis.Xyz.X, axis.Xyz.Y, axis.Xyz.Z));
xmlBuilder.Append(String.Format("<calibration rising='{0}' falling='{1}'/>", calibration.Rising, calibration.Falling));
xmlBuilder.Append(String.Format("<dynamics damping='{0}' friction='{1}'/>", dynamics.Damping, dynamics.Friction));
xmlBuilder.Append(String.Format("<limit lower='{0}' upper='{1}' effort='{2}' velocity='{3}'/>", limit.Lower, limit.Upper, limit.Effort, limit.Velocity));
xmlBuilder.Append(String.Format("<mimic joint='{0}' multiplier='{1}' offset='{2}'/>", MIMIC_JOINT_NAME, mimic.Multiplier, mimic.Offset));
xmlBuilder.Append(String.Format("<safety_controller soft_lower_limit='{0}' soft_upper_limit='{1}' k_position='{2}' k_velocity='{3}'/>", safetyController.SoftLowerLimit, safetyController.SoftUpperLimit, safetyController.KPosition, safetyController.KVelocity));
xmlBuilder.Append("</joint>");
this.xmlDoc.Load(XmlReader.Create(new StringReader(xmlBuilder.ToString())));
Joint joint = this.parser.Parse(this.xmlDoc.DocumentElement);
Assert.AreEqual(name, joint.Name);
Assert.AreEqual(JointParser.GetJointTypeFromName(type), joint.Type);
Assert.AreEqual(origin, joint.Origin);
Assert.AreEqual(PARENT_JOINT_NAME, joint.Parent.Name);
Assert.AreEqual(CHILD_JOINT_NAME, joint.Child.Name);
Assert.AreEqual(axis, joint.Axis);
Assert.AreEqual(calibration, joint.Calibration);
Assert.AreEqual(dynamics, joint.Dynamics);
Assert.AreEqual(limit, joint.Limit);
Assert.AreEqual(mimic, joint.Mimic);
Assert.AreEqual(safetyController, joint.SafetyController);
}
public void OpenSensor(int deviceIndex = 0)
{
_KinectSensor = Device.Open(deviceIndex);
if (_KinectSensor == null)
{
Debug.LogError("AzureKinect cannot be opened.");
return;
}
DeviceConfiguration kinectConfig = new DeviceConfiguration();
kinectConfig.ColorFormat = ColorImageFormat;
kinectConfig.ColorResolution = (ColorResolution)ColorCameraMode;
kinectConfig.DepthMode = (DepthMode)DepthCameraMode;
if (ColorCameraMode != ColorCameraMode._4096_x_3072_15fps &&
DepthCameraMode != DepthCameraMode._1024x1024_15fps)
{
kinectConfig.CameraFPS = FPS.FPS30;
}
else
{
kinectConfig.CameraFPS = FPS.FPS15;
}
_KinectSensor.StartCameras(kinectConfig);
_IsCameraStarted = true;
_DeviceCalibration = _KinectSensor.GetCalibration();
_Transformation = _DeviceCalibration.CreateTransformation();
CameraCalibration colorCamera = _DeviceCalibration.ColorCameraCalibration;
_ColorImageWidth = colorCamera.ResolutionWidth;
_ColorImageHeight = colorCamera.ResolutionHeight;
CameraCalibration depthCamera = _DeviceCalibration.DepthCameraCalibration;
_DepthImageWidth = depthCamera.ResolutionWidth;
_DepthImageHeight = depthCamera.ResolutionHeight;
}
public SqlRawParameter GetSqlRawParameter(Calibration parameters = null)
{
var sqlrawParams = new SqlRawParameter();
var sqlQry = new StringBuilder();
sqlQry.AppendLine("SELECT * FROM Calibrations");
if (parameters == null)
{
sqlrawParams.SqlQuery = sqlQry.ToString();
sqlrawParams.SqlParameters = new List <SqlParameter>();
return(sqlrawParams);
}
var whereClauses = new List <string>();
var sqlParams = new List <SqlParameter>();
if (parameters.CalibrationId.IsNullOrZero() == false)
{
sqlParams.Add(new SqlParameter(nameof(parameters.CalibrationId).Parametarize(), parameters.CalibrationId));
whereClauses.Add($"{nameof(parameters.CalibrationId)} = {nameof(parameters.CalibrationId).Parametarize()}");
}
else
{
if (!parameters.CalibrationTypeId.IsNullOrZero())
{
sqlParams.Add(new SqlParameter(nameof(parameters.CalibrationTypeId).Parametarize(), parameters.CalibrationTypeId));
whereClauses.Add($"{nameof(parameters.CalibrationTypeId)} = {nameof(parameters.CalibrationTypeId).Parametarize()}");
}
}
if (whereClauses.Count > 0)
{
sqlQry.AppendLine(" WHERE ");
sqlQry.AppendLine(String.Join(" AND ", whereClauses.ToArray()));
}
return(new SqlRawParameter()
{
SqlParameters = sqlParams, SqlQuery = sqlQry.ToString()
});
}
public static void Calibrate(string[] args)
{
var fileName = args.Length < 2 ? "data/calibration_dto" : args[1];
var isSecondOrder = args.Length < 3 ? false : Boolean.Parse(args[2]);
string[] lines = File.ReadAllLines(String.Format("{0}.txt", fileName));
var data = lines.Aggregate(new List <CalibrationLine>(), (p, c) =>
{
var split = c.Split(' ');
var result = new CalibrationLine
{
Energy = Double.Parse(split[0]),
Area = Double.Parse(split[1]),
Centroid = Double.Parse(split[2])
};
p.Add(result);
return(p);
});
Calibration.Calibrate(data, isSecondOrder);
}
public Calibration UpdateLastLog(Calibration model)
{
var lastLog = dbContext.CalibrationLogs.AsNoTracking().Where(a => a.CalibrationId == model.CalibrationId).OrderBy(a => a.DTConfirmed).LastOrDefault();
if (lastLog == null)
{
return(null);
}
lastLog.DTActualCalibration = model.DTLastActualCalibration.Value;
dbContext.CalibrationLogs.Update(lastLog);
var calibration = dbContext.Calibrations.AsNoTracking().FirstOrDefault(a => a.CalibrationId == model.CalibrationId);
calibration.DTLastActualCalibration = model.DTLastActualCalibration;
dbContext.Calibrations.Update(model);
dbContext.SaveChanges();
return(calibration);
}
public void TestAllPassFilterSynth()
{
Calibration.Initialize();
IBGCStream[] synthStreams = new IBGCStream[]
{
new SineWave(1f, 440f).Window(DURATION),
new SquareWave(1f, 440f).Window(DURATION),
new SawtoothWave(1f, 440f).Window(DURATION),
new TriangleWave(1f, 440f).Window(DURATION)
};
foreach (IBGCStream stream in synthStreams)
{
bool success = TryAllpassFilters(
stream: stream,
baseName: stream.GetType().Name.Substring(0, 4));
Assert.IsTrue(success);
}
}
public BackgroundTrackingLoop(ref Calibration calibration, bool cpuOnlyMode, SensorOrientation sensorOrientation, float smoothingFactor)
{
var config = new TrackerConfiguration
{
SensorOrientation = sensorOrientation,
ProcessingMode = cpuOnlyMode
? TrackerProcessingMode.Cpu
: TrackerProcessingMode.Gpu
};
tracker = new Tracker(ref calibration, config)
{
TemporalSmoothingFactor = smoothingFactor
};
isRunning = true;
backgroundThread = new Thread(BackgroundLoop)
{
IsBackground = true
};
backgroundThread.Start();
}
// called when computing the calibration has finished
private void ComputeCompleted(object sender, AsyncCompletedEventArgs <Empty> e)
{
if (FCalibrationState)
{
Calibration Calib = FEyetracker.GetCalibration();
if (e.Error != null)
{
// inform ISNode on calibration finished with errors(s)
OnCalibrationDone(Calib, false);
}
else
{
// inform tracker that calibration is finished
// Save collected calibration data to eyetracker
SetCalibration(Calib, true);
}
FEyetracker.StopCalibration();
FCalibrationState = false;
}
}
private void Awake()
{
if (Device.TryOpen(out _device))
{
Configuration = new DeviceConfiguration
{
ColorResolution = ColorResolution.R720p,
ColorFormat = ImageFormat.ColorBgra32,
DepthMode = DepthMode.NarrowViewUnbinned,
CameraFps = FrameRate.Fifteen,
};
_device.GetCalibration(Configuration.DepthMode, Configuration.ColorResolution, out var calibration);
Calibration = calibration;
}
else
{
Debug.Log("Cannot open device");
}
IsInitializationComplete = true;
}
Calibration.CameraCalibrationResult result; //All the info is contained here
// Update is called once per frame
void Update()
{
if (webcamTexture != null && webcamTexture.didUpdateThisFrame)
{
uv = Calibration.FindCheckerBoardCorners(webcamTexture, new Size(9, 6));
xyz = checkerBoard.Corners;
if (uv != null && uv.Length == 9 * 6)
{
if (Input.GetKeyDown(KeyCode.Space))
{
Sample();
}
}
}
if (Input.GetKeyDown(KeyCode.Return))
{
Calibrate();
}
}
public void GetFromRaw()
{
using (Device device = Device.Open(0))
{
byte[] raw = device.GetRawCalibration();
Calibration cal = Calibration.GetFromRaw(raw, DepthMode.WFOV_2x2Binned, ColorResolution.R1080p);
// Sanity check a few of the outputs for well known fields
ValidateCalibration(cal, DepthMode.WFOV_2x2Binned, ColorResolution.R1080p,
512, 512,
1920, 1080);
cal = Calibration.GetFromRaw(raw, DepthMode.WFOV_Unbinned, ColorResolution.R720p);
ValidateCalibration(cal, DepthMode.WFOV_Unbinned, ColorResolution.R720p,
1024, 1024,
1280, 720);
}
}
public void CopyCorners(Calibration calib)
{
for (int i = 0; i < calibration.CalibMethod.CalibrationTargets.Count; i++)
{
if (calibration.CalibMethod.CalibrationTargets[i].IsCorner)
{
corners[numRecalibTargets] = calibration.CalibMethod.CalibrationTargets[i].targetCoordinates;
calibration.CalibMethod.CalibrationTargets.Add(
new CalibrationTarget(numRecalibTargets,
calibration.CalibMethod.
CalibrationTargets[i].
targetCoordinates));
for (int j = 0; j < calibration.CalibMethod.CalibrationTargets[i].NumImages; j++)
{
calibration.CalibMethod.CalibrationTargets[numRecalibTargets].pupilCentersLeft.Add(
calibration.CalibMethod.CalibrationTargets[i].pupilCentersLeft[j]);
calibration.CalibMethod.CalibrationTargets[numRecalibTargets].pupilCentersRight.Add(
calibration.CalibMethod.CalibrationTargets[i].pupilCentersRight[j]);
if (Settings.Instance.Processing.TrackingGlints)
{
calibration.CalibMethod.CalibrationTargets[numRecalibTargets].glintsLeft.Add(
calibration.CalibMethod.CalibrationTargets[i].glintsLeft[j]);
calibration.CalibMethod.CalibrationTargets[numRecalibTargets].glintsRight.Add(
calibration.CalibMethod.CalibrationTargets[i].glintsRight[j]);
}
}
numRecalibTargets++;
}
}
}
private void OnGetCalibrationCompleted(Calibration calibration, Tobii.Gaze.Core.ErrorCode errorCode)
{
LookAndPlayForm.Program.datosCompartidos.calibrationDataEyeX = calibration;
CalibrationError errorCalibracion = new CalibrationError(LookAndPlayForm.Program.datosCompartidos.calibrationDataEyeX.GetCalibrationPointDataItems());
LookAndPlayForm.Program.datosCompartidos.meanCalibrationErrorLeftPx = errorCalibracion.meanCalibrationErrorLeftPx;
LookAndPlayForm.Program.datosCompartidos.meanCalibrationErrorRightPx = errorCalibracion.meanCalibrationErrorRightPx;
Console.WriteLine("EyetrackingEngine.OnGetCalibrationCompleted. errorCode: " + errorCode.ToString() +
"error: " +
errorCalibracion.meanCalibrationErrorLeftPx.ToString() + ", " +
errorCalibracion.meanCalibrationErrorRightPx.ToString());
if (OnGetCalibrationCompletedEvent != null)
OnGetCalibrationCompletedEvent(this, new CalibrationReadyEventArgs(errorCalibracion.CalibrationPointDataL));
}
private bool ProcessCalibration(Calibration entry) {
// Handle user cancelation
if(entry.state == QueueEntry.State.Canceled) { // action was canceled
return true;
}
if(entry.state == QueueEntry.State.Confirmed) {
return true;
}
// Create dialog and start waiting for user confirmation
dialog.StartModal(entry.id, DialogHelper.DialogType.JoystickConflict, new WindowProperties {
title = "Calibrate Controller",
message = "Select an axis to calibrate on the " + entry.joystick.name + ".",
rect = GetScreenCenteredRect(450, 480),
windowDrawDelegate = DrawCalibrationWindow
},
DialogResultCallback);
return false; // don't process anything more in this queue
}
void LoadCalibrationData()
{
calibrations = new Dictionary<string, Calibration> ();
TextAsset calibrationData1 = (TextAsset)Resources.Load (calibration1txt);
TextAsset calibrationData2 = (TextAsset)Resources.Load (calibration2txt);
TextAsset calibrationData3 = (TextAsset)Resources.Load (calibration3txt);
calibration1 = new Calibration();
calibration2 = new Calibration();
calibration3 = new Calibration();
CreateCalibrationClasses (calibrationData1.text, calibration1);
CreateCalibrationClasses (calibrationData2.text, calibration2);
CreateCalibrationClasses (calibrationData3.text, calibration3);
calibrations.Add(calibration1txt, calibration1);
calibrations.Add(calibration2txt, calibration2);
calibrations.Add(calibration3txt, calibration3);
}
void ITracker.SetCalibration(byte[] profile)
{
Calibration c = new Calibration(profile);
et.SetCalibration(c);
}
void CreateCalibrationClasses(string calibrationData, Calibration calibration)
{
string[] stringLines = calibrationData.Split ('\n');
Debug.Log (stringLines.Length);
Vector3 position = new Vector3();
for (int i = 0; i < stringLines.Length; i++) {
string[] stringLeftRightSide = stringLines[i].Split('=');
switch(stringLeftRightSide[0]){
case "posx":
position.x = float.Parse(stringLeftRightSide[1]);
break;
case "posy":
position.y = float.Parse(stringLeftRightSide[1]);
break;
case "posz":
position.z = float.Parse(stringLeftRightSide[1]);
break;
case "rotx":
calibration.RotationX = float.Parse(stringLeftRightSide[1]);
break;
case "roty":
calibration.RotationY = float.Parse(stringLeftRightSide[1]);
break;
case "rotz":
calibration.RotationZ = float.Parse(stringLeftRightSide[1]);
break;
default:
break;
}
calibration.Position = position;
}
}
private void AbortCalibration()
{
_calibrationResult = null;
_sleepTimer.Stop();
_calibrationForm.Close();
}
public void SetCalibration(byte[] data)
{
Calibration calibration = new Calibration(data);
tracker.SetCalibrationAsync(calibration, CalibrationSet);
}
/// <summary>
/// The abort calibration.
/// </summary>
private void AbortCalibration()
{
this.calibrationResult = null;
this.sleepTimer.Stop();
this.tobiiCalibrationForm.Close();
}
private void _loadCalibrationMenuItem_Click(object sender, EventArgs e)
{
try
{
if (_openFileDialog.ShowDialog() == DialogResult.OK)
{
using (var stream = _openFileDialog.OpenFile())
using (var reader = new BinaryReader(stream))
{
byte[] data = reader.ReadBytes((int)stream.Length);
Calibration calibration = new Calibration(data);
_connectedTracker.SetCalibration(calibration);
}
}
}
catch (EyeTrackerException ee)
{
MessageBox.Show("Failed to load calibration data. Got exception " + ee,
"Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
public void StartRecalibration(Calibration calib)
{
CopyCorners(calib);
recalibrating = true;
}
internal static double SqNiveau(this IParameterProvider parameters, Func<IParameterProvider, double> metric, RelativeSize relativeSize, Calibration calibration)
{
return 100.0 / System.Math.Pow(1.5, relativeSize(metric(parameters), parameters) / calibration(metric(parameters), parameters));
}
