public static async Task <VideoView> Create(IDataPoint datapoint, TimeSynchronizedContext context)
{
// TODO: Check that this datapoint has a type that can be used
var viewer = await context.GetDataViewerFor(datapoint);
var view = new VideoView(context, datapoint);
view.AddViewer(viewer);
if (!(viewer is ArchiveVideoVideoViewer videoViewer))
{
return(view);
}
var(streamFactory, mime) = videoViewer.Video.GetStreamFactory();
view.SetStreamFactory(streamFactory, mime);
if (viewer.DataPoint.Time is ArchiveVideoTime time)
{
view.StartTime = time.Offset;
time.OffsetChanged += (s, offset) => view.StartTime = offset;
view._player.OffsetChanged += (s, offset) => time.VideoPlaybackOffset = TimeFormatter.TimeFromSeconds(offset);
}
context.SelectedTimeRangeChanged += view.OnSelectedTimeRangeChanged;
context.IsPlayingChanged += view.IsPlayingChanged;
context.PlaybackRateChanged += view.PlaybackRateChanged;
view.IsPlayingChanged(null, context.IsPlaying);
view.PlaybackRateChanged(null, context.PlaybackRate);
return(view);
}
public static async Task <CorrelationPlot> Create(IDataPoint datapoint, TimeSynchronizedContext context, ISyncPage pointSyncPage)
{
var correlationPlot = new CorrelationPlot(context, datapoint, pointSyncPage);
var lineDrawer = await correlationPlot.CreateLineDrawer(datapoint);
correlationPlot.AddLine(lineDrawer);
return(correlationPlot);
}
public static async Task <LinePlot> Create(IDataPoint datapoint, TimeSynchronizedContext context)
{
var linePlot = new LinePlot(context, datapoint);
var lineDrawer = await linePlot.CreateLineDrawer(datapoint);
linePlot.AddLine(lineDrawer);
return(linePlot);
}
private void TestDataSet(long[] timeArray, double[] dataArray, int maxNum)
{
Assert.Equal(timeArray.Length, dataArray.Length);
var time = new TableTimeIndex("time", new Task <long[]>(() => timeArray), true, "test:/time", "t");
var data = new GenericColumn <double>("acc_x", new Task <double[]>(() => dataArray), time, "test/acc", "a");
var tsc = new TimeSynchronizedContext();
tsc.SetSynchronizedToWorldClock(false);
var dataViewerTask = tsc.GetDataViewerFor(data);
dataViewerTask.Wait();
var viewer = dataViewerTask.Result as ITimeSeriesViewer;
Assert.NotNull(viewer);
viewer.PreviewPercentage = 0;
var startTime = timeArray[0];
Assert.Equal(0, tsc.AvailableTimeFrom);
Assert.Equal(timeArray.Last() - startTime, tsc.AvailableTimeTo);
tsc.SetSelectedTimeRange(tsc.AvailableTimeFrom, tsc.AvailableTimeTo);
var dataView = viewer.GetCurrentData <double>();
var en = dataView.GetEnumerator(maxNum);
var count = 0;
Assert.True(en.MoveNext());
count++;
Assert.Equal(timeArray.First(), en.Current.x);
Assert.Equal(dataArray.First(), en.Current.y);
while (en.MoveNext())
{
count++;
}
Assert.Equal(timeArray.Last(), en.Current.x);
Assert.Equal(dataArray.Last(), en.Current.y);
if (maxNum > 0)
{
Assert.InRange(count, maxNum, maxNum + 2);
}
else
{
Assert.Equal(count, timeArray.Length);
}
}
public async void ChangeSingleDataArchive()
{
Guid sessionId = Guid.NewGuid(); // Todo fake sessionId
var tmpName = CreateTestArchive(sessionId);
var tmpName2 = Path.GetTempFileName();
long preFrom;
long preTo;
long[] preData;
const long offset = 10L;
using (var fr = new FileReader(tmpName))
{
var archive = await Archive.Open(fr);
var readFolder = archive.Sessions.First().Children.First();
var child = readFolder.Children.First();
Assert.IsAssignableFrom <ArchiveTable>(child);
var tableChild = (ArchiveTable)child;
var dataPoint = tableChild.DataPoints.First();
var context = new TimeSynchronizedContext();
context.SetSynchronizedToWorldClock(true);
context.AvailableTimeRangeChanged +=
(sender, from, to) => context.SetSelectedTimeRange(from, to);
var viewer = await context.GetDataViewerFor(dataPoint);
var timeViewer = (ITimeSeriesViewer)viewer;
preData = timeViewer.GetCurrentData <double>().X.ToArray();
preFrom = context.AvailableTimeFrom;
preTo = context.AvailableTimeTo;
dataPoint.Time.TransformTime(offset, 1);
await archive.WriteFile(tmpName2);
archive.Close();
}
File.Delete(tmpName);
using (var fileReader = new FileReader(tmpName2))
{
var archive = await Archive.Open(fileReader);
var readFolder = archive.Sessions.First().Children.First();
var child = readFolder.Children.First();
Assert.IsAssignableFrom <ArchiveTable>(child);
var tableChild = (ArchiveTable)child;
var dataPoint = tableChild.DataPoints.First();
var context = new TimeSynchronizedContext();
context.SetSynchronizedToWorldClock(true);
context.AvailableTimeRangeChanged +=
(sender, from, to) => context.SetSelectedTimeRange(from, to);
var viewer = await context.GetDataViewerFor(dataPoint);
var timeViewer = (ITimeSeriesViewer)viewer;
var postData = timeViewer.GetCurrentData <double>().X.ToArray();
Assert.Equal(preFrom + offset, context.AvailableTimeFrom);
Assert.Equal(preTo + offset, context.AvailableTimeTo);
for (var i = 0; i < preData.Length; i++)
{
Assert.Equal(preData[i] + offset, postData[i]);
}
}
File.Delete(tmpName2);
}
public void SaveSingleDataArchive()
{
Guid sessionId = Guid.NewGuid(); // Todo fake sessionId
var tmpName = Path.GetTempFileName();
var timeData = new[] { 1L, 2L, 3L };
var timeColumn = new DataColumn(
new DataField <long>("time"),
timeData);
var numbersData = new[] { 42d, 1337d, 6.022e23 };
var numbersColumn = new DataColumn(
new DataField <double>("cool_numbers"),
numbersData);
var schema = new Schema(timeColumn.Field, numbersColumn.Field);
var json = new JObject {
["meta"] = new JObject(), ["user"] = new JObject()
};
using (var ms = new MemoryStream())
{
using (var parquetWriter = new ParquetWriter(schema, ms))
using (var groupWriter = parquetWriter.CreateRowGroup())
{
groupWriter.WriteColumn(timeColumn);
groupWriter.WriteColumn(numbersColumn);
}
ms.Position = 0;
using (var parquetReader = new ParquetReader(ms)) {
var tableInformation = new ArchiveTableInformation()
{
Columns = new List <DataField>(parquetReader.Schema.GetDataFields()),
Time = timeColumn.Field
};
var table = new ArchiveTable(json, parquetReader, tableInformation, "testData");
var archive = Archive.Create(tmpName);
var session = ArchiveSession.Create(archive, "testName");
var folder = ArchiveFolder.Create(archive, sessionId, "testFolder");
folder.AddChild(table);
session.AddChild(folder);
archive.AddSession(session);
try
{
archive.WriteFile().Wait();
}
catch (Exception)
{
Assert.True(false);
}
archive.Close();
using (var fr = new FileReader(tmpName))
{
var openTask = Archive.Open(fr);
openTask.Wait();
var newArchive = openTask.Result;
AssertArchivesEqual(archive, newArchive);
Assert.Equal("testName", session.Name);
Assert.Single(newArchive.Sessions.First().Children);
var readFolder = newArchive.Sessions.First().Children.First();
Assert.Equal("testFolder", readFolder.Name);
Assert.Single(readFolder.Children);
var child = readFolder.Children.First();
Assert.Single(child.DataPoints);
Assert.IsAssignableFrom <ArchiveTable>(child);
var tableChild = (ArchiveTable)child;
var dataPoint = tableChild.DataPoints.First();
var context = new TimeSynchronizedContext();
context.AvailableTimeRangeChanged +=
(sender, from, to) => context.SetSelectedTimeRange(from, to);
var viewer = context.GetDataViewerFor(dataPoint);
viewer.Wait();
var dataViewer = viewer.Result;
Assert.IsAssignableFrom <ITimeSeriesViewer>(dataViewer);
var timeViewer = (ITimeSeriesViewer)dataViewer;
var data = timeViewer.GetCurrentData <double>();
Assert.Equal("cool_numbers", dataViewer.DataPoint.Name);
Assert.Equal(timeData, data.X.ToArray());
Assert.Equal(numbersData, data.Y.ToArray());
newArchive.Close();
}
}
}
File.Delete(tmpName);
}
protected VideoView(TimeSynchronizedContext context, IDataPoint dataPoint) : base(context, dataPoint)
{
}
protected LinePlot(TimeSynchronizedContext context, IDataPoint dataPoint) : base(context, dataPoint)
{
}
private CorrelationPlot(TimeSynchronizedContext context, IDataPoint dataPoint, ISyncPage pointSyncPage) : base(context, dataPoint)
{
this.Canvas.EnableTouchEvents = true;
this.Canvas.Touch += OnTouch;
this._pointSyncPage = pointSyncPage;
}
public DrawPlot(TimeSynchronizedContext context, IDataPoint dataPoint) : base(context, dataPoint)
{
_context = context;
PlotType = PlotTypes.Line;
}
