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)); }