public void Activate(DeviceConfiguration config)
{
pointCloudImage.Init(config);
if (!pointCloudImage.IsRenderingActive)
{
pointCloudImage.StartRendering();
}
pointCloudImage.Visibility = System.Windows.Visibility.Visible;
}
public void AddConfiguration(DeviceConfiguration config)
{
//TODO: transfer DeviceConfiguration to Configuration
var configEntity = new Configuration();
configEntity.ConfigurationJson = DateTime.Now.Ticks.ToString();
configEntity.ExaminationId = DateTime.Now.Ticks;
SaveOrUpdate(configEntity);
}
public async Task Save(DeviceConfiguration deviceConfiguration)
{
var file = (IStorageFile) await storageFolder.TryGetItemAsync(filename);
if(file == null)
{
file = await storageFolder.CreateFileAsync(filename);
}
var configString = JsonConvert.SerializeObject(deviceConfiguration);
await FileIO.WriteTextAsync(file, configString);
}
public void SaveConfiguration()
{
var config1 = new DeviceConfiguration();
var config2 = new DeviceConfiguration();
var trans = _session.BeginTransaction();
_examinationsDal.AddConfiguration(config1);
_examinationsDal.AddConfiguration(config2);
trans.Commit();
}
public void GetConfigByExamId_Success()
{
var config1 = new DeviceConfiguration();
var config2 = new DeviceConfiguration();
var trans = _session.BeginTransaction();
_examinationsDal.AddConfiguration(config1);
_examinationsDal.AddConfiguration(config2);
trans.Commit();
var result = _examinationsDal.GetDeviceConfigurationByExaminationId(0);
}
protected void DisplayDeviceCongifuration()
{
DeviceConfiguration currentDeviceConfiguration;
History currentHistoryNote;
// Initializing selected in SuperUserWindow list Device state
try
{
currentDeviceConfiguration =
DeviceConfiguration.
GetDeviceConfiguration(
SelectedDevice
);
// Defining which IP do device have
for (int i = 0; i < ipAddressBox.Items.Count; i++)
{
if ((ipAddressBox.Items[i] as IPAddress).ID ==
currentDeviceConfiguration.IP.ID)
{
ipAddressBox.SelectedIndex = i;
}
}
// Displaying device password in passwordTextBox
passwordBox.Text =
currentDeviceConfiguration.
AccountPassword;
// Same for account name
accoutNameBox.Text = currentDeviceConfiguration.AccountName;
}
catch (NoSuchDataException) { }
try
{
currentHistoryNote = History.GetDeviceLastHistoryNote(SelectedDevice);
// Setting device's Corps
for (int i = 0; i < corpsBox.Items.Count; i++)
{
if ((corpsBox.Items[i] as Corps).ID == currentHistoryNote.CorpsID)
{
corpsBox.SelectedIndex = i;
}
}
}
catch (NoSuchDataException) { }
}
/// <summary>
/// Initializes a new instance of the <see cref="AndroidDevice"/> class.
/// </summary>
/// <param name="configuration">Device Configuration</param>
public AndroidDevice(DeviceConfiguration configuration)
{
Configuration = configuration;
var server = new UiAutomatorServer(new Terminal(configuration), configuration.Port, configuration.DumpTimeout);
Adb = new AdbService(new Terminal(configuration));
Ui = new UiService(
new ScreenDumper(server, configuration.DumpTries),
new NodeParser(),
new NodeFinder());
Settings = new SettingsService();
Activity = new ActivityService();
Interaction = new InteractionService(server);
SetOwner();
InstallHelperApks();
}
/// <summary>
/// Most pcap configuration functions have the signature int pcap_set_foo(pcap_t, int)
/// This is a helper method to use them and detect/report errors
/// </summary>
/// <param name="configuration"></param>
/// <param name="setter"></param>
/// <param name="property"></param>
/// <param name="value"></param>
protected void Configure(
DeviceConfiguration configuration,
string property,
Func <IntPtr, int, int> setter,
int?value
)
{
if (value.HasValue)
{
var retval = setter(PcapHandle, value.Value);
if (retval != 0)
{
configuration.RaiseConfigurationFailed(property, retval);
}
}
}
/// <summary>
/// Simple, non-critical maintenance task assigned to the shift closing event.
/// </summary>
/// <param name="requestContext">The request context.</param>
private void PurgeSalesTransactionData(RequestContext requestContext)
{
if (requestContext == null || requestContext.Runtime == null)
{
return;
}
// Get retention period in days from device configuration
Terminal terminal = requestContext.GetTerminal();
DeviceConfiguration deviceConfiguration = requestContext.GetDeviceConfiguration();
// Purge transactions
PurgeSalesTransactionsDataRequest dataServiceRequest = new PurgeSalesTransactionsDataRequest(terminal.ChannelId, terminal.TerminalId, deviceConfiguration.RetentionDays);
requestContext.Runtime.Execute <NullResponse>(dataServiceRequest, this.Context);
}
public void UpdateMotionFrame(DeviceConfiguration config, MotionFrame frame)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke((Action) delegate
{
UpdateMotionFrame(config, frame);
});
return;
}
sensorImage.ProcessDepthFrame(frame.DepthFrame);
depthImage.Source = sensorImage.DepthImageSource;
rgbImage.Source = frame.RGBFrame.AsRgbBitmapSource();
skeletonImage.Source = frame.Skeletons.AsSkeletonBitmapSource(frame.DepthFrame.Width, frame.DepthFrame.Height);
}
public void UpdateMotionFrame(DeviceConfiguration config, MotionFrame frame)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke((Action)delegate
{
UpdateMotionFrame(config, frame);
});
return;
}
sensorImage.ProcessDepthFrame(frame.DepthFrame);
depthImage.Source = sensorImage.DepthImageSource;
rgbImage.Source = frame.RGBFrame.AsRgbBitmapSource();
skeletonImage.Source = frame.Skeletons.AsSkeletonBitmapSource(frame.DepthFrame.Width, frame.DepthFrame.Height);
}
/// <summary>
/// Most pcap configuration functions have the signature int pcap_set_foo(pcap_t, int)
/// those functions also set the error buffer, so we read it
/// This is a helper method to use them and detect/report errors
/// </summary>
/// <param name="configuration"></param>
/// <param name="setter"></param>
/// <param name="property"></param>
/// <param name="value"></param>
protected void Configure(
DeviceConfiguration configuration,
string property,
Func <PcapHandle, int, PcapError> setter,
int?value
)
{
if (value.HasValue)
{
var retval = setter(Handle, value.Value);
if (retval != 0)
{
configuration.RaiseConfigurationFailed(property, retval, GetLastError(Handle));
}
}
}
/// <summary>
/// Open the device. To start capturing call the 'StartCapture' function
/// </summary>
/// <param name="configuration">
/// A <see cref="DeviceConfiguration"/>
/// </param>
public virtual void Open(DeviceConfiguration configuration)
{
// Caches linkType value.
// Open refers to the device being "created"
// This method is called by sub-classes in the override method
int dataLink = 0;
if (Opened)
{
dataLink = LibPcapSafeNativeMethods.pcap_datalink(Handle);
}
if (dataLink >= 0)
{
linkType = (PacketDotNet.LinkLayers)dataLink;
}
}
public async Task <SparkDeviceOperationState> RequestCurrentState(DeviceConfiguration deviceConfig)
{
ParticleDevice device = await LoginAndGetParticleDevice(deviceConfig);
ParticleVariableResponse currentStateResult = await device.GetVariableAsync(SPARKVARIABLE_CURRENTSTATE);
try
{
SparkDeviceOperationState operationState = (SparkDeviceOperationState)int.Parse(currentStateResult.Result);
return(operationState);
}
catch (Exception e)
{
throw new InvalidOperationException("Enum value not supported for SparkDeviceOperationState");
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
deviceConfigurationRepo = new LocalDeviceConfigurationRepo();
deviceConfiguration = await deviceConfigurationRepo.Get();
if (deviceConfiguration == null)
{
deviceConfiguration = new DeviceConfiguration();
}
else
{
ToggleMenu();
Address.Text = deviceConfiguration.DefaulUrl;
MyWebView.Navigate(new Uri(deviceConfiguration.DefaulUrl));
}
}
private void RunRequests(DeviceConfiguration config)
{
var ac = config.Agent;
if (ac != null)
{
// Run a Probe request and get the returned data
if (probeData == null)
{
probeData = GetProbe(ac);
// Send the Probe data to other plugins
SendProbeData(probeData, config);
}
if (probeData != null)
{
// Run a Current request and get the returned data
currentData = GetCurrent(ac);
if (currentData != null && currentData.Header != null)
{
// Send the Current data to other plugins
SendCurrentData(currentData, config);
//Run a Sample request and get the returned data
var sampleData = GetSample(currentData.Header, ac, config);
//Send the Sample data to other plugins
if (sampleData != null)
{
SendSampleData(sampleData, config);
}
UpdateAgentData(currentData.Header.InstanceId, currentData.Header.LastSequence);
}
else
{
probeData = null;
SendAvailability(false, ac.Heartbeat, config);
}
}
else
{
SendAvailability(false, ac.Heartbeat, config);
}
}
}
private static Image CreateTestDepthImage(DeviceConfiguration config, Microseconds64 colorTimestamp)
{
if (!config.DepthMode.HasDepth())
{
return(null);
}
var width = config.DepthMode.WidthPixels();
var height = config.DepthMode.HeightPixels();
var buffer = new short[width * height];
var image = Image.CreateFromArray(buffer, ImageFormat.Depth16, width, height);
image.DeviceTimestamp = colorTimestamp + config.DepthDelayOffColor;
return(image);
}
public void UpdateMotionFrame(DeviceConfiguration config, MotionFrame frame)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke((Action) delegate
{
UpdateMotionFrame(config, frame);
});
return;
}
if (!pointCloudImage.IsInitialized)
{
Activate(config);
}
pointCloudImage.SetMotionFrame(frame);
}
private void LoadLocalDevices()
{
var deviceConfigs = DeviceConfiguration.ReadAll(FileLocations.Devices);
if (deviceConfigs != null)
{
foreach (var deviceConfig in deviceConfigs)
{
if (deviceConfig.Description != null)
{
AddDevice(new DeviceDescription(deviceConfig));
}
}
}
SendDevicesLoadedMessage();
}
public T CreateDeviceInstance <T>(DeviceConfiguration configuration) where T : IDevice
{
Type deviceType = typeof(T);
switch (deviceType.Name)
{
case nameof(FilterWheel):
IDevice device = new FilterWheel(configuration, _clientTransactionIdGenerator);
return((T)device);
case nameof(SafetyMonitor):
IDevice safetyMonitor = new SafetyMonitor(configuration, _clientTransactionIdGenerator);
return((T)safetyMonitor);
case nameof(Dome):
IDevice dome = new Dome(configuration, _clientTransactionIdGenerator);
return((T)dome);
case nameof(Camera):
IDevice camera = new Camera(configuration, _clientTransactionIdGenerator);
return((T)camera);
case nameof(Focuser):
IDevice focuser = new Focuser(configuration, _clientTransactionIdGenerator);
return((T)focuser);
case nameof(ObservingConditions):
IDevice observingConditions = new ObservingConditions(configuration, _clientTransactionIdGenerator);
return((T)observingConditions);
case nameof(Rotator):
IDevice rotator = new Rotator(configuration, _clientTransactionIdGenerator);
return((T)rotator);
case nameof(Switch):
IDevice @switch = new Switch(configuration, _clientTransactionIdGenerator);
return((T)@switch);
case nameof(Telescope):
IDevice telescope = new Telescope(configuration, _clientTransactionIdGenerator);
return((T)telescope);
default:
throw new InvalidOperationException($"Type {deviceType.Name} is not supported");
}
}
private static void AddCaptureItems(string prefix, DataTable table, List <DataItem> dataItems)
{
string capturePrefix = prefix + "/Capture";
var item = dataItems.Find(x => x.Category == DataItemCategory.EVENT && x.Type == "PROGRAM");
if (item != null)
{
DeviceConfiguration.EditTable(table, capturePrefix + "/Item||00", null, "id||00;name||program_name;link||" + item.Id + ";");
}
item = dataItems.Find(x => x.Category == DataItemCategory.EVENT && x.Type == "EXECUTION");
if (item != null)
{
DeviceConfiguration.EditTable(table, capturePrefix + "/Item||01", null, "id||01;name||execution_mode;link||" + item.Id + ";");
}
}
public ConfigDialog(DeviceConfiguration deviceConfiguration)
{
this.InitializeComponent();
this.comboBoxCameraImageUrl.DataSource = new string[]
{
"/jpg/image.jpg", //Axis
"/snapshot/1/snapshot.jpg" //Eneo
};
this.comboBoxPanTiltControl.DataSource = ((PanTiltControlType[])Enum.GetValues(typeof(PanTiltControlType))).OrderBy(x => x.ToString()).ToList();
this.comboBoxComType.DataSource = ((CommunicationType[])Enum.GetValues(typeof(CommunicationType))).OrderBy(x => x.ToString()).ToList();
this.comboBoxPort.DataSource = SerialPort.GetPortNames();
if (deviceConfiguration == null)
{
this.DeviceConfiguration = new DeviceConfiguration();
}
else
{
this.DeviceConfiguration = deviceConfiguration;
this.comboBoxPanTiltControl.SelectedItem = this.DeviceConfiguration.PanTiltControlType;
this.comboBoxComType.SelectedItem = this.DeviceConfiguration.CommunicationType;
this.textBoxPanTilt.Text = this.DeviceConfiguration.PanTiltIpAddress;
this.comboBoxPort.Text = this.DeviceConfiguration.ComPort;
this.checkBoxCameraActive.Checked = this.DeviceConfiguration.CameraActive;
this.textBoxCameraIpAddress.Text = this.DeviceConfiguration.CameraIpAddress;
this.comboBoxCameraImageUrl.Text = this.DeviceConfiguration.CameraJpegUrl;
this.textBoxCameraIpAddress.Text = this.DeviceConfiguration.CameraIpAddress;
}
#region Discover devices
this.comboBoxDiscoverd.DisplayMember = "Name";
this.comboBoxDiscoverd.ValueMember = "IpAddress";
var discoveredDevices = new List <DiscoveredDevice>
{
new DiscoveredDevice {
Manufacturer = "Discover network ..."
}
};
this.comboBoxDiscoverd.DataSource = discoveredDevices;
_ = Task.Run(async() => await this.DiscoverDevicesAsync());
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="AndroidDevice"/> class.
/// </summary>
/// <param name="configuration">Device Configuration</param>
/// <param name="adbService">Service to handle communication with adb</param>
/// <param name="uiService">Service to handle UI</param>
/// <param name="settingsService">Service to handle settings</param>
/// <param name="activityService">Service to handle activities</param>
/// <param name="interactionService">Service to handle interaction with the device</param>
public AndroidDevice(
DeviceConfiguration configuration,
IAdbService adbService,
IUiService uiService,
ISettingsService settingsService,
IActivityService activityService,
IInteractionService interactionService)
{
Configuration = configuration;
Adb = adbService;
Ui = uiService;
Settings = settingsService;
Activity = activityService;
Interaction = interactionService;
SetOwner();
InstallHelperApks();
}
// Example URL (GET)
// -----------------------------------------------------
// ../api/devices/get?token=01234&sender_id=56789 (Get all devices for the user)
// OR
// ../api/devices/get?token=01234&sender_id=56789&unique_id=ABCDEFG (Get only the device with the specified 'unique_id')
// -----------------------------------------------------
// Example Post Data
// -----------------------------------------------------
// name = 'token'
// value = 01234 (Session Token)
// name = 'sender_id'
// value = 56789 (Sender ID)
// (Optional)
// name = 'devices'
// value = [
// { "unique_id": "ABCDEFG" },
// { "unique_id": "HIJKLMN" }
// ]
// -----------------------------------------------------
/// <summary>
/// Get a single DeviceConfiguration
/// </summary>
/// <param name="userConfig">UserConfiguration object for the current user</param>
/// <param name="deviceUniqueId">The Unique ID of the device to return</param>
/// <returns></returns>
public static DeviceConfiguration Get(UserConfiguration userConfig, string deviceUniqueId)
{
if (!string.IsNullOrEmpty(deviceUniqueId))
{
Uri apiHost = ApiConfiguration.AuthenticationApiHost;
string url = new Uri(apiHost, "devices/get/index.php").ToString();
string format = "{0}?token={1}&sender_id={2}&unique_id={3}";
string token = userConfig.SessionToken;
string senderId = UserManagement.SenderId.Get();
url = string.Format(format, url, token, senderId, deviceUniqueId);
string response = HTTP.GET(url);
if (response != null)
{
bool success = ApiError.ProcessResponse(response, "Get Devices");
if (success)
{
var deviceInfos = JSON.ToType <List <DeviceInfo> >(response);
if (deviceInfos != null && deviceInfos.Count > 0)
{
var deviceInfo = deviceInfos[0];
var table = deviceInfo.ToTable();
if (table != null)
{
var xml = DeviceConfiguration.TableToXml(table);
if (xml != null)
{
var deviceConfig = DeviceConfiguration.Read(xml);
if (deviceConfig != null && !string.IsNullOrEmpty(deviceConfig.UniqueId))
{
return(deviceConfig);
}
}
}
}
}
}
}
return(null);
}
public static void SaveDeviceConfig(string connString, DeviceConfiguration config)
{
MySqlConnection conn = null;
conn = OpenConnection(connString);
var query = "UPDATE device_config SET configuration=@Configuration WHERE device_id=@DeviceId";
MySqlCommand cmd = new MySqlCommand(query, conn);
cmd.Parameters.AddWithValue("@DeviceId", config.DeviceId);
cmd.Parameters.AddWithValue("@Configuration", JsonConvert.SerializeObject(config));
cmd.ExecuteNonQuery();
if (conn != null && conn.State == ConnectionState.Open)
{
conn.Close();
}
}
public void UpdateMotionFrame(DeviceConfiguration config, MotionFrame frame)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke((Action)delegate
{
UpdateMotionFrame(config, frame);
});
return;
}
if (!pointCloudImage.IsInitialized)
{
Activate(config);
}
pointCloudImage.SetMotionFrame(frame);
}
public void Initialize(DeviceConfiguration config)
{
configuration = config;
var agentData = AgentData.Load(config);
if (agentData != null)
{
agentInstanceId = agentData.InstanceId;
lastInstanceId = agentData.InstanceId;
lastSequenceSampled = agentData.LastSequence;
System.Console.WriteLine(config.UniqueId + " :: " + agentInstanceId + " : " + lastSequenceSampled);
}
Start(config);
}
public void NonCompatibleModes()
{
using var device = GetPcapDevice();
var config = new DeviceConfiguration
{
Mode = DeviceModes.NoCaptureLocal,
BufferSize = 128 * 1024,
};
var ex = Assert.Throws <PcapException>(() => device.Open(config));
if (ex.Error != PcapError.PlatformNotSupported)
{
StringAssert.Contains(nameof(DeviceConfiguration.BufferSize), ex.Message);
}
}
public bool OpenSensor(int deviceIndex = 0)
{
_KinectSensor = Device.Open(deviceIndex);
if (_KinectSensor == null)
{
Debug.LogError("AzureKinect cannot be opened.");
return(false);
}
DeviceConfiguration kinectConfig = new DeviceConfiguration();
kinectConfig.ColorFormat = _ColorImageFormat;
kinectConfig.ColorResolution = (ColorResolution)_ColorCameraMode;
kinectConfig.DepthMode = (DepthMode)_DepthCameraMode;
if (_ColorCameraMode != ColorCameraMode._4096_x_3072_15fps &&
_DepthCameraMode != DepthCameraMode._1024x1024_15fps)
{
kinectConfig.CameraFPS = FPS.FPS30;
}
else
{
kinectConfig.CameraFPS = FPS.FPS15;
}
_KinectSensor.StartCameras(kinectConfig);
_IsCameraStarted = true;
_KinectSensor.StartImu();
_DeviceCalibration = _KinectSensor.GetCalibration();
_Transformation = _DeviceCalibration.CreateTransformation();
CameraCalibration colorCamera = _DeviceCalibration.ColorCameraCalibration;
_ColorImageWidth = colorCamera.ResolutionWidth;
_ColorImageHeight = colorCamera.ResolutionHeight;
CameraCalibration depthCamera = _DeviceCalibration.DepthCameraCalibration;
_DepthImageWidth = depthCamera.ResolutionWidth;
_DepthImageHeight = depthCamera.ResolutionHeight;
return(true);
}
public void TestAttachments()
{
var mkvPath = GenerateTempMkvFilePath();
var config = new DeviceConfiguration
{
CameraFps = FrameRate.Fifteen,
ColorFormat = ImageFormat.ColorNV12,
ColorResolution = ColorResolution.R720p,
DepthMode = DepthMode.NarrowView2x2Binned,
};
var deviceTimestamp0 = Microseconds64.FromMilliseconds(1.0);
var deviceTimestamp1 = Microseconds64.FromMilliseconds(7.7);
var attachment1Name = "\ud182\ud0b5\ud181\ud182 \ud0ba\ud0be\ud0b4\ud0b8\ud180\ud0be\ud0b2\ud0ba\ud0b8";
var attachment1Data = new byte[] { 1, 255, 0, 8, 7, 254, 128, 3, 127, 65, 179 };
var attachment2Name = "another_attachment.file";
var attachment2Data = new byte[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250 };
using (var recorder = new Recorder(mkvPath, null, config))
{
recorder.AddAttachment(attachment1Name, attachment1Data);
recorder.AddAttachment(attachment2Name, attachment2Data);
recorder.WriteHeader();
WriteTestCaptures(recorder, deviceTimestamp0, deviceTimestamp1);
}
using (var playback = new Playback(mkvPath))
{
Assert.IsTrue(playback.TryGetAttachment(attachment1Name, out var data1));
AssertAreEqual(attachment1Data, data1);
Assert.IsTrue(playback.TryGetAttachment(attachment2Name, out var data2));
AssertAreEqual(attachment2Data, data2);
Assert.IsFalse(playback.TryGetAttachment("some_unknown_attachment_name", out var tmp));
Assert.IsNull(tmp);
}
File.Delete(mkvPath);
}
private void Device_MessageReceived(object sender, MrsMessage e)
{
Device dvc = (Device)sender;
Console.WriteLine($"{e.MrsMessageType} received from {dvc.DeviceIP}:{dvc.DevicePort}");
switch (e.MrsMessageType)
{
case MrsMessageTypes.DeviceConfiguration:
// save config
_deviceConfiguration = (DeviceConfiguration)e;
// override ip and port
_deviceConfiguration.NotificationServiceIPAddress = _configuration.ListenIP;
_deviceConfiguration.NotificationServicePort = _configuration.ListenPort.ToString();
break;
case MrsMessageTypes.DeviceStatusReport:
// save status
// if status contain already values - update
_statusReport =
(DeviceStatusReport)(_statusReport == null
? e
: _statusReport.UpdateValues(e));
if (_sensor == null)
{
// now that we have config and status, start the sensor (listening side)
_sensor = new Sensor(_deviceConfiguration, _statusReport)
{
ValidateMessages = false
};
_sensor.MessageSent += Sensor_MessageSent;
_sensor.MessageReceived += Sensor_MessageReceived;
_sensor.ValidationErrorOccured += Sensor_ValidationErrorOccured;
Console.WriteLine("Starting sensor...");
_sensor.Start();
Console.WriteLine($"Sensor started on {_sensor.IP}:{_sensor.Port}");
}
break;
case MrsMessageTypes.DeviceIndicationReport:
var indicationReport = (DeviceIndicationReport)e;
_sensor?.RegisterIndications(ExtractIndications(indicationReport));
break;
}
}
private static bool ScanWeekendPoints(DeviceConfiguration config, ref float tempTarget)
{
DateTime now = DateTime.Now;
foreach (var point in config.WeekendPoints)
{
if (point.IsSaturday && now.DayOfWeek == DayOfWeek.Saturday || point.IsSunday && now.DayOfWeek == DayOfWeek.Sunday)
{
if ((now.Hour * 100 + now.Minute >= point.StartHour * 100 + point.StartMinute) && (now.Hour * 100 + now.Minute <= point.EndHour * 100 + point.EndMinute))
{
tempTarget = point.Temperature;
return(true);
}
}
}
return(false);
}
private static int GetBuiltInTrackCount(DeviceConfiguration config)
{
var count = 0;
if (config.ColorResolution != ColorResolution.Off)
{
count++;
}
if (config.DepthMode.HasDepth())
{
count++;
}
if (config.DepthMode.HasPassiveIR())
{
count++;
}
return(count);
}
public string GetSegmentEnd(DeviceConfiguration config)
{
//var sc = TrakHound.Server.Plugins.Shifts.ShiftConfiguration.Get(config);
//if (sc != null)
//{
// var shift = sc.shifts.Find(x => x.id == Shift);
// if (shift != null)
// {
// var segment = shift.segments.Find(x => x.id == Segment);
// if (segment != null)
// {
// return segment.endTime.To24HourString();
// }
// }
//}
return(null);
}
public bool TryCreateDevice(string id, DeviceConfiguration deviceConfiguration, out IDevice device)
{
switch (deviceConfiguration.Driver.Type)
{
case "Outpost.LpdBridge":
{
return(CreateGetLpdBridgeAdapter(id, deviceConfiguration, out device));
}
case "I2CHardwareBridge":
{
return(CreateI2CHardwareBridge(id, deviceConfiguration, out device));
}
}
device = null;
return(false);
}
public DeviceSetup Update(DeviceSetup deviceSetup)
{
DeviceConfiguration existingConfiguration = GetSingle(deviceSetup.Id);
if (existingConfiguration != null)
{
_dbContext.Update(existingConfiguration);
existingConfiguration.PollingEnabled = deviceSetup.PollingEnabled;
existingConfiguration.PostBackIntervalMinutes = deviceSetup.PostBackIntervalMinutes;
existingConfiguration.PostBackUrl = deviceSetup.PostBackUrl;
existingConfiguration.PostBackPort = deviceSetup.PostBackPort;
_dbContext.SaveChanges();
}
return(existingConfiguration);
}
private static Image CreateTestColorImage(DeviceConfiguration config, Microseconds64 colorTimestamp)
{
if (config.ColorResolution == ColorResolution.Off)
{
return(null);
}
var width = config.ColorResolution.WidthPixels();
var height = config.ColorResolution.HeightPixels();
var stride = config.ColorFormat.StrideBytes(width);
var buffer = new byte[config.ColorFormat.ImageSizeBytes(stride, height)];
var image = Image.CreateFromArray(buffer, config.ColorFormat, width, height);
image.DeviceTimestamp = colorTimestamp;
return(image);
}
private void UpdateFrameViewer(MotionFrame frame)
{
if (pointCloudFrameViewer != null)
{
currentConfiguration = new DeviceConfiguration()
{
DepthBufferFormat = new BufferFormat(frame.DepthFrame.Width, frame.DepthFrame.Height, frame.DepthFrame.PixelFormat),
VideoBufferFormat = new BufferFormat(frame.RGBFrame.Width, frame.RGBFrame.Height, frame.RGBFrame.PixelFormat),
};
pointCloudFrameViewer.UpdateMotionFrame(currentConfiguration, frame);
}
}
private void InitConfiguration()
{
var config = new DeviceConfiguration();
config.DepthBufferFormat = DepthBufferFormats.Format320X240X16;
config.VideoBufferFormat = ImageBufferFormats.Format1280X960X32;
//config.DepthBufferFormat = DepthBufferFormats.Format640X480X16;
//config.VideoBufferFormat = ImageBufferFormats.Format1280X960X32;
currentConfiguration = config;
}
public static DeviceConfiguration CreateDeviceConfiguration(string objectId, global::System.Collections.ObjectModel.Collection<byte[]> publicIssuerCertificates, global::System.Collections.ObjectModel.Collection<byte[]> cloudPublicIssuerCertificates)
{
DeviceConfiguration deviceConfiguration = new DeviceConfiguration();
deviceConfiguration.objectId = objectId;
if ((publicIssuerCertificates == null))
{
throw new global::System.ArgumentNullException("publicIssuerCertificates");
}
deviceConfiguration.publicIssuerCertificates = publicIssuerCertificates;
if ((cloudPublicIssuerCertificates == null))
{
throw new global::System.ArgumentNullException("cloudPublicIssuerCertificates");
}
deviceConfiguration.cloudPublicIssuerCertificates = cloudPublicIssuerCertificates;
return deviceConfiguration;
}
private void InitSensor()
{
sensorDevice = new KinectSdkDevice();
var config = new DeviceConfiguration();
config.DepthBufferFormat = DepthBufferFormats.Format320X240X16;
config.VideoBufferFormat = ImageBufferFormats.Format640X480X32;
sensorDevice.Initialize(config);
sensorDevice.SetTiltAngle(0);
sensorDevice.CompositeFrameAvailable += new CompositeFrameAvailableEventHandler(device_CompositeFrameAvailable);
}
public void Activate(DeviceConfiguration config)
{
imageContext = new ImageProcessorContext();
sensorImage = new SensorImageProcessor(imageContext);
}
