public void Fired(IOProxy proxy, List <AbstractProxyEventData> eventData)
{
SlamMapEventData slamMapEvent = (SlamMapEventData)eventData.FirstOrDefault(c => c is SlamMapEventData);
SlamStatusEventData slamStatusEvent = (SlamStatusEventData)eventData.FirstOrDefault(c => c is SlamStatusEventData);
if (slamMapEvent != null)
{
if (slamMapEvent.PublishType == SlamPublishType.Frame)
{
SlamModel3D.AddNewFrame(slamMapEvent.Frame);
_FPSCounter.CountFrame();
}
else if (slamMapEvent.PublishType == SlamPublishType.KeyframeWithPoints)
{
SlamModel3D.AddNewKeyFrame(slamMapEvent.KeyFrame);
}
else if (slamMapEvent.PublishType == SlamPublishType.Reset)
{
SlamModel3D.Reset();
}
}
if (slamStatusEvent != null)
{
Parent.SyncContext.Post(o =>
{
Status = slamStatusEvent.Status;
}, null);
}
}
public void ReadWriteMemoryStreamToFileTest()
{
IOProxy.WriteMemoryStreamToFile(testStream, testFileName);
MemoryStream ms = IOProxy.GetMemoryStreamFromFile(testFileName);
Assert.IsTrue(CompareStreams(testStream, ms));
}
public async Task WriteByteArrayToFileAsyncTest()
{
await IOProxy.WriteBytesToFileAsync(testArray, testFileName).ConfigureAwait(false);
MemoryStream ms = await IOProxy.GetMemoryStreamFromFileAsync(testFileName).ConfigureAwait(false);
Assert.IsTrue(CompareStreams(testStream, ms));
}
public async Task ReadWriteMemoryStreamToFileAsyncTest()
{
await IOProxy.WriteMemoryStreamToFileAsync(testStream, testFileName);
MemoryStream ms = await IOProxy.GetMemoryStreamFromFileAsync(testFileName);
Assert.IsTrue(CompareStreams(testStream, ms));
}
public void WritePasswordTest()
{
EncryptedPassword password = new EncryptedPassword(new Tuple <byte[], byte[]>(testArray, testArray));
IOProxy.WritePassword(password, testFileName);
EncryptedPassword newPassword = new EncryptedPassword();
newPassword.GetPasswordFromFile(testFileName);
Assert.IsTrue(password.Hash.OrderBy(s => s).SequenceEqual(newPassword.Hash.OrderBy(s => s)));
Assert.IsTrue(password.Salt.OrderBy(s => s).SequenceEqual(newPassword.Salt.OrderBy(s => s)));
}
public void FileNameToCodeTest()
{
Assert.AreEqual(IOProxy.FileNameToCode(testFileName), IOProxy.FileNameToCode(testFileName));
Assert.AreEqual(string.Empty, IOProxy.FileNameToCode(string.Empty));
try
{
IOProxy.FileNameToCode(null);
} catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(NullReferenceException));
}
}
public void Fired(IOProxy proxy, List <AbstractProxyEventData> eventData)
{
ImuDerivedEventData imuDerivedEventData = (ImuDerivedEventData)eventData.FirstOrDefault(c => c is ImuDerivedEventData);
if (imuDerivedEventData != null)
{
GyroX.AddDataPoint(imuDerivedEventData.Time, imuDerivedEventData.GyroX);
GyroY.AddDataPoint(imuDerivedEventData.Time, imuDerivedEventData.GyroY);
GyroZ.AddDataPoint(imuDerivedEventData.Time, imuDerivedEventData.GyroZ);
AccX.AddDataPoint(imuDerivedEventData.Time, imuDerivedEventData.AccelX);
AccY.AddDataPoint(imuDerivedEventData.Time, imuDerivedEventData.AccelY);
AccZ.AddDataPoint(imuDerivedEventData.Time, imuDerivedEventData.AccelZ);
}
}
public MainViewModel()
{
_IOProxy = new IOProxy(_SettingContainer);
_SyncContext = SynchronizationContext.Current;
CameraViewModel = new CameraViewModel(this);
SettingViewModel = new SettingViewModel(this);
DataPlotViewModel = new DataPlotViewModel(this);
CalibrationViewModel = new CalibrationViewModel(this);
RecordViewModel = new RecordViewModel(this);
ReplayViewModel = new ReplayViewModel(this);
DebugViewModel = new DebugViewModel(this);
VisualisationViewModel = new VisualisationViewModel(this);
_DialogCoordinator = MahApps.Metro.Controls.Dialogs.DialogCoordinator.Instance;
}
public void Fired(IOProxy proxy, List <AbstractProxyEventData> eventData)
{
if (_DataWritter != null)
{
ImuEventData imuEventData = (ImuEventData)eventData.FirstOrDefault(c => c is ImuEventData);
CameraEventData cameraEventData = (CameraEventData)eventData.FirstOrDefault(c => c is CameraEventData);
if (imuEventData != null)
{
_DataWritter.AddImu(0, imuEventData.TimeNanoSeconds, imuEventData.GyroX / 180 * Math.PI, imuEventData.GyroY / 180 * Math.PI, imuEventData.GyroZ / 180 * Math.PI, imuEventData.AccelX, imuEventData.AccelY, imuEventData.AccelZ);
}
if (cameraEventData != null && imuEventData != null)
{
_DataWritter.AddImage(0, imuEventData.TimeNanoSeconds, cameraEventData.Image.ToPNGBinary(3), cameraEventData.ExposureTime);
}
else if (cameraEventData != null)
{
_DataWritter.AddImage(0, -1, cameraEventData.Image.ToPNGBinary(3), cameraEventData.ExposureTime);
}
}
}
internal void UpdateSettings(bool connectionSettingsChanged)
{
SettingsUpdated();
if (connectionSettingsChanged)
{
if (Node != null)
{
Node.Dispose();
Node = null;
}
if (SettingViewModel.SelectedHost != null)
{
_Connector = new LinkUpTcpClientConnector(IPAddress.Parse(SettingViewModel.SelectedHost.IpAddress), SettingViewModel.SelectedHost.Port);
_Connector.DebugDump = false;
_Connector.ConnectivityChanged += Connector_ConnectivityChanged;
_Connector.ConnectivityChanged += IOProxy.Connector_ConnectivityChanged;
_Connector.MetricUpdate += Connector_MetricUpdate;
Node = new LinkUpNode();
Node.Name = NodeName;
Node.AddSubNode(Connector);
IOProxy.Node = Node;
IOProxy.UpdateLinkUpBindings();
}
}
_SettingContainer.Save();
if (Connector != null && Connector.ConnectivityState == LinkUpConnectivityState.Connected)
{
_IOProxy.UpdateSettings();
}
}
public void Fired(IOProxy proxy, List <AbstractProxyEventData> eventData)
{
CameraEventData cameraEventData = (CameraEventData)eventData.FirstOrDefault(c => c is CameraEventData);
if (cameraEventData != null)
{
Task.Factory.StartNew(() =>
{
Mat mat = cameraEventData.Image;
bool undistort = false;
Parent.SyncContext.Send(o =>
{
undistort = Undistort;
if (GammaCorretion)
{
Mat result = new Mat(ImageWidth, ImageHeight, DepthType.Cv32F, 1);
int i = 0;
Mat lut = new Mat(1, 256, DepthType.Cv32F, 1);
foreach (double val in Parent.SettingContainer.Settings.CalibrationSettings.PhotometricCalibrationSettings.ResponseValues)
{
lut.SetValue(0, i++, (byte)val);
}
CvInvoke.LUT(mat, lut, result);
result.ConvertTo(mat, DepthType.Cv8U);
}
if (VignetteCorretion)
{
Mat invVignette = new Mat(ImageWidth, ImageHeight, DepthType.Cv32F, 1);
Mat result = new Mat(ImageWidth, ImageHeight, DepthType.Cv32F, 1);
CvInvoke.Divide(Mat.Ones(ImageWidth, ImageHeight, DepthType.Cv32F, 1), Parent.CalibrationViewModel.PhotometricCalibrationViewModel.Vignette.CvImage, invVignette, 255, DepthType.Cv32F);
CvInvoke.Multiply(mat, invVignette, result, 1, DepthType.Cv32F);
result.ConvertTo(mat, DepthType.Cv8U);
}
}
, null);
if (undistort)
{
Mat matUndist = new Mat(ImageWidth, ImageHeight, DepthType.Cv8U, 1);
if (FishEyeCalibration)
{
Mat map1 = new Mat();
Mat map2 = new Mat();
Fisheye.InitUndistorRectifyMap(OrginalCameraMatrix, DistortionCoefficients, Mat.Eye(3, 3, DepthType.Cv64F, 1), CenteredCameraMatrix, new System.Drawing.Size(ImageWidth, ImageHeight), DepthType.Cv32F, map1, map2);
CvInvoke.Remap(mat, matUndist, map1, map2, Inter.Linear, BorderType.Constant);
}
else
{
CvInvoke.Undistort(mat, matUndist, CenteredCameraMatrix, DistortionCoefficients);
}
mat = matUndist;
}
_FPSCounter.CountFrame();
Parent.SyncContext.Post(o =>
{
ExposureTime = (eventData[0] as CameraEventData).ExposureTime;
Image = new CvImageContainer();
Image.CvImage = mat;
}
, null);
});
}
}
