/// <summary>
/// Initializes a new instance of the StreamData class and sets all properties based on the KStudioEventStream provided
/// </summary>
/// <param name="stream">KStudioEventStream to get data from</param>
public StreamData(KStudioEventStream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
this.EventStream = stream;
this.PublicMetadata = stream.GetMetadata(KStudioMetadataType.Public);
this.PersonalMetadata = stream.GetMetadata(KStudioMetadataType.PersonallyIdentifiableInformation);
this.EventHeaders = new ObservableCollection <KStudioEventHeader>();
KStudioSeekableEventStream seekStream = stream as KStudioSeekableEventStream;
if (seekStream != null)
{
this.StartTime = seekStream.StartRelativeTime;
this.EndTime = seekStream.EndRelativeTime;
List <KStudioEventHeader> headers = seekStream.EventHeaders.ToList();
foreach (KStudioEventHeader header in headers)
{
this.EventHeaders.Add(header);
}
}
}
private void NullableComboBox_KeyDown(object sender, KeyEventArgs e)
{
if (e != null)
{
if (e.Key == Key.Delete)
{
ComboBox comboBox = sender as ComboBox;
if (comboBox != null)
{
KStudioEventStream eventStream = comboBox.SelectedItem as KStudioEventStream;
if (eventStream != null)
{
EventStreamState ess = eventStream.UserState as EventStreamState;
if (ess != null)
{
if (ess.SelectedFilePlaybackStream != null)
{
EventStreamState ess2 = ess.SelectedFilePlaybackStream.UserState as EventStreamState;
if (ess2 != null)
{
e.Handled = true;
ess2.SelectedLivePlaybackStream = null;
}
}
}
}
}
}
}
}
/// <summary>
/// Verifies that the streams selected for playback exist in the file and are capable of being played on the service
/// </summary>
/// <param name="client">KStudioClient which is connected to the Kinect service</param>
/// <param name="filePath">Path to file that will be played back</param>
/// <param name="playbackStreams">Collection of streams which have been selected for playback</param>
private static void VerifyStreamsForPlayback(KStudioClient client, string filePath, IEnumerable <Guid> playbackStreams)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (!client.IsServiceConnected)
{
throw new InvalidOperationException(Strings.ErrorNotConnected);
}
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
if (playbackStreams == null)
{
throw new ArgumentNullException("playbackStreams");
}
// verify stream exists in the file
using (KStudioEventFile file = client.OpenEventFile(filePath))
{
HashSet <Guid> fileStreams = new HashSet <Guid>();
foreach (KStudioEventStream stream in file.EventStreams)
{
fileStreams.Add(stream.DataTypeId);
}
if (!fileStreams.IsSupersetOf(playbackStreams))
{
Guid invalidStream = playbackStreams.First(x => !fileStreams.Contains(x));
throw new InvalidOperationException(string.Format(Strings.ErrorPlaybackStreamNotInFile, StreamSupport.ConvertStreamGuidToString(invalidStream)));
}
}
// verify stream is supported for playback by the Kinect sensor
foreach (Guid stream in playbackStreams)
{
KStudioEventStream eventStream = client.GetEventStream(stream, KStudioEventStreamSemanticIds.KinectDefaultSensorConsumer);
if (!eventStream.IsPlaybackable)
{
throw new InvalidOperationException(string.Format(Strings.ErrorPlaybackStreamNotSupported, StreamSupport.ConvertStreamGuidToString(stream)));
}
}
}
public EventStreamState(KStudioEventStream stream, IKStudioService kstudioService, bool obscureStream)
{
DebugHelper.AssertUIThread();
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (kstudioService == null)
{
throw new ArgumentNullException("kstudioService");
}
this.stream = stream;
this.kstudioService = kstudioService;
this.obscureStream = obscureStream;
this.ShortName = stream.Name;
if (String.IsNullOrWhiteSpace(this.ShortName))
{
this.ShortName = stream.DataTypeName;
}
if (String.IsNullOrWhiteSpace(this.ShortName))
{
this.ShortName = stream.DataTypeId.ToString() + ":" + stream.SemanticId;
}
this.ShortNameUppercase = this.ShortName.ToUpperInvariant();
StringBuilder sb = new StringBuilder();
if (!String.IsNullOrWhiteSpace(stream.DataTypeName))
{
sb.Append(stream.DataTypeName);
sb.AppendLine();
}
if (!String.IsNullOrWhiteSpace(stream.Name))
{
sb.Append(stream.Name);
sb.AppendLine();
}
sb.Append(stream.DataTypeId);
sb.Append(":");
sb.Append(stream.SemanticId);
this.LongName = sb.ToString();
}
public EventStreamState(KStudioEventStream stream, IKStudioService kstudioService, bool obscureStream)
{
DebugHelper.AssertUIThread();
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (kstudioService == null)
{
throw new ArgumentNullException("kstudioService");
}
this.stream = stream;
this.kstudioService = kstudioService;
this.obscureStream = obscureStream;
this.ShortName = stream.Name;
if (String.IsNullOrWhiteSpace(this.ShortName))
{
this.ShortName = stream.DataTypeName;
}
if (String.IsNullOrWhiteSpace(this.ShortName))
{
this.ShortName = stream.DataTypeId.ToString() + ":" + stream.SemanticId;
}
this.ShortNameUppercase = this.ShortName.ToUpperInvariant();
StringBuilder sb = new StringBuilder();
if (!String.IsNullOrWhiteSpace(stream.DataTypeName))
{
sb.Append(stream.DataTypeName);
sb.AppendLine();
}
if (!String.IsNullOrWhiteSpace(stream.Name))
{
sb.Append(stream.Name);
sb.AppendLine();
}
sb.Append(stream.DataTypeId);
sb.Append(":");
sb.Append(stream.SemanticId);
this.LongName = sb.ToString();
}
/// <summary>
/// Updates (add/edits) stream-level metadata in an event file
/// </summary>
/// <param name="client">KStudioClient to use for accessing the event file</param>
/// <param name="fileName">Path to event file</param>
/// <param name="streamName">Name of stream which should contain the metadata</param>
/// <param name="type">Type of metadata to update (Public or Personal)</param>
/// <param name="key">Key of metadata object to add/edit</param>
/// <param name="value">Value of metadata object to add/edit</param>
/// <returns>String which contains the updated contents of the target metadata object</returns>
public static string UpdateStreamMetadata(KStudioClient client, string fileName, string streamName, KStudioMetadataType type, string key, object value)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
if (string.IsNullOrEmpty(streamName))
{
throw new ArgumentNullException("streamName");
}
string metadataText = string.Empty;
using (KStudioEventFile file = client.OpenEventFileForEdit(fileName))
{
// find the stream in the file and alter its metadata
Guid dataTypeId = StreamSupport.ConvertStreamStringToGuid(streamName);
if (dataTypeId == KStudioEventStreamDataTypeIds.Null)
{
throw new InvalidOperationException(Strings.ErrorNullStream);
}
KStudioEventStream stream = file.EventStreams.FirstOrDefault(s => s.DataTypeId == dataTypeId);
if (stream != null)
{
KStudioMetadata metadata = stream.GetMetadata(type);
Metadata.AlterMetadata(metadata, key, value);
metadataText = Metadata.GetMetadataAsText(metadata, type, stream.DataTypeName);
}
}
return(metadataText);
}
public void SetupForPlayback(ReadOnlyObservableCollection <KStudioEventStream> clientEventStreams)
{
DebugHelper.AssertUIThread();
if ((this.livePlaybackStreams == null) && (clientEventStreams != null))
{
ListCollectionView targetPlaybackableStreams = new ListCollectionView(clientEventStreams);
targetPlaybackableStreams.Filter = (object item) =>
{
KStudioEventStream s = item as KStudioEventStream;
Debug.Assert(s != null);
return(s.IsPlaybackable && s.IsFromService && (s.DataTypeId == this.stream.DataTypeId));
};
targetPlaybackableStreams.SortDescriptions.Clear();
targetPlaybackableStreams.SortDescriptions.Add(new SortDescription("UserState.ShortNameUppercase", ListSortDirection.Ascending));
targetPlaybackableStreams.Refresh();
this.livePlaybackStreams = targetPlaybackableStreams;
this.RaisePropertyChanged("LivePlaybackStreams");
}
}
public WritableMetadataProxy(KStudioEventFile file, KStudioEventStream stream, KStudioMetadata metadata)
{
DebugHelper.AssertUIThread();
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
this.file = file as KStudioWritableEventFile;
this.stream = stream;
this.metadata = metadata;
this.metadata.CollectionChanged += Notify_CollectionChanged;
lock (this.metadata)
{
LoadCollection();
}
}
public bool DoTargetPlaybackDance(KStudioEventStream stream, bool newValue)
{
DebugHelper.AssertUIThread();
bool okay = false;
if (stream == null)
{
Debug.Assert(newValue == false);
this.selectedTargetStreamsPlaybackable = false;
RaisePropertyChanged("CanPlayback");
}
else
{
okay = true;
// if unselecting the stream, first unselect all hidden streams that require the changing stream
if (!newValue)
{
Dictionary<KStudioEventStream, bool?> playbackableStreams = new Dictionary<KStudioEventStream, bool?>();
foreach (KStudioEventStream playbackableStream in this.targetPlaybackableStreams)
{
EventStreamState state = (EventStreamState)(playbackableStream.UserState);
if (state.SelectedFilePlaybackStream != null)
{
playbackableStreams.Add(playbackableStream, playbackableStream == stream ? false : state.IsSelectedForTargetPlayback);
}
}
foreach (KStudioEventStream playbackableStream in this.targetPlaybackableStreams)
{
if (playbackableStream != stream)
{
EventStreamState state = (EventStreamState)(playbackableStream.UserState);
if (state.IsSelectedForTargetPlayback && (state.SelectedFilePlaybackStream != null))
{
EventStreamState stateFile = (EventStreamState)(state.SelectedFilePlaybackStream.UserState);
if (!stateFile.IsVisibleForPlayback)
{
if (!playbackableStream.HasSelectionRequirements(KStudioEventStreamSelectorRequirementFlags.ProcessPlayback, playbackableStreams))
{
state.IsSelectedForTargetPlaybackNoCheck = false;
}
}
}
}
}
}
{
Dictionary<KStudioEventStream, bool?> playbackableStreams = new Dictionary<KStudioEventStream, bool?>();
foreach (KStudioEventStream playbackableStream in this.targetPlaybackableStreams)
{
EventStreamState state = (EventStreamState)(playbackableStream.UserState);
if (state.SelectedFilePlaybackStream != null)
{
playbackableStreams.Add(playbackableStream, state.IsSelectedForTargetPlayback);
}
}
bool canPlayback = false;
okay = stream.DetermineSelectionRequirements(KStudioEventStreamSelectorRequirementFlags.ProcessPlayback, playbackableStreams, newValue, out canPlayback);
if (okay)
{
foreach (KeyValuePair<KStudioEventStream, bool?> kv in playbackableStreams)
{
if (kv.Key != stream)
{
if (kv.Value.HasValue)
{
((EventStreamState)kv.Key.UserState).IsEnabledForTargetPlayback = true;
((EventStreamState)kv.Key.UserState).IsSelectedForTargetPlaybackNoCheck = kv.Value.Value;
}
else
{
((EventStreamState)kv.Key.UserState).IsEnabledForTargetPlayback = false;
}
}
}
}
this.selectedTargetStreamsPlaybackable = canPlayback;
RaisePropertyChanged("CanPlayback");
}
}
return okay;
}
public KinectIr(KStudioEventStream stream) : base(stream)
{
}
protected KinectStream(KStudioEventStream stream)
{
_stream = stream;
}
private static string BuildRequirementsToolTip(KStudioEventStream stream, IEnumerable streams, KStudioEventStreamSelectorRequirementFlags process)
{
string value = null;
process = process &= KStudioEventStreamSelectorRequirementFlags.ProcessMask;
if ((stream != null) && (stream.EventStreamSelectorRequirements != null))
{
EventStreamState state = (EventStreamState)stream.UserState;
StringBuilder sb = new StringBuilder();
KStudioEventStreamIdentifier emptyIdentifier = new KStudioEventStreamIdentifier();
foreach (KStudioEventStreamSelectorRequirement requirement in stream.EventStreamSelectorRequirements)
{
if ((requirement.Flags & KStudioEventStreamSelectorRequirementFlags.ProcessMask) == process)
{
switch (requirement.Flags & KStudioEventStreamSelectorRequirementFlags.OperationMask)
{
case KStudioEventStreamSelectorRequirementFlags.OperationAll:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, emptyIdentifier, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_All_Format, temp);
}
}
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier1, emptyIdentifier, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_All_Format, temp);
}
}
break;
case KStudioEventStreamSelectorRequirementFlags.OperationNone:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, (KStudioEventStreamIdentifier)requirement.Identifier1, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_None_Format, temp);
}
}
break;
case KStudioEventStreamSelectorRequirementFlags.OperationOr:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, (KStudioEventStreamIdentifier)requirement.Identifier1, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_Or_Format, temp);
}
}
break;
case KStudioEventStreamSelectorRequirementFlags.OperationXor:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, (KStudioEventStreamIdentifier)requirement.Identifier1, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_Xor_Format, temp);
}
}
break;
}
}
}
value = sb.ToString();
}
return value;
}
private static string BuildRequirementsToolTip(KStudioEventStream stream, IEnumerable streams, KStudioEventStreamSelectorRequirementFlags process)
{
string value = null;
process = process &= KStudioEventStreamSelectorRequirementFlags.ProcessMask;
if ((stream != null) && (stream.EventStreamSelectorRequirements != null))
{
EventStreamState state = (EventStreamState)stream.UserState;
StringBuilder sb = new StringBuilder();
KStudioEventStreamIdentifier emptyIdentifier = new KStudioEventStreamIdentifier();
foreach (KStudioEventStreamSelectorRequirement requirement in stream.EventStreamSelectorRequirements)
{
if ((requirement.Flags & KStudioEventStreamSelectorRequirementFlags.ProcessMask) == process)
{
switch (requirement.Flags & KStudioEventStreamSelectorRequirementFlags.OperationMask)
{
case KStudioEventStreamSelectorRequirementFlags.OperationAll:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, emptyIdentifier, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_All_Format, temp);
}
}
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier1, emptyIdentifier, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_All_Format, temp);
}
}
break;
case KStudioEventStreamSelectorRequirementFlags.OperationNone:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, (KStudioEventStreamIdentifier)requirement.Identifier1, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_None_Format, temp);
}
}
break;
case KStudioEventStreamSelectorRequirementFlags.OperationOr:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, (KStudioEventStreamIdentifier)requirement.Identifier1, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_Or_Format, temp);
}
}
break;
case KStudioEventStreamSelectorRequirementFlags.OperationXor:
{
string temp = EventStreamState.GetStreamNames((KStudioEventStreamIdentifier)requirement.Identifier0, (KStudioEventStreamIdentifier)requirement.Identifier1, streams);
if (!String.IsNullOrWhiteSpace(temp))
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.AppendFormat(Strings.StreamRequirement_Xor_Format, temp);
}
}
break;
}
}
}
value = sb.ToString();
}
return(value);
}
public bool DoTargetMonitorDance(KStudioEventStream stream, bool newValue)
{
DebugHelper.AssertUIThread();
bool okay = false;
if (stream == null)
{
Debug.Assert(newValue == false);
this.selectedTargetStreamsMonitorable = false;
RaisePropertyChanged("CanMonitor");
}
else
{
okay = true;
// if unselecting the stream, first unselect all hidden streams that require the changing stream
if (!newValue)
{
Dictionary<KStudioEventStream, bool?> monitorableStreams = new Dictionary<KStudioEventStream, bool?>();
foreach (KStudioEventStream monitorableStream in this.targetMonitorableStreams)
{
EventStreamState state = (EventStreamState)monitorableStream.UserState;
monitorableStreams.Add(monitorableStream, monitorableStream == stream ? false : state.IsSelectedForTargetMonitor);
}
foreach (KStudioEventStream monitorableStream in this.targetMonitorableStreams)
{
if (monitorableStream != stream)
{
EventStreamState state = (EventStreamState)(monitorableStream.UserState);
if (state.IsSelectedForTargetMonitor && !state.IsVisibleForTargetMonitor)
{
if (!monitorableStream.HasSelectionRequirements(KStudioEventStreamSelectorRequirementFlags.ProcessMonitor, monitorableStreams))
{
state.IsSelectedForTargetMonitorNoCheck = false;
}
}
}
}
}
bool canMonitor = false;
{
Dictionary<KStudioEventStream, bool?> monitorableStreams = new Dictionary<KStudioEventStream, bool?>();
foreach (KStudioEventStream monitorableStream in this.targetMonitorableStreams)
{
EventStreamState state = (EventStreamState)(monitorableStream.UserState);
monitorableStreams.Add(monitorableStream, state.IsSelectedForTargetMonitor);
}
okay = stream.DetermineSelectionRequirements(KStudioEventStreamSelectorRequirementFlags.ProcessMonitor, monitorableStreams, newValue, out canMonitor);
if (okay)
{
foreach (KeyValuePair<KStudioEventStream, bool?> kv in monitorableStreams)
{
if (kv.Key != stream)
{
if (kv.Value.HasValue)
{
((EventStreamState)kv.Key.UserState).IsEnabledForTargetMonitor = true;
((EventStreamState)kv.Key.UserState).IsSelectedForTargetMonitorNoCheck = kv.Value.Value;
}
else
{
((EventStreamState)kv.Key.UserState).IsEnabledForTargetMonitor = false;
}
}
}
}
}
this.selectedTargetStreamsMonitorable = canMonitor;
RaisePropertyChanged("CanMonitor");
}
return okay;
}
public void UpdateTargetMonitorVisibility(KStudioEventStream stream)
{
DebugHelper.AssertUIThread();
if (stream != null)
{
EventStreamState streamState = stream.UserState as EventStreamState;
if (streamState != null)
{
if (streamState.IsVisibleForTargetMonitor)
{
this.lastHiddenMonitorableStreams.HashSet.Remove(new KStudioEventStreamIdentifier(stream.DataTypeId, stream.SemanticId));
}
else
{
this.lastHiddenMonitorableStreams.HashSet.Add(new KStudioEventStreamIdentifier(stream.DataTypeId, stream.SemanticId));
}
}
}
this.RaisePropertyChanged("TargetMonitorableStreamsTitle");
this.RaisePropertyChanged("TargetMonitorableStreamsToolTip");
}
public KinectColor(KStudioEventStream stream) : base(stream)
{
_frameAnalysis = CountDroppedFrames();
}
public bool DoTargetRecordingDance(KStudioEventStream stream, bool newValue)
{
DebugHelper.AssertUIThread();
bool okay = false;
if (stream == null)
{
Debug.Assert(newValue == false);
this.selectedTargetStreamsRecordable = false;
RaisePropertyChanged("CanRecord");
}
else
{
okay = true;
// if unselecting the stream, first unselect all hidden streams that require the changing stream
if (!newValue)
{
Dictionary<KStudioEventStream, bool?> recordableStreams = new Dictionary<KStudioEventStream, bool?>();
foreach (KStudioEventStream recordableStream in this.targetRecordableStreams)
{
EventStreamState state = (EventStreamState)recordableStream.UserState;
recordableStreams.Add(recordableStream, recordableStream == stream ? false : state.IsSelectedForTargetRecording);
}
foreach (KStudioEventStream recordableStream in this.targetRecordableStreams)
{
if (recordableStream != stream)
{
EventStreamState state = (EventStreamState)(recordableStream.UserState);
if (state.IsSelectedForTargetRecording && !state.IsVisibleForTargetRecording)
{
if (!recordableStream.HasSelectionRequirements(KStudioEventStreamSelectorRequirementFlags.ProcessRecord, recordableStreams))
{
state.IsSelectedForTargetRecordingNoCheck = false;
}
}
}
}
}
{
Dictionary<KStudioEventStream, bool?> recordableStreams = new Dictionary<KStudioEventStream, bool?>();
foreach (KStudioEventStream recordableStream in this.targetRecordableStreams)
{
EventStreamState state = (EventStreamState)(recordableStream.UserState);
recordableStreams.Add(recordableStream, state.IsSelectedForTargetRecording);
}
bool canRecord = false;
okay = stream.DetermineSelectionRequirements(KStudioEventStreamSelectorRequirementFlags.ProcessRecord, recordableStreams, newValue, out canRecord);
if (okay)
{
foreach (KeyValuePair<KStudioEventStream, bool?> kv in recordableStreams)
{
if (kv.Key != stream)
{
if (kv.Value.HasValue)
{
((EventStreamState)kv.Key.UserState).IsEnabledForTargetRecording = true;
((EventStreamState)kv.Key.UserState).IsSelectedForTargetRecordingNoCheck = kv.Value.Value;
}
else
{
((EventStreamState)kv.Key.UserState).IsEnabledForTargetRecording = false;
}
}
}
}
this.selectedTargetStreamsRecordable = canRecord;
RaisePropertyChanged("CanRecord");
}
}
return okay;
}
public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
DebugHelper.AssertUIThread();
DataTemplate result = null;
if (this.pluginService != null)
{
string key = null;
Type valueType = null;
Guid dataTypeId = Guid.Empty;
Guid semanticId = Guid.Empty;
MetadataKeyValuePair kv = item as MetadataKeyValuePair;
if (kv != null)
{
Debug.Assert(kv.Value != null);
key = kv.Key;
valueType = kv.Value.GetType();
kv.GetStreamIds(out dataTypeId, out semanticId);
}
else if (item is KeyValuePair <string, object> )
{
KeyValuePair <string, object> kv2 = (KeyValuePair <string, object>)item;
Debug.Assert(kv2.Value != null);
key = kv2.Key;
valueType = kv2.Value.GetType();
// In order to keep the standard Metadata collection as a normal IDictionary (and thus have normal
// KeyValuePair) and not have to copy over read-only metadata into a separate collection proxy,
// set the stream as the DataContext of the ListView parent, and just look it up.
DependencyObject obj = container;
while (true)
{
obj = VisualTreeHelper.GetParent(obj);
if (obj == null)
{
break;
}
FrameworkElement element = obj as FrameworkElement;
if (element != null)
{
KStudioEventStream stream = element.Tag as KStudioEventStream;
if (stream != null)
{
dataTypeId = stream.DataTypeId;
semanticId = stream.SemanticId;
break;
}
}
}
}
if (this.readOnly.GetValueOrDefault(false))
{
result = this.pluginService.GetReadOnlyStreamMetadataDataTemplate(valueType, key, dataTypeId, semanticId);
}
else
{
result = this.pluginService.GetWritableStreamMetadataDataTemplate(valueType, key, dataTypeId, semanticId);
}
}
return(result);
}
/// <summary>
/// Records streams from the Kinect sensor to an event file
/// </summary>
/// <param name="client">KStudioClient which is connected to the Kinect service</param>
/// <param name="filePath">Path to new event file which will be created for recording</param>
/// <param name="duration">How long the recording should last before being stopped</param>
/// <param name="streamNames">Collection of streams to include in the recording</param>
public static void RecordClip(KStudioClient client, string filePath, TimeSpan duration, IEnumerable <string> streamNames)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (!client.IsServiceConnected)
{
throw new InvalidOperationException(Strings.ErrorNotConnected);
}
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
HashSet <Guid> streamDataTypeIds = new HashSet <Guid>();
KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection();
KStudioRecording recording = null;
// decide which streams to record
if (streamNames != null && streamNames.Count <string>() > 0)
{
streamDataTypeIds = StreamSupport.ConvertStreamsToGuids(streamNames);
StreamSupport.VerifyStreamsForRecordAndPlayback(streamDataTypeIds);
}
else
{
if (Path.GetExtension(filePath).ToLower().Equals(Strings.XrfExtension))
{
streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.RawIr);
}
else
{
streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.Ir);
streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.Depth);
streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.Body);
streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.BodyIndex);
}
}
// verify streams are recordable by the Kinect sensor
foreach (Guid stream in streamDataTypeIds)
{
KStudioEventStream eventStream = client.GetEventStream(stream, KStudioEventStreamSemanticIds.KinectDefaultSensorProducer);
if (!eventStream.IsRecordable)
{
throw new InvalidOperationException(string.Format(Strings.ErrorRecordingStreamNotSupported, StreamSupport.ConvertStreamGuidToString(stream)));
}
streamCollection.Add(stream);
}
// fix file extension, if necessary
if (streamDataTypeIds.Contains(KStudioEventStreamDataTypeIds.RawIr) && Path.GetExtension(filePath).ToUpperInvariant().Equals(Strings.XefExtension.ToUpperInvariant()))
{
Path.ChangeExtension(filePath, Strings.XrfExtension);
}
// attempt to record streams for the specified duration
try
{
recording = client.CreateRecording(filePath, streamCollection);
}
catch (Exception)
{
//K4W supports uncompressed and compressed color, so if we get an error, try recording the other type
streamCollection = StreamSupport.CreateStreamCollection(streamDataTypeIds, true);
recording = client.CreateRecording(filePath, streamCollection);
}
using (recording)
{
recording.StartTimed(duration);
while (recording.State == KStudioRecordingState.Recording)
{
Thread.Sleep(500);
}
if (recording.State == KStudioRecordingState.Error)
{
throw new InvalidOperationException(Strings.ErrorRecordingFailed);
}
}
}
private const int DepthHeight = 424; // Height of the depth image
public KinectDepth(KStudioEventStream stream) : base(stream)
{
}
