public bool Read(SetupProfile profile, XmlNode root)
{
foreach (XmlNode node in root)
{
if (node.Name.Equals("Cap3Point"))
{
if (node.Attributes["Index"] == null)
{
return(false);
}
int index = JsonString.ParseInt(node.Attributes["Index"].InnerText, -1);
if (index < 0)
{
return(false);
}
EquipmentSettings settings = ReadCap3Point(node);
if (settings == null)
{
return(false);
}
profile.AddTracker(index, settings);
}
}
return(true);
}
public XmlNode Write(SetupProfile profile, XmlNode root, XmlDocument target)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (root == null)
{
throw new ArgumentNullException("root");
}
foreach (int i in profile.VideoCaptureIndexes)
{
EquipmentSettings settings = profile.GetVideoCapture(i);
XmlNode node = WriteStream(i, settings, target);
if (node != null)
{
root.AppendChild(node);
}
}
return(root);
}
public bool Write(SetupProfile profile, XmlNode root, XmlDocument target)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (root == null)
{
throw new ArgumentNullException("root");
}
foreach (int i in profile.TrackerIndexes)
{
EquipmentSettings settings = profile.GetTracker(i);
XmlNode node = WriteCap3Point(i, settings, target);
if (node != null)
{
root.AppendChild(node);
}
}
return(true);
}
public bool ApplySettings(EquipmentSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
lock (captureSync) {
// trivial case if not started
if (!Capturing)
{
this.settings = new EquipmentSettings(settings);
return(true);
}
// otherwise we have to stop the capture
// provide new settings
// and restart the capture
if (!Stop())
{
return(false);
}
this.settings = new EquipmentSettings(settings);
if (!Start())
{
return(false);
}
}
return(true);
}
public EquipmentSettings GetSettings()
{
lock (captureSync) {
var result = new EquipmentSettings(settings);
result.SetInteger(SensorProperty.Capturing, (videoFrame != IntPtr.Zero) ? 1 : 0);
return(result);
}
}
public KeypointDetector(EquipmentSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
}
public void AddTracker(int index, EquipmentSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
trackers[index] = settings;
}
public void AddVideoCapture(int index, EquipmentSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
captures[index] = settings;
}
public Utility(Machine machine, string path)
{
Machine = machine;
CreatePaths(path);
Version = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion;
CharacterSettings = LoadCharacterSettings();
BotSettings = LoadBotSettings();
Inventory = LoadInventories();
EquipmentSettings = LoadEquipmentSettings();
LoadBuffProfiles();
}
public P3PoseEstimator(EquipmentSettings settings, IObjectModel model)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
this.settings = settings;
this.model = model;
}
private XmlNode WriteStream(int index, EquipmentSettings settings, XmlDocument target)
{
var result = target.CreateElement("Webcam");
result.SetAttribute("Index", index.ToString(JsonString.FormatProvider));
result.SetAttribute("Name", settings.GetText(SensorProperty.Name, "Webcam"));
{ // camera
XmlElement node = target.CreateElement("Camera");
result.AppendChild(node);
node.InnerText = settings.GetInteger(SensorProperty.CameraId, 0).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.CameraId).ToString());
}
{ // width
XmlElement node = target.CreateElement("Width");
result.AppendChild(node);
node.InnerText = settings.GetInteger(SensorProperty.FrameWidth, 640).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.FrameWidth).ToString());
}
{ // height
XmlElement node = target.CreateElement("Height");
result.AppendChild(node);
node.InnerText = settings.GetInteger(SensorProperty.FrameHeight, 480).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.FrameHeight).ToString());
}
{ // fps
XmlElement node = target.CreateElement("FPS");
result.AppendChild(node);
node.InnerText = settings.GetInteger(SensorProperty.FrameRate, 30).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.FrameRate).ToString());
}
{ // exposure
XmlElement node = target.CreateElement("Exposure");
result.AppendChild(node);
node.InnerText = settings.GetDecimal(SensorProperty.Exposure, 0.0m).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.Exposure).ToString());
}
{ // brightness
XmlElement node = target.CreateElement("Brightness");
result.AppendChild(node);
node.InnerText = settings.GetDecimal(SensorProperty.Brightness, 0.0m).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.Brightness).ToString());
}
{ // contrast
XmlElement node = target.CreateElement("Contrast");
result.AppendChild(node);
node.InnerText = settings.GetDecimal(SensorProperty.Contrast, 0.0m).ToString();
node.SetAttribute("Auto", settings.IsAuto(SensorProperty.Contrast).ToString());
}
return(result);
}
public PointLabeler(EquipmentSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
this.lastLabels = new int[0];
this.lastPoints = new Point2i[0];
this.inPoints = new Point2i[0];
this.outPoints = new Point2i[0];
this.outLabels = new int[0];
this.permutations = new int[0][];
this.permutationPointNo = 0;
}
public P3CapTracker(EquipmentSettings settings) : base()
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = new EquipmentSettings(settings);
this.pointDetector = null;
this.pointLabeler = null;
this.poseEstimator = null;
IRasterImageBase frame = new TrackerVideoFrame(1, 1, new byte[1]);
this.imageOut = SharedRef.Create(frame);
this.imageCleaner = new SharedRefCleaner(32);
this.trackerSync = new object();
}
public override bool ApplySettings(EquipmentSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
lock (trackerSync) {
this.settings = new EquipmentSettings(settings);
if (Running)
{
var model = new CapModel();
pointDetector = new KeypointDetector(this.settings);
pointLabeler = new PointLabeler(this.settings);
poseEstimator = new P3PoseEstimator(this.settings, model);
}
}
return(true);
}
private HttpStatusCode RespondGet(JsonString requestSubject, JsonString responseSubject, int sensorStart, int sensorEnd)
{
object dataSync = new object();
JsonString data;
lock (dataSync) { // TODO lock required?
data = JsonString.CreateArray();
}
var readySignal = new ManualResetEvent(false);
CaptureSystem.Instance.Invoke((object sender, EventArgs args) => {
var system = (CaptureSystem)sender;
for (int i = sensorStart; i <= sensorEnd; i++)
{
var entry = JsonString.CreateDict();
ISensorBase sensor = system.GetSensor(i);
if (sensor == null)
{
entry.AddTerminal("inuse", "false");
}
else if (sensor.SensorType == SensorType.Webcam)
{
var capture = (WebcamCapture)sensor;
EquipmentSettings settings = capture.GetSettings();
entry.AddTerminal("inuse", "true");
entry.AddJsonString("settings", EquipmentSettings.ToJson(settings));
}
else
{
entry.AddTerminal("inuse", "false");
}
data.AddJsonString(string.Empty, entry);
}
readySignal.Set();
});
readySignal.WaitOne();
lock (dataSync) {
responseSubject.AddJsonString("data", data);
}
return(HttpStatusCode.OK);
}
private HttpStatusCode RespondGet(JsonString requestSubject, JsonString responseSubject, int[] positions)
{
object dataSync = new object();
JsonString data;
lock (dataSync) { // TODO lock required?
data = JsonString.CreateDict();
}
var readySignal = new ManualResetEvent(false);
TrackingSystem.Instance.Invoke((object sender, EventArgs args) => {
var system = (TrackingSystem)sender;
foreach (int pos in positions)
{
var entry = JsonString.CreateDict();
IPoseTracker tracker = system.GetTracker(pos);
if (tracker == null)
{
entry.AddTerminal("inuse", "false");
}
else if (tracker is P3CapTracker)
{
var capTracker = (P3CapTracker)tracker;
EquipmentSettings settings = capTracker.GetSettings();
entry.AddTerminal("inuse", "true");
entry.AddJsonString("settings", EquipmentSettings.ToJson(settings));
}
data.AddJsonString(JsonString.Stringify(pos), entry);
}
readySignal.Set();
});
readySignal.WaitOne();
lock (dataSync) {
responseSubject.AddJsonString("data", data);
}
return(HttpStatusCode.OK);
}
private XmlNode WriteCap3Point(int index, EquipmentSettings settings, XmlDocument target)
{
XmlElement result = target.CreateElement("Cap3Point");
result.SetAttribute("Index", index.ToString());
// stream
for (int i = 0; i < 2; i++) // stream
{
int stream = settings.GetInteger(TrackerProperty.Stream0 + i, -1);
if (stream > -1)
{
XmlElement node = target.CreateElement("Stream");
result.AppendChild(node);
node.InnerText = stream.ToString();
}
}
{ // model
// TODO implement
}
{ // mixing
int mixing = settings.GetInteger(TrackerProperty.Smoothing, -1);
if (mixing > -1)
{
XmlElement node = target.CreateElement("Smoothing");
result.AppendChild(node);
node.InnerText = mixing.ToString();
}
}
{
decimal mixingDecline = settings.GetDecimal(TrackerProperty.SmoothingDropoff, -1.0m);
if (mixingDecline > -1.0m)
{
XmlElement node = target.CreateElement("SmoothingDropoff");
result.AppendChild(node);
node.InnerText = mixingDecline.ToString(JsonString.FormatProvider);
}
}
{
int bright = settings.GetInteger(TrackerProperty.MinBrightness, -1);
if (bright > -1)
{
XmlElement node = target.CreateElement("MinBrightness");
result.AppendChild(node);
node.InnerText = bright.ToString();
}
}
{ // cluster radius
int radius = settings.GetInteger(TrackerProperty.MinClusterRadius, -1);
if (radius > -1)
{
XmlElement node = target.CreateElement("MinClusterRadius");
result.AppendChild(node);
node.InnerText = radius.ToString();
}
}
{
int radius = settings.GetInteger(TrackerProperty.MaxClusterRadius, -1);
if (radius > -1)
{
XmlElement node = target.CreateElement("MaxClusterRadius");
result.AppendChild(node);
node.InnerText = radius.ToString();
}
}
{ // cluster members
int members = settings.GetInteger(TrackerProperty.MaxClusterMembers, -1);
if (members > -1)
{
XmlElement node = target.CreateElement("MaxClusterMembers");
result.AppendChild(node);
node.InnerText = members.ToString();
}
}
{ // cluster no
int clusterNo = settings.GetInteger(TrackerProperty.MaxClusterNo, -1);
if (clusterNo > -1)
{
XmlElement node = target.CreateElement("MaxClusters");
result.AppendChild(node);
node.InnerText = clusterNo.ToString();
}
}
{ // point no
int pointNo = settings.GetInteger(TrackerProperty.MaxPointNo, -1);
if (pointNo > -1)
{
XmlElement node = target.CreateElement("MaxPoints");
result.AppendChild(node);
node.InnerText = pointNo.ToString();
}
}
{ // layer energy
int energy = settings.GetInteger(TrackerProperty.MinLayerEnergy, -1);
if (energy > -1)
{
XmlElement node = target.CreateElement("MinLayerEnergy");
result.AppendChild(node);
node.InnerText = energy.ToString();
}
}
{ // label no
int labelNo = settings.GetInteger(TrackerProperty.LabelNo, -1);
if (labelNo > -1)
{
XmlElement node = target.CreateElement("Labels");
result.AppendChild(node);
node.InnerText = labelNo.ToString();
}
}
{ // fast approx threshold
int threshold = settings.GetInteger(TrackerProperty.FastApproxThreshold, -1);
if (threshold > -1)
{
XmlElement node = target.CreateElement("FastApproxThreshold");
result.AppendChild(node);
node.InnerText = threshold.ToString();
}
}
{ // max queued images
int imageNo = settings.GetInteger(TrackerProperty.MaxQueuedImages, -1);
if (imageNo > -1)
{
XmlElement node = target.CreateElement("MaxQueuedImages");
result.AppendChild(node);
node.InnerText = imageNo.ToString();
}
}
return(result);
}
private EquipmentSettings ReadCap3Point(XmlNode root)
{
var result = new EquipmentSettings(typeof(TrackerProperty));
int streamNo = 0;
foreach (XmlNode node in root.ChildNodes)
{
if (node.Name.Equals("Stream"))
{
int stream = JsonString.ParseInt(node.InnerText, -1);
if (stream < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.Stream0 + streamNo, stream);
streamNo += 1;
}
else if (node.Name.Equals("Model"))
{
int model = JsonString.ParseInt(node.InnerText, -1);
if (model < 0)
{
return(null);
}
// TODO replace with another system
//result.SetInteger(TrackerProperty.Model, model);
}
else if (node.Name.Equals("Smoothing"))
{
int smoothing = JsonString.ParseInt(node.InnerText, -1);
if (smoothing < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.Smoothing, smoothing);
}
else if (node.Name.Equals("SmoothingDropoff"))
{
decimal dropoff = JsonString.ParseDecimal(node.InnerText, -1.0m);
if (dropoff == -1.0m)
{
return(null);
}
result.SetDecimal(TrackerProperty.SmoothingDropoff, dropoff);
}
else if (node.Name.Equals("MinBrightness"))
{
int brightness = JsonString.ParseInt(node.InnerText, -1);
if (brightness < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MinBrightness, brightness);
}
else if (node.Name.Equals("MinClusterRadius"))
{
int radius = JsonString.ParseInt(node.InnerText, -1);
if (radius < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MinClusterRadius, radius);
}
else if (node.Name.Equals("MaxClusterRadius"))
{
int radius = JsonString.ParseInt(node.InnerText, -1);
if (radius < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxClusterRadius, radius);
}
else if (node.Name.Equals("MinLayerEnergy"))
{
int energy = JsonString.ParseInt(node.InnerText, -1);
if (energy < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MinLayerEnergy, energy);
}
else if (node.Name.Equals("MaxClusterMembers"))
{
int members = JsonString.ParseInt(node.InnerText, -1);
if (members < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxClusterMembers, members);
}
else if (node.Name.Equals("MaxClusters"))
{
int clusters = JsonString.ParseInt(node.InnerText, -1);
if (clusters < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxClusterNo, clusters);
}
else if (node.Name.Equals("MaxPoints"))
{
int points = JsonString.ParseInt(node.InnerText, -1);
if (points < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxPointNo, points);
}
else if (node.Name.Equals("Labels"))
{
int labelNo = JsonString.ParseInt(node.InnerText, -1);
if (labelNo < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.LabelNo, labelNo);
}
else if (node.Name.Equals("FastApproxThreshold"))
{
int threshold = JsonString.ParseInt(node.InnerText, -1);
if (threshold < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.FastApproxThreshold, threshold);
}
else if (node.Name.Equals("MaxQueuedImages"))
{
int images = JsonString.ParseInt(node.InnerText, -1);
if (images < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxQueuedImages, images);
}
}
return(result);
}
public abstract bool ApplySettings(EquipmentSettings settings);
private HttpStatusCode RespondPost(JsonString requestSubject, JsonString responseSubject, int sensorIndex)
{
object dataSync = new object();
// first read the data from the data array
JsonString data = requestSubject.GetJsonString("data");
if (data == null || data.Type != JsonStringType.Array || data.Array.Count < 1)
{
return(HttpStatusCode.BadRequest);
}
var targetMap = new Dictionary <int, EquipmentSettings>();
for (int i = 0; i <= 0; i++)
{
JsonString sensor = data.GetJsonString(0);
if (sensor == null)
{
return(HttpStatusCode.BadRequest);
}
bool used = JsonString.ParseBool(sensor.GetTerminal("inuse", "false"), false);
if (used)
{
JsonString jSettings = sensor.GetJsonString("settings");
if (jSettings == null)
{
return(HttpStatusCode.BadRequest);
}
var settings = EquipmentSettings.FromJson(jSettings, typeof(SensorProperty));
targetMap.Add(sensorIndex + i, settings);
}
}
// secondly satisfy the request
var status = HttpStatusCode.OK;
var resultMap = new Dictionary <int, EquipmentSettings>();
var readySignal = new ManualResetEvent(false);
CaptureSystem.Instance.Invoke((object sender, EventArgs args) => {
var system = (CaptureSystem)sender;
for (int iSource = sensorIndex; iSource <= sensorIndex; iSource++)
{
// first determine which operations to perform
int iTarget = iSource;
bool connect = false;
bool disconnect = false;
bool start = false;
bool stop = false;
bool apply = false;
var entry = data.GetJsonString(0);
ISensorBase sensor = system.GetSensor(sensorIndex);
EquipmentSettings sourceSettings = null;
SensorType sourceType = SensorType.Webcam;
if (sensor != null)
{
sourceSettings = ((WebcamCapture)sensor).GetSettings();
int iType = sourceSettings.GetInteger(SensorProperty.Type, -1);
if (iType > -1)
{
sourceType = (SensorType)iType;
}
}
EquipmentSettings targetSettings = null;
SensorType targetType = SensorType.Webcam;
if (targetMap.TryGetValue(iSource, out targetSettings))
{
int iType = targetSettings.GetInteger(SensorProperty.Type, -1);
if (iType > -1)
{
targetType = (SensorType)iType;
}
}
if (sourceSettings == null && targetSettings != null)
{
connect = true;
}
else if (sourceSettings != null && targetSettings == null)
{
disconnect = true;
}
else if (sourceSettings == null && targetSettings == null)
{
// nothing to do
}
else
{
if (sourceType != targetType)
{
disconnect = true;
connect = true;
}
apply = true;
}
if (targetSettings != null)
{
int iTargetCapturing = targetSettings.GetInteger(SensorProperty.Capturing, -1);
if (iTargetCapturing < 0)
{
// ignore if not available
}
else if (iTargetCapturing != 0)
{
start = true;
}
else
{
stop = true;
}
}
// TODO make restrictions or otherwise cover remaining possible cases
bool success = true;
// perform the operations which were activated above
if (disconnect && success)
{
if (system.DisconnectSensor(iSource))
{
LogManager.Instance.LogMessage(this, "Disconnected sensor " + iSource);
sensor = null;
// already removed from result map
}
else
{
// nothing changed
LogManager.Instance.LogError(this, "Failed to disconnect sensor " + iSource);
resultMap[iSource] = sourceSettings;
success = false;
}
}
if (connect && success)
{
sensor = new WebcamCapture(targetSettings);
int iNext = system.ConnectSensor(sensor, iTarget);
if (iNext == iTarget)
{
LogManager.Instance.LogMessage(this, "Connected sensor " + iNext);
targetSettings = ((WebcamCapture)sensor).GetSettings();
resultMap[iTarget] = targetSettings;
}
else if (iNext < 0)
{
// failed, leave result map entry empty
LogManager.Instance.LogError(this, "Failed to connect new sensor");
sensor = null;
success = false;
}
else
{
LogManager.Instance.LogMessage(this, "Connected sensor " + iNext);
// sensor connected with different index, which we can accept
iTarget = iNext;
resultMap[iNext] = targetSettings;
targetSettings = ((WebcamCapture)sensor).GetSettings();
}
}
if (stop && success)
{
if (system.StopSensor(iTarget))
{
LogManager.Instance.LogMessage(this, "Stopped sensor " + iTarget);
}
else
{
targetSettings = ((WebcamCapture)sensor).GetSettings();
success = false;
LogManager.Instance.LogError(this, "Failed to stop sensor " + iTarget);
}
resultMap[iTarget] = targetSettings;
}
if (apply && success)
{
if (sensor != null)
{
if (((WebcamCapture)sensor).ApplySettings(targetSettings))
{
LogManager.Instance.LogMessage(this, "Applied new settings to sensor " + iTarget);
}
else
{
LogManager.Instance.LogError(this, "Failed to apply new settings to sensor " + iTarget);
}
targetSettings = ((WebcamCapture)sensor).GetSettings();
resultMap[iTarget] = targetSettings;
}
}
if (start && success)
{
if (system.StartSensor(iSource))
{
LogManager.Instance.LogMessage(this, "Started sensor " + iSource);
targetSettings = ((WebcamCapture)sensor).GetSettings();
resultMap[iTarget] = targetSettings;
}
else
{
LogManager.Instance.LogError(this, "Failed to start sensor " + iSource);
targetSettings = ((WebcamCapture)sensor).GetSettings();
resultMap[iTarget] = targetSettings;
success = false;
}
}
if (!success)
{
status = HttpStatusCode.InternalServerError;
}
}
readySignal.Set();
});
// lastly create an update for all clients
if (!readySignal.WaitOne(10000))
{
return(HttpStatusCode.InternalServerError);
}
if (status != HttpStatusCode.OK)
{
return(status);
}
//var responseSubject = new JsonString(subject);
{
var updateData = JsonString.CreateArray();
{
for (int i = sensorIndex; i <= sensorIndex; i++)
{
var entry = JsonString.CreateDict();
EquipmentSettings settings;
if (resultMap.TryGetValue(i, out settings))
{
entry.AddTerminal("inuse", "true");
entry.AddJsonString("settings", EquipmentSettings.ToJson(settings));
}
else
{
entry.AddTerminal("inuse", "false");
}
updateData.AddJsonString(string.Empty, entry);
}
}
responseSubject.AddJsonString("data", updateData);
}
return(HttpStatusCode.OK);
}
/// <summary>
/// Reads stream settings from the given node.
/// </summary>
/// <returns><c>true</c>, if operation was successful, <c>false</c> otherwise.</returns>
/// <param name="index">Capture index.</param>
/// <param name="profile">Target profile.</param>
/// <param name="root">Root node.</param>
public bool ReadWebcam(string name, int index, SetupProfile profile, XmlNode root)
{
var settings = new EquipmentSettings(typeof(SensorProperty));
// TODO read name from data
settings.SetText(SensorProperty.Name, name);
settings.SetText(SensorProperty.Type, "Webcam");
// first parse the node
foreach (XmlNode node in root.ChildNodes)
{
if (node.Name.Equals("Camera"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
if (!auto)
{
int camera = JsonString.ParseInt(node.InnerText, -1);
if (camera < 0)
{
return(false);
}
settings.SetInteger(SensorProperty.CameraId, camera);
}
}
else if (node.Name.Equals("Width"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
if (!auto)
{
int width = JsonString.ParseInt(node.InnerText, 640);
if (width < 1)
{
return(false);
}
settings.SetInteger(SensorProperty.FrameWidth, width);
}
}
else if (node.Name.Equals("Height"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
if (!auto)
{
int height = JsonString.ParseInt(node.InnerText, 480);
if (height < 1)
{
return(false);
}
settings.SetInteger(SensorProperty.FrameHeight, height);
}
}
else if (node.Name.Equals("FPS"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
if (!auto)
{
int fps = JsonString.ParseInt(node.InnerText, 30);
if (fps < 0)
{
return(false);
}
settings.SetInteger(SensorProperty.FrameRate, fps);
}
}
else if (node.Name.Equals("Exposure"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
decimal exposure = JsonString.ParseDecimal(node.InnerText, 0.0m);
if (!auto)
{
settings.SetDecimal(SensorProperty.Exposure, exposure);
}
}
else if (node.Name.Equals("Brightness"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
decimal bright = JsonString.ParseDecimal(node.InnerText, 0.0m);
if (!auto)
{
settings.SetDecimal(SensorProperty.Brightness, bright);
}
}
else if (node.Name.Equals("Contrast"))
{
bool auto = true;
if (node.Attributes["Auto"] != null)
{
auto = JsonString.ParseBool(node.Attributes["Auto"].InnerText, true);
}
decimal contrast = JsonString.ParseDecimal(node.InnerText, 0.0m);
if (!auto)
{
settings.SetDecimal(SensorProperty.Contrast, contrast);
}
}
}
// add the settings if successful
profile.AddVideoCapture(index, settings);
return(true);
}
public WebcamCapture(EquipmentSettings settings) : this()
{
this.settings = new EquipmentSettings(settings);
}
