/// <summary> /// Render the depth as a surface onto the scene. /// </summary> /// <param name="camera">Camera 4d transform matrix.</param> public void RenderDepth(double[][] camera) { Vector3[][] vertices = new Vector3[(int)ResX][]; Color color = Color.White; for (int i = 0; i < DepthFrame.Length; i++) { vertices[i] = new Vector3[(int)ResY]; } float m = 0; for (int k = 0; k < DepthFrame[0].Length; k++) { for (int i = 0; i < DepthFrame.Length; i++) { float range = GetRange(i, k, DepthFrame[i][k]); m = Math.Max(m, DepthFrame[i][k]); double[] local = Measurer.MeasureToMap(Pose, new PixelRangeMeasurement(i - ResX / 2, k - ResY / 2, range)); vertices[i][k] = camera.TransformH(local).ToVector3(); } } Graphics.DrawGrid(vertices, color, false); }
/// <summary> /// Obtain several measurements from the hidden state. /// </summary> /// <param name="time">Provides a snapshot of timing values.</param> /// <returns>Pixel-range measurements.</returns> public override List <PixelRangeMeasurement> Measure(GameTime time) { var measurements = new List <PixelRangeMeasurement>(); NextFrame(out DepthFrame, out ColorFrame, out interest); for (int i = 0; i < interest.Count; i++) { float range = GetRange(interest[i].I, interest[i].K, (float)interest[i].Value); measurements.Add(new PixelRangeMeasurement(interest[i].I - ResX / 2, interest[i].K - ResY / 2, range)); } if (ShowSidebar && depthsensed != null) { DepthMatrixToTexture(depthsensed, DepthFrame); ColorMatrixToTexture(colorsensed, ColorFrame); } MappedMeasurements.Clear(); foreach (PixelRangeMeasurement z in measurements) { MappedMeasurements.Add(Measurer.MeasureToMap(Pose, z)); } return(measurements); }
/// <summary> /// Obtain several measurements from the hidden state. /// Ladmarks may be misdetected. /// </summary> /// <param name="time">Provides a snapshot of timing values.</param> /// <returns>Pixel-range measurements.</returns> public override List <MeasurementT> Measure(GameTime time) { List <double[]> mlinear = Measurements[FrameIndex].Item2; if (FrameIndex < RecLength - 1) { updateWants(); FrameIndex++; } else { WantsToStop = true; } List <MeasurementT> measurements = new List <MeasurementT>(); MeasurementT dummy = new MeasurementT(); MappedMeasurements.Clear(); foreach (double[] z in mlinear) { MeasurementT measurement = dummy.FromLinear(z); measurements.Add(measurement); MappedMeasurements.Add(Measurer.MeasureToMap(Pose, measurement)); } return(measurements); }
public void constructor_saves_subject_internally() { KinokoSubject subject = () => { }; Measurer measurer = new Measurer(subject, 1); Assert.That(measurer.Subject, Is.SameAs(subject)); }
/// <summary> /// Obtain a measurement from the hidden state. /// This method always detects the landmark (misdetection /// probability is ignored). /// </summary> /// <param name="landmark">Landmark 3d location against which the measurement is performed.</param> /// <returns>Pixel-range measurements.</returns> public MeasurementT MeasureDetected(double[] landmark) { MeasurementT measurement = Measurer.MeasurePerfect(Pose, landmark); double[] mlinear = measurement.ToLinear(); double[] noise = Util.RandomGaussianVector(new double[mlinear.Length], MeasurementCovariance); return(measurement.FromLinear(mlinear.Add(noise))); }
public IEnumerable <WordPlacement> Place(IEnumerable <KeyValuePair <string, int> > words) { var fontSize = Height; foreach (var word in words) { fontSize = (int)Math.Min(fontSize, 100 * Math.Log10(word.Value + 100)); while (fontSize >= MinimumFontSize) { var found = false; var inf = Measurer.Measure(word.Key, new Font(FontFamily, fontSize)); for (var i = 0; i < Compactness; ++i) { var rects = inf.Rectangles.ToList(); if (rects.Count == 0) { continue; } var maxW = Math.Max(1, Width - (int)rects.Max(ii => ii.Width)); var maxH = Math.Max(1, Height - (int)rects.Max(ii => ii.Height)); var xOffset = inf.Offset.X + Rand.Next(1, maxW); var yOffset = inf.Offset.Y + Rand.Next(1, maxH); var newRects = new HashSet <RectangleF>(rects.Count); foreach (var r in rects) { r.Offset(xOffset, yOffset); newRects.Add(r); } if (!Map.Check(newRects)) { continue; } Map.Insert(newRects); yield return(new WordPlacement(word.Key, new PointF(xOffset, yOffset), fontSize)); found = true; break; } if (found) { break; } fontSize--; } } }
public void constructor_saves_repeatCount_internally() { KinokoSubject subject = () => { }; int repeatCount = 10; Measurer measurer = new Measurer(subject, repeatCount); Assert.That(measurer.RepeatCount, Is.EqualTo(repeatCount)); }
public void returns_not_null_Result() { KinokoSubject subject = () => { }; int repeatMeasurementCount = 10; Measurer measurer = new Measurer(subject, repeatMeasurementCount); KinokoResult result = measurer.Run(); Assert.That(result, Is.Not.Null); }
public void calls_the_subject_multiple_times([Values(1, 2, 3, 4, 5, 10)] int n) { int calledCount = 0; KinokoSubject subject = () => calledCount++; Measurer measurer = new Measurer(subject, n); measurer.Run(); Assert.That(calledCount, Is.EqualTo(n)); }
public void MeasureNode() { if (m_measurer == null) { m_measurer = new Measurer(this); } m_measurer.Measure(); ///ToDo: Verify }
public void Result_contains_correct_number_of_measurements([Values(1, 2, 3, 4, 5, 10)] int n) { KinokoSubject subject = () => { }; Measurer measurer = new Measurer(subject, n); KinokoResult result = measurer.Run(); Assert.That(result.Measurements, Is.Not.Null); Assert.That(result.Measurements.Length, Is.EqualTo(n)); }
public RowDescriptor(MathNode node, List <MathNode> childCells, string rowalign, List <string> columnaligns, List <int> busycells) { AlignToAxis = (rowalign == "axis"); Height = 0; Depth = 0; SpaceAfter = 0; Cells = new List <CellDescriptor>(); foreach (MathNode c in childCells) { // Find first free cell while (busycells.Count > Cells.Count && busycells[Cells.Count] > 0) { Cells.Add(null); } string halign = Measurer.GetByIndexOrLast(columnaligns, Cells.Count); string valign = rowalign; int colspan = 1; int rowspan = 1; if (c.ElementName == "mtd") { if (c.Attributes.ContainsKey("columnalign")) { halign = c.Attributes["columnalign"]; } if (c.Attributes.ContainsKey("rowalign")) { valign = c.Attributes["rowalign"]; } colspan = int.Parse(c.Attributes.ContainsKey("colspan") ? c.Attributes["colspan"] : "1"); rowspan = int.Parse(c.Attributes.ContainsKey("rowspan") ? c.Attributes["rowspan"] : "1"); } while (Cells.Count >= node.Columns.Count) { node.Columns.Add(new ColumnDescriptor()); } Cells.Add(new CellDescriptor(c, halign, valign, colspan, rowspan)); for (int i = 1; i < colspan; i++) { Cells.Add(null); } while (Cells.Count > node.Columns.Count) { node.Columns.Add(new ColumnDescriptor()); } } }
public void calls_the_subject() { bool isCalled = false; KinokoSubject subject = () => isCalled = true; int repeatMeasurementCount = 10; Measurer measurer = new Measurer(subject, repeatMeasurementCount); measurer.Run(); Assert.That(isCalled, Is.True); }
public void Result_Measurements_contains_correct_values() { int callIndex = 0; double[] times = new double[] { 60, 80, 40 }; KinokoSubject subject = () => Thread.Sleep((int)times[callIndex++]); Measurer measurer = new Measurer(subject, times.Length); KinokoResult result = measurer.Run(); AssertAreEqual(times, result.Measurements); }
private int FindIterationCount(StopwatchTimer timer, Action method, long minTicksForMeasurement, Action <string> log) { var iterationCount = 1; var diff = Measurer.MeasureDiffOutsideLoop(timer, new DelegateAction(method), iterationCount); while (diff < minTicksForMeasurement || diff > minTicksForMeasurement * 2) { iterationCount = (int)((iterationCount * minTicksForMeasurement) / Math.Max(diff, 1)); diff = Measurer.MeasureDiffOutsideLoop(timer, new DelegateAction(method), iterationCount); log?.Invoke($"Diff {diff} IterationCount {iterationCount}"); } return(iterationCount); }
private void PreProcessStage(GameObject newStage) { foreach (Transform child in newStage.transform) { if (child.tag == "End") { lastStageEnd = child.position; } else if (child.tag == "Finish") { var m = Measurer.AttachMeasure(child.gameObject, hud.SetTime, this.Goal); loadedMeasures.Enqueue(m); } } }
public Measurer RegisterMeasurer() { Measurer measurer = new Measurer(); Random rand = new Random(); using (var context = new DRUSContext()) { // Dodeli mu random lokaciju int loc = rand.Next(context.Locations.Count()); var locations = context.Locations.ToArray(); measurer.LocationId = locations.ElementAt(loc).Id; measurer.Name = rand.Next().ToString(); Measurer m = context.Measurers.Add(measurer); context.SaveChanges(); return(m); } }
public async Task <IActionResult> Create(AddUserViewModel model) { if (ModelState.IsValid) { var user = await CreateUserAsync(model); if (user != null) { var measurer = new Measurer { User = user }; _dataContext.Measurers.Add(measurer); await _dataContext.SaveChangesAsync(); return(RedirectToAction("Index")); } ModelState.AddModelError(string.Empty, "User with this email already exists. "); } return(View(model)); }
public QuickPerfMeasurements Run(Action <string> log)//<T>(this QuickPerfConfig<T> config) { Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime; Thread.CurrentThread.Priority = ThreadPriority.Highest; var timer = new StopwatchTimer(); var timerSpec = timer.Spec; Func <double, double> toNs = ticks => 1000 * 1000 * 1000 * ticks / (double)timerSpec.Frequency; const int MinTicksExtraMultiplier = 40; const int PrecisionDigits = 3; int precisionMultiplier = 1; for (int i = 0; i < PrecisionDigits; i++) { precisionMultiplier *= 10; } const int precisionMeasurementCount = 11; const int measurementsPerParamPerMethodCount = 21; // Measure timer precision var precisionMeasurements = ReserveMeasurements(precisionMeasurementCount); TimerMeasurer.MeasurePrecision(timer, precisionMeasurements); precisionMeasurements.Sort(); var min = precisionMeasurements.First(); var median = precisionMeasurements.Middle(); var max = precisionMeasurements.Last(); log?.Invoke($"Precision {min} - {median} - {max} ticks"); var minTicksForMeasurement = median * precisionMultiplier * MinTicksExtraMultiplier; foreach (var param in m_params) { // TODO: When to do m_setup?.Invoke(param); foreach (var namedMethod in m_methods) { var method = namedMethod.Method; var methodAction = new DelegateAction(method); var idleAction = new DelegateAction(IdleAction); // Pre-JIT and warmup var warmupIdleTime = Measurer.MeasureDiffOutsideLoop(timer, idleAction, 3); var warmupTime = Measurer.MeasureDiffOutsideLoop(timer, methodAction, 3); ForceAndWaitForGarbageCollection(); var iterationCount = FindIterationCount(timer, method, minTicksForMeasurement, log); //ForceAndWaitForGarbageCollection(); var idleTime = Measurer.MeasureDiffOutsideLoop(timer, idleAction, iterationCount); log?.Invoke($"Idle Ticks: {idleTime} ns: {toNs(idleTime / (double)iterationCount)}"); var measurements = ReserveMeasurements(measurementsPerParamPerMethodCount); ForceAndWaitForGarbageCollection(); for (int i = 0; i < measurements.Count; i++) { //ForceAndWaitForGarbageCollection(); var methodTime = Measurer.MeasureDiffOutsideLoop(timer, methodAction, iterationCount); measurements.Set(i, methodTime); log?.Invoke($"{namedMethod.Name} Ticks: {methodTime} ns: {toNs(methodTime / (double)iterationCount)}"); } } } return(new QuickPerfMeasurements()); }
public void SetUp() { KinokoSubject subject = () => Thread.Sleep(10); measurer = new Measurer(subject, 1); }
/// <summary> /// Get the probability of detection of a particular landmark /// using measurement coordinates to express the landmark. /// It is modelled as a constant if it's on the FOV and zero if not. /// </summary> /// <param name="measurement">Queried landmark in measurmeent coordinates.</param> /// <returns></returns> public double DetectionProbabilityM(MeasurementT measurement) { return(Measurer.FuzzyVisibleM(measurement) * detectionProbability); }
private void Button_Click(object sender, RoutedEventArgs e) { DateTime from = new DateTime(); DateTime to = new DateTime(); Measurer m = null; Location l = null; double value = 0; List <Measurement> result = null; bool errorDate = false; bool errorValue = false; string resultText = ""; try { from = Convert.ToDateTime(tbTimeFrom.Text); to = Convert.ToDateTime(tbTimeTo.Text); }catch (Exception exc) { errorDate = true; } try { value = Convert.ToDouble(tbValue.Text); } catch (Exception exc) { errorValue = true; } if (rbMeasurer.IsChecked == true) { m = (Measurer)cbClients.SelectedItem; } else { l = (Location)cbLocations.SelectedItem; } if (rbAll.IsChecked == true || rbAverage.IsChecked == true) { if (errorDate == false) { if (rbMeasurer.IsChecked == true && m != null) { result = service.GetMeasurementDate(m.Id, from, to).ToList(); } else if (l != null) { result = service.GetLocationDate(l.Id, from, to).ToList(); } } if (rbAll.IsChecked == true) { foreach (Measurement mes in result) { resultText += mes.Time.ToString() + " " + mes.Humidity + "% " + mes.Temperature + "C \n"; } } else { double temp = 0; double humid = 0; int humidCount = 0; foreach (Measurement mes in result) { temp += mes.Temperature; if (mes.Humidity > 0) { humidCount++; humid += mes.Humidity; } } temp /= result.Count; humid /= humidCount; if (rbHumidity.IsChecked == true) { resultText = humid.ToString(); } else { resultText = temp.ToString(); } } } else if (errorValue == false) { bool greaterThen = false; if (rbMore.IsChecked == true) { greaterThen = true; } if (rbMeasurer.IsChecked == true && m != null) { result = service.GetMeasurementValue(m.Id, greaterThen, value).ToList(); } else if (l != null) { result = service.GetLocationValue(l.Id, greaterThen, value).ToList(); } foreach (Measurement mes in result) { if (greaterThen) { if (rbHumidity.IsChecked == true) { if (mes.Humidity > value) { resultText += mes.Time.ToString() + " " + mes.Humidity + "% \n"; } } else { if (mes.Temperature > value) { resultText += mes.Time.ToString() + " " + mes.Temperature + "C \n"; } } } else { if (rbHumidity.IsChecked == true) { if (mes.Humidity < value && mes.Humidity > 0) { resultText += mes.Time.ToString() + " " + mes.Humidity + "% \n"; } } else { if (mes.Temperature < value) { resultText += mes.Time.ToString() + " " + mes.Temperature + "C \n"; } } } } } tbText.Text = resultText; }
private void PrepareCompleted(VideoPlayer source) { RenderTexture.width = (int)source.width; RenderTexture.height = (int)source.height; Measurer.MarkDirty(); }
private void SubToClient(object sender, RoutedEventArgs e) { Measurer m = (Measurer)cbClients.SelectedItem; service.RegisterObserver(m.Id); }
/// <summary> /// Find if a given ladmark is visible from the current pose of the vehicle. /// </summary> /// <param name="landmark">Queried landmark.</param> /// <returns>True if the landmark is visible; false otherwise.</returns> public bool Visible(double[] landmark) { return(Measurer.VisibleM(Measurer.MeasurePerfect(Pose, landmark))); }
/// <summary> /// Obtain several measurements from the hidden state. /// Ladmarks may be misdetected. /// </summary> /// <param name="time">Provides a snapshot of timing values.</param> /// <returns>Pixel-range measurements.</returns> public override List <MeasurementT> Measure(GameTime time) { List <MeasurementT> measurements = new List <MeasurementT>(); Map visible = new Map(3); DataAssociation = new List <int>(); double[][] diraccov = new double[3][] { new double[3] { 0.001, 0, 0 }, new double[3] { 0, 0.001, 0 }, new double[3] { 0, 0, 0.001 } }; // add every measurement with probability = DetectionProbability for (int i = 0; i < Landmarks.Count; i++) { double pd = DetectionProbability(Landmarks[i]); if (pd > 0) { if (Util.Uniform.Next() < pd) { measurements.Add(MeasureDetected(Landmarks[i])); DataAssociation.Add(i); visible.Add(new Gaussian(Landmarks[i], diraccov, 1.0)); } else { visible.Add(new Gaussian(Landmarks[i], diraccov, 0.0)); // weight indicates visible but not detected } } } // poisson distributed clutter measurement count // a cap of 10 lambda is enforced because technically // the number is unbounded so it could freeze the system int nclutter; try { // the poisson generator may underflow if lambda is too small nclutter = Math.Min(clutterGen.Generate(), (int)(ClutterCount * 10)); } catch (ArithmeticException) { nclutter = 0; } for (int i = 0; i < nclutter; i++) { measurements.Add(Measurer.RandomMeasure()); DataAssociation.Add(int.MinValue); } MappedMeasurements.Clear(); foreach (MeasurementT z in measurements) { MappedMeasurements.Add(Measurer.MeasureToMap(Pose, z)); } WayVisibleMaps.Add(Tuple.Create(time.TotalGameTime.TotalSeconds, visible)); return(measurements); }
/// <summary> /// Get the probability of detection of a particular landmark. /// It is modelled as a constant if it's on the FOV and zero if not. /// </summary> /// <param name="landmark">Queried landmark.</param> /// <returns></returns> public double DetectionProbability(double[] landmark) { return(Measurer.FuzzyVisibleM(Measurer.MeasurePerfect(Pose, landmark)) * detectionProbability); }