public IEnumerator <ITask> DeleteGrammarEntryHandler(DeleteGrammarEntry delete)
{
// Make sure current grammar type is dictionary-style
if (_state.GrammarType != GrammarType.DictionaryStyle)
{
Fault fault = Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"Cannot delete entries from grammar dictionary because grammar"
+ "currently in use is not DictionaryStyle."
);
LogInfo(fault.ToException());
delete.ResponsePort.Post(fault);
yield break;
}
#region Set up load grammar request and load grammar
// Set up load grammar request
LoadGrammarRequest loadRequest = new LoadGrammarRequest();
loadRequest.GrammarType = GrammarType.DictionaryStyle;
loadRequest.DictionaryGrammar = new Dictionary <string, string>(_state.DictionaryGrammar);
GrammarUtilities.DeleteDictionary(loadRequest.DictionaryGrammar, delete.Body.DictionaryGrammar);
// Load new grammar
SuccessFailurePort loadGrammarPort = new SuccessFailurePort();
SpawnIterator <LoadGrammarRequest, SuccessFailurePort>(
loadRequest,
loadGrammarPort,
LoadGrammar
);
// Check loading outcome
yield return((Choice)loadGrammarPort);
Exception exception = (Exception)loadGrammarPort;
if (exception != null)
{
LogWarning(exception);
delete.ResponsePort.Post(Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
exception.Message
));
yield break;
}
#endregion
SaveState(_state);
// Notify subscribers of state change
Replace replace = new Replace();
replace.Body = _state;
SendNotification <Replace>(_subMgrPort, replace);
delete.ResponsePort.Post(DefaultDeleteResponseType.Instance);
}
public IEnumerator <ITask> UpsertGrammarEntryHandler(UpsertGrammarEntry upsert)
{
if (_state.GrammarType != GrammarType.DictionaryStyle)
{
// Since we are switching grammar mode make sure there exists a valid,
// empty dictionary
if (_state.DictionaryGrammar == null)
{
_state.DictionaryGrammar = new Dictionary <string, string>();
}
else
{
_state.DictionaryGrammar.Clear();
}
}
#region Set up load grammar request and load grammar
// Set up load grammar request
LoadGrammarRequest loadRequest = new LoadGrammarRequest();
loadRequest.GrammarType = GrammarType.DictionaryStyle;
loadRequest.DictionaryGrammar = new Dictionary <string, string>(_state.DictionaryGrammar);
GrammarUtilities.UpsertDictionary(loadRequest.DictionaryGrammar, upsert.Body.DictionaryGrammar);
// Load new grammar
SuccessFailurePort loadGrammarPort = new SuccessFailurePort();
SpawnIterator <LoadGrammarRequest, SuccessFailurePort>(
loadRequest,
loadGrammarPort,
LoadGrammar
);
// Check loading outcome
yield return((Choice)loadGrammarPort);
Exception exception = (Exception)loadGrammarPort;
if (exception != null)
{
LogWarning(exception);
upsert.ResponsePort.Post(Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
exception.Message
));
yield break;
}
#endregion
SaveState(_state);
// Notify subscribers of state change
Replace replace = new Replace();
replace.Body = _state;
SendNotification <Replace>(_subMgrPort, replace);
upsert.ResponsePort.Post(DefaultUpsertResponseType.Instance);
}
public void UpdateFormatHandler(mdwebcam.UpdateFormat update)
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.ActionNotSupported,
"UpdateFormat is not supported by the webcam replay service"
)
);
}
public void HttpPostHandler(HttpPost httpPost)
{
httpPost.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.ActionNotSupported,
"HTTP Post is not supported by the webcam replay service"
)
);
}
public void ChangeControllerHandler(gc.ChangeController update)
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.ActionNotSupported,
"The Joystick Form Service does not support changing controllers"
)
);
}
/// <summary>
/// Posts a HTTP error message with a supplied error message back to the client
/// </summary>
/// <param name="post"></param>
/// <param name="errorMsg"></param>
private void PostHttpPostParameterError(HttpPost post, string errorMsg)
{
post.ResponsePort.Post(new HttpResponseType(
HttpStatusCode.OK,
Fault.FromCodeSubcodeReason(
FaultCodes.Sender,
DsspFaultCodes.ActionNotSupported,
errorMsg
)
));
}
void UpdateDeviceInternal(UpdateDevice update)
{
CameraInstance selected = update.Body.Selected;
bool updated = false;
if (_state.Selected != null &&
_state.Selected.FrameGrabber != null)
{
_state.Selected.FrameGrabber.StopCapture();
_state.Selected.FrameGrabber.Dispose();
_state.Selected = null;
}
foreach (object obj in new vision.CameraCollection())
{
using (vision.Camera camera = obj as vision.Camera)
{
if ((!string.IsNullOrEmpty(selected.FriendlyName) && camera.Name == selected.FriendlyName) ||
(!string.IsNullOrEmpty(selected.DevicePath) && camera.Path == selected.DevicePath))
{
selected.FriendlyName = camera.Name;
selected.DevicePath = selected.DevicePath;
selected.FrameGrabber = vision.FrameGrabber.FromCamera(camera);
selected.SupportedFormats = ConvertFormats(selected.FrameGrabber.Formats);
selected.FrameGrabber.CaptureFrame += OnCaptureFrame;
selected.FrameGrabber.StartCapture();
selected.Format = new Format(selected.FrameGrabber.Format);
updated = true;
break;
}
}
}
if (updated)
{
_state.Selected = selected;
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
SendNotification(_submgrPort, update);
}
else
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"Camera not found"
)
);
}
}
public IEnumerator <ITask> OnUpdateButton(UpdateButton update)
{
int index = _state.Buttons.FindIndex(update.Body.CompareId);
if (index < 0)
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"A button with the requested ID does not exist: " + update.Body.Id
)
);
}
else
{
bool isInternal = update.GetHeader <InternalUpdate>() != null;
if (!isInternal)
{
Fault fault = null;
FormInvoke invoke = new FormInvoke(
delegate
{
_form.UpdateButton(update.Body);
}
);
WinFormsServicePort.Post(invoke);
yield return(Arbiter.Choice(
invoke.ResultPort,
EmptyHandler,
delegate(Exception e)
{
fault = Fault.FromException(e);
}
));
if (fault != null)
{
update.ResponsePort.Post(fault);
yield break;
}
}
_state.Buttons[index] = update.Body;
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
DoSendNotification(update);
}
}
public void OnUpdateColorDefinition(UpdateColorDefinition update)
{
ColorDefinition def = update.Body;
if (!def.Validate())
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"ColorDefinition is not valid."
)
);
return;
}
ColorSet set = _state.Colors.Find(def.Compare);
if (set == null)
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"ColorSet List does not contain an entry for: " + def.Name
)
);
return;
}
int index = set.Colors.FindIndex(def.CompareColor);
if (index >= 0)
{
set.Colors[index] = def;
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
_state.UpdateColorSetMap();
SendNotification(_submgrPort, update, Filter.ColorDefinitions.ToString());
}
else
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"ColorSet Definition List does not contain an entry for: " + def.Name
)
);
}
}
void HttpGetHandler(HttpGet httpGet)
{
HttpListenerRequest request = httpGet.Body.Context.Request;
HttpListenerResponse response = httpGet.Body.Context.Response;
Stream image = null;
string path = request.Url.AbsolutePath;
if (path == _cylinder)
{
image = GenerateCylinder();
}
else if (path == _top)
{
image = GenerateTop(400);
}
else if (path.StartsWith(_topw))
{
int width;
string remain = path.Substring(_topw.Length);
if (int.TryParse(remain, out width))
{
image = GenerateTop(width);
}
}
else if (path == _root)
{
HttpResponseType rsp = new HttpResponseType(HttpStatusCode.OK,
_state,
//base.StateTransformPath,
_transform);
httpGet.ResponsePort.Post(rsp);
}
if (image != null)
{
SendJpeg(httpGet.Body.Context, image);
}
else
{
httpGet.ResponsePort.Post(Fault.FromCodeSubcodeReason(
W3C.Soap.FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"Unable to generate Image"));
}
}
public void OnAddColorDefinition(AddColorDefinition add)
{
ColorDefinition insert = add.Body;
if (insert.Validate() == false)
{
add.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"ColorDefinition is invalid"
)
);
return;
}
ColorSet set = _state.Colors.Find(insert.Compare);
if (set != null)
{
if (set.Colors.Exists(insert.CompareColor))
{
add.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.DuplicateEntry,
"ColorSet Definition List already contains an entry for: " + insert.Name
)
);
return;
}
set.Colors.Add(insert);
_state.UpdateColorSetMap();
add.ResponsePort.Post(DefaultInsertResponseType.Instance);
}
else
{
set = new ColorSet();
set.Name = insert.Name;
set.Colors.Add(insert);
_state.Colors.Add(set);
_state.UpdateColorSetMap();
add.ResponsePort.Post(DefaultInsertResponseType.Instance);
}
SendNotification(_submgrPort, add, Filter.ColorDefinitions.ToString());
}
public IEnumerator <ITask> ReplaceHandler(Replace replace)
{
// Use try/catch to respond with meaningful error in case of an exception
try
{
SetRate(replace.Body.Rate);
SetVolume(replace.Body.Volume);
SetVoice(replace.Body.Voice);
}
catch (ArgumentException e)
{
replace.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
W3C.Soap.FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
e.Message
)
);
yield break;
}
DisableAudioOutput(replace.Body.DisableAudioOutput);
SayText say = new SayText();
say.Body.SpeechText = replace.Body.SpeechText;
SpawnIterator(say, SayTextHandler);
yield return((Choice)say.ResponsePort);
Fault fault = (Fault)say.ResponsePort;
if (fault != null)
{
replace.ResponsePort.Post(fault);
yield break;
}
SaveState(_state);
// Notify subscribers of state change
Replace subscriberReplace = new Replace();
subscriberReplace.Body = _state;
SendNotification <Replace>(_subMgrPort, subscriberReplace);
replace.ResponsePort.Post(DefaultReplaceResponseType.Instance);
}
public IEnumerator <ITask> OnDeleteButton(DeleteButton delete)
{
FlexButton existing = _state.Buttons.Find(delete.Body.CompareId);
if (existing == null)
{
delete.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"A button with the requested ID does not exist: " + delete.Body.Id
)
);
}
else
{
Fault fault = null;
FormInvoke invoke = new FormInvoke(
delegate
{
_form.DeleteButton(delete.Body);
}
);
WinFormsServicePort.Post(invoke);
yield return(Arbiter.Choice(
invoke.ResultPort,
EmptyHandler,
delegate(Exception e)
{
fault = Fault.FromException(e);
}
));
if (fault != null)
{
delete.ResponsePort.Post(fault);
}
else
{
_state.Buttons.Remove(existing);
delete.ResponsePort.Post(DefaultDeleteResponseType.Instance);
DoSendNotification(delete);
}
}
}
/// <summary>
/// SeakCompleted handler, called by speech synthesizer
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void SpeakCompletedHandler(object sender, SpeakCompletedEventArgs args)
{
Fault fault = null;
if (args.Error != null)
{
string errorStr = "Asynchronous speech synthesis failed: "
+ args.Error.ToString();
LogWarning(LogGroups.Console, errorStr);
fault = Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
errorStr
);
}
SayTextSynch sayText;
lock (_sayTextSynchDictionary)
{
if (_sayTextSynchDictionary.TryGetValue(args.Prompt, out sayText))
{
_sayTextSynchDictionary.Remove(args.Prompt);
if (fault != null)
{
sayText.ResponsePort.Post(fault);
}
else
{
sayText.ResponsePort.Post(DefaultUpdateResponseType.Instance);
}
}
else
{
if (fault != null)
{
FaultNotify notifyMsg = new FaultNotify();
notifyMsg.Body = fault;
SendNotification <FaultNotify>(_subMgrPort, notifyMsg);
}
}
}
}
public IEnumerator <ITask> OnInsertButton(InsertButton insert)
{
if (_state.Buttons.Exists(insert.Body.CompareId) ||
_state.Controls.Exists(insert.Body.CompareId))
{
insert.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.DuplicateEntry,
"A button with the same ID already exists: " + insert.Body.Id
)
);
}
else
{
Fault fault = null;
FormInvoke invoke = new FormInvoke(
delegate
{
_form.InsertButton(insert.Body);
}
);
WinFormsServicePort.Post(invoke);
yield return(Arbiter.Choice(
invoke.ResultPort,
EmptyHandler,
delegate(Exception e)
{
fault = Fault.FromException(e);
}
));
if (fault != null)
{
insert.ResponsePort.Post(fault);
}
else
{
_state.Buttons.Add(insert.Body);
insert.ResponsePort.Post(DefaultUpdateResponseType.Instance);
DoSendNotification(insert);
}
}
}
public IEnumerator <ITask> EmulateRecognizeHandler(EmulateRecognize speech)
{
if (string.IsNullOrEmpty(speech.Body.Text))
{
Fault fault = Fault.FromCodeSubcodeReason(
FaultCodes.Sender,
DsspFaultCodes.OperationFailed,
"Text of speech to be emulated cannot be empty"
);
LogInfo(fault.ToException());
speech.ResponsePort.Post(fault);
yield break;
}
this.state.Recognizer.EmulateRecognizeAsync(speech.Body.Text);
speech.ResponsePort.Post(DefaultUpdateResponseType.Instance);
yield break;
}
public void OnSetFrameRate(SetFrameRate update)
{
var rate = update.Body.FrameRate;
if (rate > KinectState.MaxFrameRate)
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Sender,
DsspFaultCodes.OperationFailed,
Resources.FrameRateOutOfRange));
}
else
{
this.state.FrameRate = rate;
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
SendNotification(this.submgrPort, update);
}
}
public void OnRemoveColorDefinition(RemoveColorDefinition remove)
{
ColorDefinition delete = remove.Body;
ColorSet set = _state.Colors.Find(delete.Compare);
if (set != null)
{
ColorDefinition existing = set.Colors.Find(delete.CompareColor);
if (existing != null)
{
set.Colors.Remove(existing);
if (set.Colors.Count == 0)
{
_state.Colors.Remove(set);
}
_state.UpdateColorSetMap();
remove.ResponsePort.Post(DefaultDeleteResponseType.Instance);
SendNotification(_submgrPort, remove, Filter.ColorDefinitions.ToString());
}
else
{
remove.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"Color Definition List does not contain an entry for: " + delete.Name
)
);
}
}
else
{
remove.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"Color Set List does not contain an entry for: " + delete.Name
)
);
}
}
public IEnumerator <ITask> InitControllerHandler(InitController init)
{
try
{
if (Srv1Controller == null)
{
InitControllerInternal();
}
init.ResponsePort.Post(new DefaultSubmitResponseType());
}
catch
{
init.ResponsePort.Post(
Fault.FromCodeSubcodeReason(FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"Invalid COM port")
);
}
yield break;
}
void SensorUpdateHandler(SensorUpdate sensorUpdate)
{
int sensorID = sensorUpdate.sensorID;
if ((sensorID > 0) && (sensorID <= 4))
{
//LogInfo("--- Sensor State Updated " + sensorUpdate.value.ToString());
_state.Sensors[sensorID - 1].value = sensorUpdate.value;
_subMgrPort.Post(new submgr.Submit(_state, DsspActions.ReplaceRequest));
sensorUpdate.ResponsePort.Post(new DefaultUpdateResponseType());
}
else
{
sensorUpdate.ResponsePort.Post(
Fault.FromCodeSubcodeReason(FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"Bad Index")
);
}
}
public IEnumerator <ITask> SetSrgsGrammarFileHandler(SetSrgsGrammarFile setSrgsGrammarFile)
{
#region Set up load grammar request and load grammar
// Set up load grammar request
LoadGrammarRequest loadRequest = new LoadGrammarRequest();
loadRequest.GrammarType = GrammarType.Srgs;
loadRequest.SrgsFileLocation = setSrgsGrammarFile.Body.FileLocation;
// Load new grammar
SuccessFailurePort loadGrammarPort = new SuccessFailurePort();
SpawnIterator <LoadGrammarRequest, SuccessFailurePort>(
loadRequest,
loadGrammarPort,
LoadGrammar
);
// Check loading outcome
yield return((Choice)loadGrammarPort);
Exception exception = (Exception)loadGrammarPort;
if (exception != null)
{
LogWarning(exception);
setSrgsGrammarFile.ResponsePort.Post(Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
exception.Message
));
yield break;
}
#endregion
SaveState(this.state);
// Notify subscribers of state change
Replace replace = new Replace();
replace.Body = this.state;
SendNotification <Replace>(this.subMgrPort, replace);
setSrgsGrammarFile.ResponsePort.Post(DefaultUpdateResponseType.Instance);
}
public IEnumerator <ITask> OnFindColorDefinition(FindColorDefinition find)
{
ColorDefinition query = find.Body;
ColorSet existing = _state.Colors.Find(query.Compare);
if (existing != null)
{
find.ResponsePort.Post(existing);
}
else
{
find.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.UnknownEntry,
"Color Definition List does not contain an entry for: " + query.Name
)
);
}
yield break;
}
public IEnumerator <ITask> HttpQueryHandler(HttpQuery query)
{
HttpQueryRequestType request = query.Body;
NameValueCollection parameters = request.Query;
string cmd = parameters["cmd"];
if (cmd != null)
{
cmd = cmd.ToLowerInvariant();
switch (cmd)
{
case "events":
yield return(new IterativeTask(delegate
{
return EventsHttpQueryHandler(query, parameters);
}));
yield break;
case "speechrecognizerstate":
yield return(new IterativeTask(delegate
{
return SpeechRecognizerStateHttpQueryHandler(query);
}));
yield break;
}
}
// Unknown query
query.ResponsePort.Post(new HttpResponseType(
HttpStatusCode.BadRequest,
Fault.FromCodeSubcodeReason(
FaultCodes.Sender,
DsspFaultCodes.ActionNotSupported,
"Unknown query"
)
));
yield break;
}
public void UpdateTiltHandler(UpdateTilt update)
{
var tilt = update.Body.Tilt;
// need constants
if (tilt > (short)kinectSensor.MaxElevationAngle ||
tilt < (short)kinectSensor.MinElevationAngle)
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Sender,
DsspFaultCodes.OperationFailed,
Resources.InvalidTiltAngle));
}
else
{
this.SetKinectTiltAngle((int)tilt);
this.UpdateTiltAngle(this.state.TiltDegrees);
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
SendNotification(this.submgrPort, update);
}
}
/// <summary>
/// Internal handler, not on public port
/// </summary>
/// <param name="sensorConfiguration"></param>
void SensorConfigurationHandler(SensorConfiguration sensorConfiguration)
{
int sensorID = sensorConfiguration.sensorID;
string name = sensorConfiguration.name;
Srv1SensorType type = (Srv1SensorType)sensorConfiguration.type;
if ((sensorID > 0) && (sensorID <= 4))
{
_state.Sensors[sensorID - 1].type = type;
_state.Sensors[sensorID - 1].name = name;
sensorConfiguration.ResponsePort.Post(new DefaultUpdateResponseType());
_subMgrPort.Post(new submgr.Submit(_state, DsspActions.ReplaceRequest));
}
else
{
sensorConfiguration.ResponsePort.Post(
Fault.FromCodeSubcodeReason(FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"Bad Index")
);
}
}
public IEnumerator <ITask> ReplaceHandler(bumper.Replace replace)
{
if (_subscribed)
{
throw new InvalidOperationException("Already subscribed");
}
else if (ValidState(replace.Body))
{
_bumperConfigState.ContactSensorArrayState = replace.Body;
SaveState(_bumperConfigState);
Port <bool> subscribeDonePort = new Port <bool>();
SpawnIterator <Port <bool> >(subscribeDonePort, SubscribeToNXT);
yield return(Arbiter.Receive <bool>(false, subscribeDonePort,
delegate(bool success)
{
if (success)
{
replace.ResponsePort.Post(DefaultReplaceResponseType.Instance);
}
else
{
replace.ResponsePort.Post(
Fault.FromCodeSubcodeReason(FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"LegoNxtBumper service subscription to LEGO NXT Brick failed")
);
}
}));
}
else
{
throw new InvalidOperationException("Invalid State");
}
yield break;
}
public IEnumerator <ITask> LogHandler(Log log)
{
#if URT_MINCLR
if (log.Body.Base == 0 ||
log.Body.Base == math.E)
{
log.ResponsePort.Post(new Response(math.Log(log.Body.A)));
}
else if (log.Body.Base == 10)
{
log.ResponsePort.Post(new Response(math.Log10(log.Body.A)));
}
else
{
log.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.ActionNotSupported,
"Only natural logarithms and logarithms in base 10 are supported."
)
);
}
#else
double logbase;
if (log.Body.Base == 0)
{
logbase = math.E;
}
else
{
logbase = log.Body.Base;
}
log.ResponsePort.Post(new Response(math.Log(log.Body.A, logbase)));
#endif
yield break;
}
void UpdateFormatInternal(UpdateFormat update)
{
Format format = update.Body;
if (_state.Selected != null &&
_state.Selected.FrameGrabber != null)
{
vision.FrameGrabber grabber = _state.Selected.FrameGrabber;
grabber.StopCapture();
grabber.Format = (vision.Format)format;
grabber.StartCapture();
_state.Selected.Format = new Format(grabber.Format);
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
}
else
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"No camera is currently selected")
);
}
}
public IEnumerator <ITask> UpdateFormatHandler(UpdateFormat update)
{
Format format = update.Body;
if (_state.Selected != null &&
_state.Selected.Started)
{
yield return((Choice)StopCapture());
yield return((Choice)SetFormat(format));
yield return((Choice)StartCapture());
_state.Selected.Format = format;
if (format.MaxFramesPerSecond > 0)
{
_state.Selected.Format.MaxFramesPerSecond = format.MaxFramesPerSecond;
}
if (format.MinFramesPerSecond > 0)
{
_state.Selected.Format.MinFramesPerSecond = format.MinFramesPerSecond;
}
_state.ImageSize = new physics.Vector2(format.Width, format.Height);
update.ResponsePort.Post(DefaultUpdateResponseType.Instance);
}
else
{
update.ResponsePort.Post(
Fault.FromCodeSubcodeReason(
W3C.Soap.FaultCodes.Receiver,
DsspFaultCodes.OperationFailed,
"No camera is currently selected"
)
);
}
}
public IEnumerator <ITask> OnRotateSingle(pantilt.Rotate rotate)
{
// Just convert this to a kinect tilt operation
if (rotate.Body.RotatePanRequest != null &&
rotate.Body.RotatePanRequest.TargetRotationAngleInRadians != 0)
{
rotate.ResponsePort.Post(Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.ActionNotSupported,
Resources.PanNotSupported));
yield break;
}
if (rotate.Body.RotateTiltRequest == null)
{
// no-op
rotate.ResponsePort.Post(DefaultUpdateResponseType.Instance);
yield break;
}
if (rotate.Body.RotateTiltRequest.IsMotionCompletionRequiredForResponse != false)
{
rotate.ResponsePort.Post(Fault.FromCodeSubcodeReason(
FaultCodes.Receiver,
DsspFaultCodes.ActionNotSupported,
Resources.ResponseOnMotionCompletedNotSupported));
yield break;
}
if (rotate.Body.RotateTiltRequest.TargetAccelerationInRadiansPerSecondSecond != 0)
{
LogWarning(Resources.AccelerationIgnored);
}
if (rotate.Body.RotateTiltRequest.MaxSpeedInRadiansPerSecond != 0)
{
LogWarning(Resources.SpeedIgnored);
}
double targetTiltInDegrees;
if (rotate.Body.RotateTiltRequest.IsRelative)
{
targetTiltInDegrees =
this.state.TiltDegrees + (rotate.Body.RotateTiltRequest.TargetRotationAngleInRadians * DegreesPerRadian);
}
else
{
targetTiltInDegrees = rotate.Body.RotateTiltRequest.TargetRotationAngleInRadians * DegreesPerRadian;
}
this.panTiltState.TiltState.JointCommand.TargetAngleInRadians = targetTiltInDegrees / DegreesPerRadian;
var updateTilt = new UpdateTilt
{
Body = { Tilt = targetTiltInDegrees },
ResponsePort = rotate.ResponsePort
};
this.mainPort.Post(updateTilt);
yield break;
}
