public void NoAdjacentPointsSetReturnsCorrectly()
{
var p1 = new MeasurementPoint(0, 0, 100);
var p2 = new MeasurementPoint(2, 2, 100);
var p3 = new MeasurementPoint(4, 4, 100);
var points = new List <MeasurementPoint>()
{
p1, p2, p3
};
var expected = new List <HashSet <MeasurementPoint> >()
{
new HashSet <MeasurementPoint>()
{
p1
},
new HashSet <MeasurementPoint>()
{
p2
},
new HashSet <MeasurementPoint>()
{
p3
}
};
var output = example.GetSubregions(points);
Assert.IsTrue(expected.Count == output.Count);
for (int i = 0; i < output.Count; i++)
{
AssertCollectionsMatch(expected[i], output[i]);
}
}
private void OnPrevButtonClicked(object sender, RoutedEventArgs e)
{
MeasurementPoint measurementPoint = GetMeasurementPoint();
MeasurementPoint previousPoint = measurementPoint?.PreviousPoint;
previousPoint?.OpenPoint();
}
private void OnNextButtonClicked(object sender, RoutedEventArgs e)
{
MeasurementPoint measurementPoint = GetMeasurementPoint();
MeasurementPoint nextPoint = measurementPoint?.NextPoint;
nextPoint?.OpenPoint();
}
private static MeasurementPoint LoadAPreviouslySavedMeasurementPoint(MeasurementPointRepository measurementPointRepository)
{
var newMeasurementPoint = MeasurementPoint.CreateNew();
measurementPointRepository.Save(newMeasurementPoint);
return(measurementPointRepository.Load(newMeasurementPoint.Id));
}
protected HashSet <MeasurementPoint> GetRandomClusterSet(out int[,] measurements, int threshold)
{
var random = CreateRNG();
var value = threshold + 1;
var expected = new HashSet <MeasurementPoint>();
measurements = CreateMeasurementArray(3, 3, 0);
measurements[1, 1] = value;
expected.Add(new MeasurementPoint(1, 1, value));
var target = random.Next(3, 10);
while (expected.Count < target)
{
var x = random.Next(0, 3);
var y = random.Next(0, 3);
var candidate = new MeasurementPoint(x, y, value);
if (expected.Contains(candidate))
{
continue;
}
measurements[x, y] = value;
expected.Add(candidate);
}
return(expected);
}
private void timerSerialReceive_Tick(object sender, EventArgs e)
{
if (serialPort1.BytesToRead > 0)
{
MeasurementPoint measuredPoint;
string availableData = "";
availableData += serialPort1.ReadExisting().ToString();
string[] analogReadings = availableData.Split(';');
textBoxRead1.AppendText(availableData);
if (analogReadings.Length == 1)
{
measuredPoint = new MeasurementPoint(DateTime.Now.ToLongTimeString(), Convert.ToInt32(analogReadings[0]),
Convert.ToInt32(analogReadings[0]), Convert.ToInt32(analogReadings[0]));
chart1.Series[0].Points.AddXY(measuredPoint.time, measuredPoint.va);
//chart1.Series[1].Points.AddXY(measuredPoint.time, measuredPoint.vb);
// chart1.Series[2].Points.AddXY(measuredPoint.time, measuredPoint.vab);
allMeasuredPoints.Add(measuredPoint);
/*listBoxVa.Items.Add(analogReadings[0]);
* chart1.Series[0].Points.AddXY(Convert.ToDouble(listBoxVa.Items.Count - 1),
* Convert.ToDouble(listBoxVa.Items[listBoxVa.Items.Count - 1]));
* listBoxVb.Items.Add(analogReadings[1]);
* chart1.Series[1].Points.AddXY(Convert.ToDouble(listBoxVb.Items.Count - 1),
* Convert.ToDouble(listBoxVb.Items[listBoxVb.Items.Count - 1]));
* listBoxVab.Items.Add(analogReadings[2]);
* chart1.Series[2].Points.AddXY(Convert.ToDouble(listBoxVab.Items.Count - 1),
* Convert.ToDouble(listBoxVab.Items[listBoxVab.Items.Count - 1]));
*/
}
timerChartAdd.Enabled = true;
timerSerialReceive.Enabled = false;
}
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
double totalWidth = (double)values[0];
MeasurementPoint point = values[1] as MeasurementPoint;
int count = point?.Count ?? 0;
return((totalWidth - 15 * count) / Math.Max(count, 1));
}
private static MeasurementPoint AddMeasurementPoint(MeasurementPointRepository measurementPointRepository)
{
var measurementPoint = MeasurementPoint.CreateNew();
measurementPointRepository.Save(measurementPoint);
return(measurementPoint);
}
private void LogTimeDifferenceToClosestWaterMeasurement(Data row, MeasurementPoint closestMeasurementTime)
{
var timeDifference = Math.Abs(closestMeasurementTime.UnixTime - row.UnixTime);
if (timeDifference > _dataProcessingParams.RegularizerTimeLoggingThreshold)
{
_logger.Information("More than {0} seconds for closest measurement:" + row.UnixTime, _dataProcessingParams.RegularizerTimeLoggingThreshold);
}
}
private static Model AddForecastToMeasurementPoint(MeasurementPoint measurementPoint, MeasurementPointRepository measurementPointRepository)
{
var model = new ModelRepository().Load(1);
measurementPoint.AddForeCast(usingModel: model);
measurementPointRepository.Save(measurementPoint);
return(model);
}
internal static InfluxPoint ToInfluxPoint(this MeasurementPoint point)
{
var influxPoint = new InfluxPoint(point.Measurement)
.AddTags(point.Tags)
.AddFields(point.ValueTypeFields)
.AddFields(point.StringFields);
return(influxPoint);
}
private async void OnOpenCloseButtonClicked(object sender, RoutedEventArgs e)
{
DockMeasurementDetail measurementDetail = (DockMeasurementDetail)DataContext;
MeasurementPoint measurementPoint = measurementDetail?.MeasurementPoint;
Measurement measurement = measurementPoint?.Measurement;
if (measurementPoint != null)
{
if (measurementPoint.Open)
{
measurementPoint.ClosePoint();
if (!measurement.IsPointMeasurement)
{
measurement.EnableMeasurementSeries();
}
await measurement.MeasurementPointUpdatedAsync(measurementPoint.PointId);
if (measurement.IsPointMeasurement)
{
MapView mapView = MapView.Active;
Geometry geometry = await mapView.GetCurrentSketchAsync();
VectorLayer layer = measurement.VectorLayer;
long? uid = measurement.ObjectId;
if (geometry != null && uid == null && layer != null)
{
await layer.AddFeatureAsync(geometry);
}
else if (uid != null && layer != null)
{
MapPoint mapPoint = measurementPoint.Point;
await layer.UpdateFeatureAsync((long)uid, mapPoint);
}
}
measurementDetail.SelectedObservation = null;
}
else
{
if (measurement.IsPointMeasurement)
{
measurement.OpenMeasurement();
}
else
{
measurement.DisableMeasurementSeries();
}
measurementPoint.OpenPoint();
}
}
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
MeasurementPoint point = values.Length >= 1 ? values[0] as MeasurementPoint : null;
bool isOpen = values.Length >= 2 && values[1] is bool && (bool)values[1];
MapPoint mapPoint = values.Length >= 3 ? values[2] as MapPoint : null;
Measurement measurement = point?.Measurement;
bool update = measurement?.ObjectId == null && mapPoint != null && !double.IsNaN(mapPoint.X) && !double.IsNaN(mapPoint.Y) && !double.IsNaN(mapPoint.Z) ||
point?.LastPoint != null && point.LastPoint != mapPoint;
return(((!measurement?.IsPointMeasurement ?? false) || isOpen) && update);
}
public void Delete(MeasurementPoint measurementPoint)
{
var sessionFactory = SessionFactory.CreateSessionFactory();
using (var session = sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Delete(measurementPoint);
transaction.Commit();
}
}
protected HashSet <MeasurementPoint> GetCenterAloneSet(out List <MeasurementPoint> points)
{
var p1 = new MeasurementPoint(1, 1, 2);
points = new List <MeasurementPoint>()
{
p1
};
var expected = new HashSet <MeasurementPoint>();
return(expected);
}
protected override async Task OnCollectAsync(IDispatcher dispatcher)
{
var value = _counter.NextValue();
var point = new MeasurementPoint(Name)
.AddTag("host", _counter.MachineName)
.AddField("value", (decimal)value)
.AddTimeStamp(SysTime.Now());
var measurement = new PerformanceCounterMeasurement(point);
await dispatcher.DispatchAsync(measurement).ForAwait();
}
private void timerSerialReceive_Tick(object sender, EventArgs e)
{
if (serialPort1.BytesToRead > 0)
{
if (buttraw.Checked)
{
MeasurementPoint measuredPoint;
string availableData = "";
availableData += serialPort1.ReadExisting().ToString();
textBoxTextFile.AppendText(availableData + "\r\n");
measuredPoint = new MeasurementPoint(DateTime.Now.ToLongTimeString(), int.Parse(availableData));
if (measuredPoint != null)
{
AllMeasurementPoints.Add(measuredPoint);
}
chart1.Series[0].Points.AddXY(measuredPoint.time, measuredPoint.raw);
timerChartAdd.Enabled = true;
timerSerialReceive.Enabled = false;
}
if (buttscaled.Checked)
{
MeasurementPointscaled measuredPoint;
string availableData = "";
availableData += serialPort1.ReadExisting().ToString();
textBoxTextFile.AppendText(availableData + "\r\n");
measuredPoint = new MeasurementPointscaled(DateTime.Now.ToLongTimeString(), string.Format(availableData));
if (measuredPoint != null)
{
AllMeasurementPointsscaled.Add(measuredPoint);
}
chart1.Series[1].Points.AddXY(measuredPoint.time, measuredPoint.scaled);
timerChartAdd.Enabled = true;
timerSerialReceive.Enabled = false;
}
}
}
public void ProvidedPointReturnsCorrectly()
{
var p1 = new MeasurementPoint(1, 1, 210);
var subregion = new HashSet <MeasurementPoint>()
{
p1
};
var output = example.GetCenterOfMass(subregion);
var expected = new Point(1, 1);
Assert.IsTrue(expected.Equals(output));
}
public void ProvidedPairReturnsCorrectly()
{
var p7 = new MeasurementPoint(5, 4, 250);
var p8 = new MeasurementPoint(5, 5, 250);
var subregion = new HashSet <MeasurementPoint>()
{
p7, p8
};
var expected = new Point(5, 5);
var output = example.GetCenterOfMass(subregion);
Assert.IsTrue(expected.Equals(output));
}
private async void OnUndoButtonClicked(object sender, RoutedEventArgs e)
{
MeasurementPoint measurementPoint = GetMeasurementPoint();
Measurement measurement = measurementPoint.Measurement;
if (measurement.IsPointMeasurement)
{
measurementPoint.RemoveMe();
if (measurement.ObjectId == null)
{
measurement.AddMeasurementPoint();
}
else
{
measurement.CreateMeasurementPoint(measurementPoint.LastPoint);
}
}
else
{
MapView mapView = MapView.Active;
Geometry geometry = await mapView.GetCurrentSketchAsync();
List <MapPoint> points = await measurement.ToPointCollectionAsync(geometry);
int removePoints = measurement.IsGeometryType(GeometryType.Polygon) && points.Count == 2 &&
measurement.PointNr == 1 ? 2 : 1;
for (int i = 0; i < removePoints; i++)
{
int substract = (measurement.IsGeometryType(GeometryType.Polygon) && (removePoints == 1)) ? 2 : 1;
points.RemoveAt(points.Count - substract);
}
await QueuedTask.Run(() =>
{
if (measurement.IsGeometryType(GeometryType.Polygon))
{
geometry = PolygonBuilder.CreatePolygon(points);
}
else if (measurement.IsGeometryType(GeometryType.Polyline))
{
geometry = PolylineBuilder.CreatePolyline(points);
}
});
await mapView.SetCurrentSketchAsync(geometry);
}
}
private static void AppendProcessInfo(ManagementBaseObject service, MeasurementPoint point)
{
int processId;
if (!int.TryParse(service.GetPropertyValue("ProcessId").ToString(), out processId))
{
return;
}
var process = Process.GetProcessById(processId);
point
.AddField("workingSetMb", (decimal)process.WorkingSet64 / 1024 / 1024)
.AddField("threadCount", process.Threads.Count);
}
public HttpResponseMessage Post(SampleMeasurementRequest request)
{
_logger.Debug("Recieved SampleMeasurementRequest");
var point = new MeasurementPoint(request.Name)
.AddTag("host", request.MachineName ?? Environment.MachineName)
.AddField("value", request.Value)
.AddTimeStamp(SysTime.Now());
var measurement = new WebHookMeasurement(point);
_dispatcher.DispatchAsync(measurement);
return(Request.CreateResponse(HttpStatusCode.Created));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
MeasurementPoint = await _context.MeasurementPoint.SingleOrDefaultAsync(m => m.Id == id);
if (MeasurementPoint == null)
{
return(NotFound());
}
return(Page());
}
public void TheMeasurmentPointPersistedShouldHaveTheSameDataAsTheMeasurementPointBeingSaved()
{
var measurementPointRepository = new MeasurementPointRepository();
var newMeasurementPoint = MeasurementPoint.CreateNew();
measurementPointRepository.Save(newMeasurementPoint);
var persistedMeasuementPoint = measurementPointRepository.Load(newMeasurementPoint.Id);
Assert.That(persistedMeasuementPoint, Is.Not.Null);
Assert.That(persistedMeasuementPoint.Id, Is.EqualTo(newMeasurementPoint.Id));
Assert.That(persistedMeasuementPoint.CreatedDate, Is.EqualTo(newMeasurementPoint.CreatedDate));
Assert.That(persistedMeasuementPoint.IsActive, Is.EqualTo(newMeasurementPoint.IsActive));
Assert.That(persistedMeasuementPoint.Forecasts, Is.Empty);
measurementPointRepository.Delete(newMeasurementPoint);
}
public void SingleWSetReturnsCorrectly()
{
var p1 = new MeasurementPoint(0, 2, 100);
var p2 = new MeasurementPoint(0, 1, 100);
var p3 = new MeasurementPoint(1, 1, 100);
var p4 = new MeasurementPoint(1, 0, 100);
var p5 = new MeasurementPoint(2, 0, 100);
var p6 = new MeasurementPoint(4, 4, 100);
p1.AdjacentPoints.Add(p2);
p2.AdjacentPoints.Add(p1);
p2.AdjacentPoints.Add(p3);
p3.AdjacentPoints.Add(p2);
p3.AdjacentPoints.Add(p4);
p4.AdjacentPoints.Add(p3);
p4.AdjacentPoints.Add(p5);
p5.AdjacentPoints.Add(p4);
var points = new List <MeasurementPoint>()
{
p1, p2, p3, p4, p5, p6
};
var expected = new List <HashSet <MeasurementPoint> >()
{
new HashSet <MeasurementPoint>()
{
p1, p2, p3, p4, p5
},
new HashSet <MeasurementPoint>()
{
p6
}
};
var output = example.GetSubregions(points);
Assert.IsTrue(expected.Count == output.Count);
for (int i = 0; i < output.Count; i++)
{
AssertCollectionsMatch(expected[i], output[i]);
}
}
public void ProvidedWReturnsCorrectly()
{
var p2 = new MeasurementPoint(3, 2, 250);
var p3 = new MeasurementPoint(3, 3, 250);
var p4 = new MeasurementPoint(4, 1, 230);
var p5 = new MeasurementPoint(4, 2, 245);
var p6 = new MeasurementPoint(5, 1, 220);
var subregion = new HashSet <MeasurementPoint>()
{
p2, p3, p4, p5, p6
};
var expected = new Point(4, 2);
var output = example.GetCenterOfMass(subregion);
Assert.IsTrue(expected.Equals(output));
}
public void UniformYSetReturnsCorrectly()
{
var p1 = new MeasurementPoint(0, 0, 1);
var p2 = new MeasurementPoint(0, 1, 1);
var p3 = new MeasurementPoint(0, 2, 1);
var p4 = new MeasurementPoint(0, 3, 1);
var p5 = new MeasurementPoint(0, 4, 1);
var subregion = new HashSet <MeasurementPoint>()
{
p1, p2, p3, p4, p5
};
var expected = new Point(0, 2);
var output = example.GetCenterOfMass(subregion);
Assert.IsTrue(expected.Equals(output));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
MeasurementPoint = await _context.MeasurementPoint.FindAsync(id);
if (MeasurementPoint != null)
{
_context.MeasurementPoint.Remove(MeasurementPoint);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
protected HashSet <MeasurementPoint> GetSinglePointSet(int x, int y, out List <MeasurementPoint> points)
{
var p1 = new MeasurementPoint(1, 1, 2);
var p2 = new MeasurementPoint(x, y, 2);
points = new List <MeasurementPoint>()
{
p1, p2
};
var expected = new HashSet <MeasurementPoint>()
{
p2
};
expected.Remove(p1);
return(expected);
}
protected HashSet <MeasurementPoint> GetBottomRightSet(out List <MeasurementPoint> points)
{
var p1 = new MeasurementPoint(2, 2, 2);
var p2 = new MeasurementPoint(1, 1, 2);
var p3 = new MeasurementPoint(1, 2, 2);
var p4 = new MeasurementPoint(2, 1, 2);
points = new List <MeasurementPoint>()
{
p1, p2, p3, p4
};
var expected = new HashSet <MeasurementPoint>()
{
p2, p3, p4
};
return(expected);
}
