private void WebcamCaptureMenuItem_Click(object sender, EventArgs e)
{
var Form = new WebcamCapture();
Form.Show(this);
Form.Activate();
}
private void SetupCapture()
{
Capture cap;
if (this.captureSource == -1)
{
cap = new VideoFileCapture(@"..\..\Media\test.avi")
{
Looping = true
};
}
else
{
cap = new WebcamCapture(this.captureSource);
}
this.ctt = new CaptureToTexture(cap, "vidtex");
// get video size
this.ctt.Start();
while (!cap.IsRunning)
{
}
this.ctt.Stop();
Size s = new Size(NextPowerOfTwo(cap.Size.Width), NextPowerOfTwo(cap.Size.Height));
using (TexturePtr tex = TextureManager.Singleton.CreateManual(
"vidtex",
ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME,
TextureType.TEX_TYPE_2D,
(uint)s.Width,
(uint)s.Height,
0,
PixelFormat.PF_A8R8G8B8))
{
using (MaterialPtr mat = MaterialManager.Singleton.Create("vidmat", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME))
{
mat.GetTechnique(0).CreatePass().CreateTextureUnitState(tex.Name);
Entity e = this.sceneMgr.CreateEntity("cube", "cube.mesh");
e.SetMaterial(mat);
this.sceneMgr.RootSceneNode.CreateChildSceneNode().AttachObject(e);
}
}
this.ctt.Start();
}
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);
}
public Task <bool> ActivateProfile(SetupProfile profile)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
var captureSignal = new ManualResetEvent(false);
var trackerSignal = new ManualResetEvent(false);
var deviceSignal = new ManualResetEvent(false);
var cancel = new CancellationToken();
CaptureSystem.Instance.Invoke((object sender, EventArgs args) => {
var system = (CaptureSystem)sender;
foreach (int i in profile.VideoCaptureIndexes)
{
var settings = profile.GetVideoCapture(i);
var sensor = new WebcamCapture(settings);
int index = system.ConnectSensor(sensor, i);
if (index != i)
{
LogManager.Instance.LogWarning(this, string.Format("VideoCapture {0} assigned to different index {1}",
i, index));
}
}
captureSignal.Set();
});
TrackingSystem.Instance.Invoke(delegate {
foreach (int i in profile.TrackerIndexes)
{
var settings = profile.GetTracker(i);
var tracker = new P3CapTracker(settings);
int index = TrackingSystem.Instance.StartTracker(tracker);
}
trackerSignal.Set();
});
VirtualDeviceManager.Instance.Invoke(delegate {
foreach (int i in profile.DeviceIndexes)
{
var settings = profile.GetDevice(i);
var device = VirtualDevice.CreateFromSettings(settings);
int index = VirtualDeviceManager.Instance.ConnectDevice(device);
}
deviceSignal.Set();
});
return(Task.Factory.StartNew(delegate {
captureSignal.WaitOne();
trackerSignal.WaitOne();
deviceSignal.WaitOne();
return true;
}, cancel));
// we need to wait for the detection system to update tracker equipment
// DetectionSystem.Instance.Invoke(delegate {
// Invoke(delegate {
// foreach (int iTracker in profile.BindingIndexes) {
// if (!bindingsFactory.ApplyBindings(iTracker, profile.GetBindings(iTracker))) {
// LogManager.Instance.LogError(this, "Failed to restore tracker bindings");
// return;
// }
// }
// });
// });
}
