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