/// <summary> /// Function used to store raw data from kinect /// </summary> /// <param name="filePath">path of the recording file</param> /// <param name="duration">duration of the recording in seconds</param> public void RecordData(string filePath, TimeSpan duration) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.StartTimed(duration); while (recording.State == KStudioRecordingState.Recording) { Thread.Sleep(500); } if (recording.State == KStudioRecordingState.Error) { throw new InvalidOperationException("Error: Recording failed!"); } } client.DisconnectFromService(); } }
public int GetNumOfFrames(Guid typeId) { int numFrames = 0; try { using (KStudioClient client = KStudio.CreateClient(KStudioClientFlags.ProcessNotifications)) { ManualResetEvent mr = new ManualResetEvent(false); KStudioEventStreamSelectorCollection selEvents = new KStudioEventStreamSelectorCollection(); selEvents.Add(typeId); //This is where you will intercept steps in the XEF file using (var reader = client.CreateEventReader(_path, selEvents)) { KStudioEvent ev; reader.GetNextEvent(); while ((ev = reader.GetNextEvent()) != null) { numFrames++; } } } } catch (Exception e) { if (e.Message == "Operation is not valid due to the current state of the object.") { throw new Exception($"No events of type {typeId} in this XEF file!"); } } return(numFrames); }
public T[] LoadFrame <T>(int desiredFrameNum, Guid eventType, Func <KStudioEvent, T[]> pixelCopyOperation) { T[] pixels = null; using (KStudioClient client = KStudio.CreateClient(KStudioClientFlags.ProcessNotifications)) { KStudioEventStreamSelectorCollection selEvents = new KStudioEventStreamSelectorCollection(); selEvents.Add(eventType); //This is where you will intercept steps in the XEF file using (var reader = client.CreateEventReader(_path, selEvents)) { KStudioEvent ev; reader.GetNextEvent(); int frameNum = 0; while ((ev = reader.GetNextEvent()) != null) { if (frameNum == desiredFrameNum) { pixels = pixelCopyOperation(ev); break; } frameNum++; } } } return(pixels); }
public static void Play(object filePathObj) { using (var client = KStudio.CreateClient()) { string filePath = (string)filePathObj; //Console.WriteLine("Connecting to a service"); client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); using (var playback = client.CreatePlayback(filePath)) { //Console.WriteLine("Playback created"); playback.EndBehavior = KStudioPlaybackEndBehavior.Stop; playback.Start(); //for (var j = 0; j < 700; j++) //{ // playback.StepOnce(); // Thread.Sleep(500); //} while (playback.State == KStudioPlaybackState.Playing) { Thread.Sleep(500); } if (playback.State == KStudioPlaybackState.Error) { throw new InvalidOperationException("Error: Playback failed!"); } } //return true; //Console.WriteLine("Disconnecting"); client.DisconnectFromService(); } }
/// <summary> /// Converts a collection of stream GUIDs to a KStudioEventStreamSelectorCollection object that can be used for playback and record /// </summary> /// <param name="streamGuids">collection of stream Guids to add</param> /// <param name="swapColor">true, if the uncompressed and compressed color streams should be swapped</param> /// <returns>A KStudioEventStreamSelectorCollection object which contains the requested streams</returns> internal static KStudioEventStreamSelectorCollection CreateStreamCollection(IEnumerable <Guid> streamGuids, bool swapColor) { KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); HashSet <Guid> streamDataTypeIds = streamGuids as HashSet <Guid>; if (swapColor) { if (streamDataTypeIds.Contains(KStudioEventStreamDataTypeIds.UncompressedColor)) { streamDataTypeIds.Remove(KStudioEventStreamDataTypeIds.UncompressedColor); streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.CompressedColor); } else if (streamDataTypeIds.Contains(KStudioEventStreamDataTypeIds.CompressedColor)) { streamDataTypeIds.Remove(KStudioEventStreamDataTypeIds.CompressedColor); streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.UncompressedColor); } } foreach (Guid dataTypeId in streamDataTypeIds) { streamCollection.Add(dataTypeId); } return(streamCollection); }
/// <summary> /// Records a new .xef file /// </summary> /// <param name="filePath">Full path to where the file should be saved to</param> private void RecordClip(string filePath) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); // Specify which streams should be recorded KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); streamCollection.Add(KStudioEventStreamDataTypeIds.BodyIndex); // Create the recording object using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.StartTimed(this.duration); while (recording.State == KStudioRecordingState.Recording) { Thread.Sleep(500); } } client.DisconnectFromService(); } // Update UI after the background recording task has completed this.isRecording = false; this.Dispatcher.BeginInvoke(new NoArgDelegate(UpdateState)); }
///// <summary> ///// Function used to store raw data from kinect ///// </summary> ///// <param name="filePath">path of the recording file</param> ///// <param name="duration">duration of the recording in seconds</param> //public void RecordData(string filePath, TimeSpan duration) //{ // using (KStudioClient client = KStudio.CreateClient()) // { // client.ConnectToService(); // KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); // streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); // streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); // streamCollection.Add(KStudioEventStreamDataTypeIds.Body); // using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) // { // recording.StartTimed(duration); // while (recording.State == KStudioRecordingState.Recording) // { // Thread.Sleep(500); // } // if (recording.State == KStudioRecordingState.Error) // { // throw new InvalidOperationException("Error: Recording failed!"); // } // } // client.DisconnectFromService(); // } //} /// <summary> /// Function used to store raw data from kinect /// </summary> /// <param name="filePath">path of the recording file</param> public void RecordData(string filePath) { _keepRecording = true; using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); //streamCollection.Add(KStudioEventStreamDataTypeIds.CompressedColor); using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.Start(); //stopRecording.WaitOne(); while (_keepRecording) { Thread.Sleep(500); } recording.Stop(); if (recording.State == KStudioRecordingState.Error) { throw new InvalidOperationException("Error: Recording failed!"); } } client.DisconnectFromService(); } }
public Task RecordClip(string filePath, TimeSpan duration) { if (IsRecording || IsPlaying) { return(null); } if (duration == TimeSpan.Zero) { duration = _maxRecordingDuration; } _stopRequested = false; Task t = Task.Run(() => { _recording = true; using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); //streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); streamCollection.Add(KStudioEventStreamDataTypeIds.BodyIndex); streamCollection.Add(KStudioEventStreamDataTypeIds.UncompressedColor); using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.StartTimed(duration); while (recording.State == KStudioRecordingState.Recording) { if (_stopRequested) { recording.Stop(); } Thread.Sleep(50); } if (recording.State == KStudioRecordingState.Error) { throw new InvalidOperationException("Error: Recording failed!"); } } client.DisconnectFromService(); } Thread.Sleep(500); _recording = false; }); return(t); }
private void RecordClip(string filePath) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); if (FInputIRStream[0]) { streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); } if (FInputDepthStream[0]) { streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); } streamCollection.Add(KStudioEventStreamDataTypeIds.Body); streamCollection.Add(KStudioEventStreamDataTypeIds.BodyIndex); if (FInputRGBStream[0]) { streamCollection.Add(KStudioEventStreamDataTypeIds.UncompressedColor); } recordingBufferSizeMB = (uint)FInputRecordingBufferSizeMB[0]; recording = client.CreateRecording(filePath, streamCollection, recordingBufferSizeMB, KStudioRecordingFlags.IgnoreOptionalStreams); using (recording) { recording.PropertyChanged += Recording_PropertyChanged; recording.Start(); FRecordBufferSizeMegabytes[0] = (uint)recording.BufferSizeMegabytes; while ((recording.State == KStudioRecordingState.Recording) && (doRecord)) { Thread.Sleep(100); //recording reports no values :( FRecordBufferInUseSizeMegabytes[0] = recording.BufferInUseSizeMegabytes; } recording.Stop(); //wait until the recording buffer is empty while (recording.BufferInUseSizeMegabytes > 0) { Thread.Sleep(50); FRecordBufferInUseSizeMegabytes[0] = recording.BufferInUseSizeMegabytes; } recording.PropertyChanged -= Recording_PropertyChanged; } client.DisconnectFromService(); } }
/// <summary> /// Playback a list of clips /// </summary> /// <param name="filename">ObservableCollection of VideoModel objects that contains Filename of the clip to be played.</param> private void PlaybackClip(ObservableCollection <VideoModel> videos) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); VideoModel video; int i = 0; while (i < videos.Count) { video = videos[i]; if (!string.IsNullOrEmpty(video.Filename)) { _status = "Playing " + video.Filename + " - " + (i + 1) + "/" + videos.Count; using (KStudioPlayback playback = client.CreatePlayback(video.Filename)) { _isPlaying = true; _stop = false; // We can use playback.StartPaused() and SeekRelativeTime to start the clip at // a specific time. playback.Start(); while (playback.State == KStudioPlaybackState.Playing) { Thread.Sleep(150); if (_stop) { playback.Stop(); break; } } _isPlaying = false; if (_stop) { return; } } } i++; } client.DisconnectFromService(); } }
/// <summary> /// 开始录制xef文件 /// </summary> /// <param name="filePath">xef文件路径</param> public void StartRecordClip(object filePath) { try { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); //streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); streamCollection.Add(KStudioEventStreamDataTypeIds.BodyIndex); //streamCollection.Add(KStudioEventStreamDataTypeIds.UncompressedColor); using (KStudioRecording recording = client.CreateRecording((string)filePath, streamCollection)) { recording.Start(); SharpAvi.IsCreateRecord = true; SharpAvi.IsRecording = true; while (recording.State == KStudioRecordingState.Recording) { //Flag为1时调出循环,结束录像 if (_flag == 1) { break; } } SharpAvi.IsStopRecord = true; recording.Stop(); recording.Dispose(); } client.DisconnectFromService(); client.Dispose(); _flag = 0; } } catch { _flag = 0; _flag1 = 1; SharpAvi.IsStopRecord = true; MessageBox.Show("视频录制出现异常"); } }
public void StartRecording(string filePath) { client = KStudio.CreateClient(); client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.UncompressedColor); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); // The enum value for Audio is missing. The GUID below was taken from Kinect Studio. var Audio = new Guid(0x787c7abd, 0x9f6e, 0x4a85, 0x8d, 0x67, 0x63, 0x65, 0xff, 0x80, 0xcc, 0x69); streamCollection.Add(Audio); recording = client.CreateRecording(filePath, streamCollection, KStudioRecordingFlags.IgnoreOptionalStreams); recording.Start(); LogConsole.WriteLine("File opened and recording ..."); }
public void OpenRecording(string filePath) { client = KStudio.CreateClient(); client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.UncompressedColor); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); Guid Audio = new Guid(0x787c7abd, 0x9f6e, 0x4a85, 0x8d, 0x67, 0x63, 0x65, 0xff, 0x80, 0xcc, 0x69); streamCollection.Add(Audio); playback = client.CreatePlayback(filePath, streamCollection); playback.StateChanged += KStudioClient_Playback_StateChanged; playback.Start(); OnKinectAvailabilityChanged(this, true); LogConsole.WriteLine("Recording opened and playing ..."); }
/// <summary> /// Playback a clip /// </summary> /// <param name="filename">Path/name of the clip to be played.</param> private void PlaybackClip(string filename) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); using (KStudioPlayback playback = client.CreatePlayback(filename)) { // If the clip should not be evaluated from the begining. // It should start paused. if (_initialTime.Milliseconds > 0) { playback.StartPaused(); playback.SeekByRelativeTime(_initialTime); playback.Resume(); } else { playback.Start(); } while (playback.State == KStudioPlaybackState.Playing && !finished) { Thread.Sleep(150); } // Finished the read of frames for calibration. if (finished) { playback.Stop(); } } client.DisconnectFromService(); } }
/// <summary> /// Records a new .xef file and saves body data to a .txt file /// </summary> /// <param name="filePath">full path to where the file should be saved to</param> private void RecordClip(string filePath) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection { KStudioEventStreamDataTypeIds.Ir, KStudioEventStreamDataTypeIds.Depth, KStudioEventStreamDataTypeIds.Body, KStudioEventStreamDataTypeIds.BodyIndex, KStudioEventStreamDataTypeIds.UncompressedColor }; using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.StartTimed(this.duration); while (recording.State == KStudioRecordingState.Recording) { Thread.Sleep(500); } } client.DisconnectFromService(); } if (this.trackedBodies.Count > 0) { this.SaveBodiesToFile(this.trackedBodies); } // Update UI after the background recording task has completed this.isRecording = false; this.Dispatcher.BeginInvoke(new NoArgDelegate(UpdateState)); }
public DepthProcessor LoadDepthFrame(int desiredFrameNum, int numberOfDepthSmooths) { var dProcessor = new DepthProcessor(); dProcessor.FrameSelector = new FrameSelector(desiredFrameNum, numberOfDepthSmooths); using (KStudioClient client = KStudio.CreateClient(KStudioClientFlags.ProcessNotifications)) { ManualResetEvent mr = new ManualResetEvent(false); KStudioEventStreamSelectorCollection selEvents = new KStudioEventStreamSelectorCollection(); selEvents.Add(KStudioEventStreamDataTypeIds.Depth); //This is where you will intercept steps in the XEF file KStudioEventReader reader = client.CreateEventReader(_path, selEvents); KStudioEvent ev; while ((ev = reader.GetNextEvent()) != null && !dProcessor.FrameSelector.AreAllFramesCaptured) { dProcessor.ProcessEvent(ev); } reader.Dispose(); } return(dProcessor); }
/// <summary> /// Plays an event file to the Kinect service /// </summary> /// <param name="client">KStudioClient which is connected to the Kinect service</param> /// <param name="filePath">Path to event file which is targeted for playback</param> /// <param name="streamNames">Collection of streams to include in the playback session</param> /// <param name="loopCount">Number of times the playback should be repeated before stopping</param> public static void PlaybackClip(KStudioClient client, string filePath, IEnumerable <string> streamNames, uint loopCount) { if (client == null) { throw new ArgumentNullException("client"); } if (!client.IsServiceConnected) { throw new InvalidOperationException(Strings.ErrorNotConnected); } if (string.IsNullOrEmpty(filePath)) { throw new ArgumentNullException("filePath"); } KStudioPlayback playback = null; // determine if all specified streams are valid for playback if (streamNames.Count <string>() > 0) { HashSet <Guid> playbackDataTypeIds = StreamSupport.ConvertStreamsToPlaybackGuids(streamNames); StreamSupport.VerifyStreamsForRecordAndPlayback(playbackDataTypeIds); Playback.VerifyStreamsForPlayback(client, filePath, playbackDataTypeIds); try { KStudioEventStreamSelectorCollection streams = StreamSupport.CreateStreamCollection(playbackDataTypeIds, false); playback = client.CreatePlayback(filePath, streams); } catch (Exception) { //K4W supports uncompressed and compressed color, so if we get an error, try playing the other type KStudioEventStreamSelectorCollection streams = StreamSupport.CreateStreamCollection(playbackDataTypeIds, true); playback = client.CreatePlayback(filePath, streams); } } else { playback = client.CreatePlayback(filePath); } // begin playback using (playback) { playback.EndBehavior = KStudioPlaybackEndBehavior.Stop; // this is the default behavior playback.Mode = KStudioPlaybackMode.TimingEnabled; // this is the default behavior playback.LoopCount = loopCount; playback.Start(); while (playback.State == KStudioPlaybackState.Playing) { Thread.Sleep(500); } if (playback.State == KStudioPlaybackState.Error) { throw new InvalidOperationException(Strings.ErrorPlaybackFailed); } } }
public void StartMonitor() { DebugHelper.AssertUIThread(); if ((this.client != null) && (this.monitor == null)) { KStudioEventStreamSelectorCollection streamSelectorCollection = new KStudioEventStreamSelectorCollection(); foreach (KStudioEventStream s in this.targetMonitorableStreams.OfType<KStudioEventStream>()) { EventStreamState streamState = s.UserState as EventStreamState; if (streamState != null) { if (streamState.IsSelectedForTargetMonitor) { streamSelectorCollection.Add(s.DataTypeId, s.SemanticId); this.lastMonitoredStreams.HashSet.Add(new KStudioEventStreamIdentifier(s.DataTypeId, s.SemanticId)); } else { this.lastMonitoredStreams.HashSet.Remove(new KStudioEventStreamIdentifier(s.DataTypeId, s.SemanticId)); } } } if (streamSelectorCollection.Count > 0) { try { this.MonitorTime = TimeSpan.Zero; this.monitor = this.client.CreateMonitor(streamSelectorCollection, KStudioMonitorFlags.IgnoreOptionalStreams); this.monitor.PropertyChanged += this.Monitor_PropertyChanged; this.MonitorState = this.monitor.State; KStudioMonitor temp = this.monitor; this.RunAsync(() => temp.Start()); if (this.pluginService != null) { this.pluginService.ClearEvents(EventType.Monitor); } this.RaisePropertyChanged("MonitorViewStateTitle"); this.RaisePropertyChanged("ComboViewStateTitle"); this.monitorTimer.Start(); } catch (Exception ex) { this.StopMonitor(); this.HandleMonitorError(ex); return; } } } }
public void StartRecording() { DebugHelper.AssertUIThread(); this.ClosePlayback(); if ((this.client != null) && (this.recording == null) && (this.playback == null)) { bool rawRecording = false; KStudioEventStreamSelectorCollection streamSelectorCollection = new KStudioEventStreamSelectorCollection(); foreach (KStudioEventStream s in this.targetRecordableStreams.OfType<KStudioEventStream>().Where(s => ((EventStreamState)s.UserState).IsSelectedForTargetRecording)) { if (s.DataTypeId == KStudioEventStreamDataTypeIds.RawIr) { rawRecording = true; } streamSelectorCollection.Add(s.DataTypeId, s.SemanticId); } string filePath = null; try { if ((this.settings != null) && this.settings.AutoStopMonitorOnRecord) { this.StopMonitor(); } this.RecordingTime = TimeSpan.Zero; KStudioRecordingFlags flags = KStudioRecordingFlags.GenerateFileName | KStudioRecordingFlags.IgnoreOptionalStreams; if (rawRecording) { flags |= KStudioRecordingFlags.XrfFileName; } this.recording = this.client.CreateRecording(this.TargetFilePath, streamSelectorCollection, this.settings.RecordingBufferSizeMB, flags); filePath = recording.FilePath; this.RecordingState = this.recording.State; this.RecordingFilePath = filePath; this.RecordingFileSizeBytes = this.recording.FileSizeBytes; this.RecordingBufferSizeMegabytes = this.recording.BufferSizeMegabytes; this.RecordingBufferInUseMegabytes = this.recording.BufferInUseSizeMegabytes; this.RecordingMetadata = new MetadataInfo(false, Strings.RecordingMetadata_Title, this.recordingFilePath, new WritableMetadataProxy(null, this.recording.GetMetadata(KStudioMetadataType.Public)), new WritableMetadataProxy(null, this.recording.GetMetadata(KStudioMetadataType.PersonallyIdentifiableInformation))); foreach (KStudioEventStream s in this.targetRecordableStreams.OfType<KStudioEventStream>()) { EventStreamState streamState = s.UserState as EventStreamState; if (streamState != null) { if (streamState.IsSelectedForTargetRecording) { streamState.Metadata = new MetadataInfo(false, streamState.ShortName, this.recordingFilePath + "\n" + streamState.LongName, new WritableMetadataProxy(null, this.recording.GetMetadataForStream(KStudioMetadataType.Public, s.DataTypeId, s.SemanticId)), new WritableMetadataProxy(null, this.recording.GetMetadataForStream(KStudioMetadataType.PersonallyIdentifiableInformation, s.DataTypeId, s.SemanticId))); this.lastRecordedStreams.HashSet.Add(new KStudioEventStreamIdentifier(s.DataTypeId, s.SemanticId)); } else { this.lastRecordedStreams.HashSet.Remove(new KStudioEventStreamIdentifier(s.DataTypeId, s.SemanticId)); } } } this.recording.PropertyChanged += this.Recording_PropertyChanged; this.SetDefaultMetadataViews(this.recordingMetadata); KStudioRecording temp = this.recording; this.RunAsync(() => temp.Start()); } catch (Exception ex) { this.CloseRecording(false); this.HandleFileCreateError(ex, filePath); } } }
public void RecordClip() { //Console.WriteLine("the thing filepath is"+thing.FilePath); string xefname = filePath + MainWindow.textbox + ".xef"; // Make sure to have enough disk space for the recording DriveInfo[] allDrives = DriveInfo.GetDrives(); //const string c = @"G:\"; try { foreach (DriveInfo d in allDrives) { if (d.IsReady && d.Name == c) { long totfreespace = d.TotalFreeSpace; if (totfreespace < minimum_size) { string size = (minimum_size / 1E9).ToString(); mes = "Not enough disk space to record Kinect video, Available memory less than " + size + " GB"; throw new System.ArgumentException(mes); } } } } catch (ArgumentException exx) { Console.WriteLine("{0} Exception caught.", exx); done = true; //act_rec.Reset(); rec_error = true; if (exx.Message != mes) { // Let's restart the Kinect video service // This service once stopped does not seem to restart automatically Process[] kstu = Process.GetProcessesByName("KStudioHostService"); /// kstu[0].Kill(); // Kill the process kstu = Process.GetProcessesByName("KinectService"); kstu[0].Kill(); } while (MessageBox.Show(exx.Message, "ERROR", MessageBoxButton.OK, MessageBoxImage.Error) != MessageBoxResult.OK) { Thread.Sleep(20); } // Reset the recording error before exiting rec_error = false; return; } // try // { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); streamCollection.Add(KStudioEventStreamDataTypeIds.BodyIndex); streamCollection.Add(KStudioEventStreamDataTypeIds.UncompressedColor); //streamCollection.Add(KStudioEventStreamDataTypeIds.CompressedColor); try { Console.WriteLine("now the filepath is " + filePath); using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { // Introduce a timer to make sure that the recording is never longer than expected // act_rec.Start(); //recording.StartTimed(duration); recording.Start(); while (recording.Duration.TotalMilliseconds < dur && done == false) { Thread.Sleep(30); //int si = (int)recording.BufferInUseSizeMegabytes; // Console.WriteLine("Recording Buffer in Megabytes {0} ", si); } recording.Stop(); recording.Dispose(); } } catch (Exception e) { Console.WriteLine("{0} Exception caught.", e); done = true; rec_error = true; while (MessageBox.Show("ERROR", e.Message, MessageBoxButton.OK, MessageBoxImage.Error) != MessageBoxResult.OK) { Thread.Sleep(20); } // Reset the recording error before exiting rec_error = false; return; } finally { Thread.Sleep(100); client.DisconnectFromService(); } } // Make sure to reset the bool done variable once recording is done }
private void StartPlayback(bool startPaused) { DebugHelper.AssertUIThread(); if ((this.playback == null) && (this.playbackFile != null)) { if (!this.IsPlaybackFileOnTarget) { this.StopMonitor(); } KStudioEventStreamSelectorCollection streamSelectorCollection = null; KStudioPlaybackFlags flags = KStudioPlaybackFlags.IgnoreOptionalStreams; this.playbackStep = null; if (this.playbackFileLocal) { flags |= KStudioPlaybackFlags.ToClient; streamSelectorCollection = new KStudioEventStreamSelectorCollection(); foreach (KStudioEventStream stream in this.playbackFile.EventStreams) { if ((this.pluginService == null) || this.pluginService.IsInterestedInEventsFrom(EventType.Inspection, stream.DataTypeId, stream.SemanticId)) { streamSelectorCollection.Add(stream.DataTypeId, stream.SemanticId); // last one always wins if ((stream.DataTypeId == KStudioEventStreamDataTypeIds.LongExposureIr) || (stream.DataTypeId == KStudioEventStreamDataTypeIds.Ir) || (stream.DataTypeId == KStudioEventStreamDataTypeIds.Depth) || (stream.DataTypeId == KStudioEventStreamDataTypeIds.RawIr)) { this.playbackStep = new KStudioEventStreamIdentifier(stream.DataTypeId, stream.SemanticId); } } } } else { streamSelectorCollection = new KStudioEventStreamSelectorCollection(); foreach (KStudioEventStream stream in this.targetPlaybackableStreams.OfType<KStudioEventStream>()) { EventStreamState ess = stream.UserState as EventStreamState; if ((ess != null) && ess.IsSelectedForTargetPlayback && (ess.SelectedFilePlaybackStream != null)) { streamSelectorCollection.Add(stream.DataTypeId, ess.SelectedFilePlaybackStream.SemanticId, stream.SemanticId); if (stream.SemanticId == KStudioEventStreamSemanticIds.KinectDefaultSensorConsumer) { if ((stream.DataTypeId == KStudioEventStreamDataTypeIds.LongExposureIr)) { // LEIR always wins because of the way mapping order works this.playbackStep = new KStudioEventStreamIdentifier(stream.DataTypeId, ess.SelectedFilePlaybackStream.SemanticId); } else if ((stream.DataTypeId == KStudioEventStreamDataTypeIds.Ir) || (stream.DataTypeId == KStudioEventStreamDataTypeIds.RawIr)) { if (this.playbackStep == null) { this.playbackStep = new KStudioEventStreamIdentifier(stream.DataTypeId, ess.SelectedFilePlaybackStream.SemanticId); } } } } } } this.playback = this.client.CreatePlayback(playbackFile, streamSelectorCollection, flags); this.playback.PropertyChanged += this.Playback_PropertyChanged; this.PlaybackState = this.playback.State; PlaybackFileSettings playbackFileSettings = this.playbackFile.UserState as PlaybackFileSettings; if (playbackFileSettings != null) { playbackFileSettings.SaveStreamSelection(); } if (this.playbackPausePoints != null) { this.playbackPausePoints.Playback = this.playback; } if (this.playbackInOutPoints != null) { this.playbackInOutPoints.Playback = this.playback; } this.playback.LoopCount = this.playbackLoopCount; this.playback.CurrentLoopIteration = this.playbackLoopIteration; KStudioPlayback temp = this.playback; if (this.playbackStartTime != TimeSpan.Zero) { temp.SeekByRelativeTime(this.playbackStartTime); this.playbackStartTime = TimeSpan.Zero; } if (this.IsPlaybackFileOnTarget && (this.pluginService != null)) { this.pluginService.ClearEvents(EventType.Inspection); } this.RaisePropertyChanged("MonitorViewStateTitle"); this.RaisePropertyChanged("ComboViewStateTitle"); if (startPaused) { this.RunAsync(() => temp.StartPaused()); } else { this.RunAsync(() => temp.Start()); } if (this.IsPlaybackFileOnTarget && (this.settings != null) && this.settings.AutoMonitorOnTargetPlayback) { this.StartMonitor(); } } else if (this.playback != null) { KStudioPlayback temp = this.playback; if (this.playback.State == KStudioPlaybackState.Paused) { this.RunAsync(() => temp.Resume()); } else { this.RunAsync(() => temp.Start()); } } }
public static void RecordClip(string filePath, TimeSpan duration) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection { KStudioEventStreamDataTypeIds.Ir, KStudioEventStreamDataTypeIds.Depth, KStudioEventStreamDataTypeIds.Body, KStudioEventStreamDataTypeIds.BodyIndex }; using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.StartTimed(duration); while (recording.State == KStudioRecordingState.Recording) { Thread.Sleep(500); } if (recording.State == KStudioRecordingState.Error) { throw new InvalidOperationException("Error: Recording failed!"); } } client.DisconnectFromService(); } }
/// <summary> /// Records a new .xef file /// </summary> /// <param name="filePath">Full path to where the file should be saved to</param> private void RecordClip(string filePath) { using (KStudioClient client = KStudio.CreateClient()) { client.ConnectToService(); // Specify which streams should be recorded KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); streamCollection.Add(KStudioEventStreamDataTypeIds.Ir); streamCollection.Add(KStudioEventStreamDataTypeIds.Depth); streamCollection.Add(KStudioEventStreamDataTypeIds.Body); streamCollection.Add(KStudioEventStreamDataTypeIds.BodyIndex); // Create the recording object using (KStudioRecording recording = client.CreateRecording(filePath, streamCollection)) { recording.StartTimed(this.duration); while (recording.State == KStudioRecordingState.Recording) { Thread.Sleep(500); } } client.DisconnectFromService(); } // Update UI after the background recording task has completed this.isRecording = false; this.Dispatcher.BeginInvoke(new NoArgDelegate(UpdateState)); }
/// <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); } } }
/// <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); } } }
/// <summary> /// Converts a collection of stream GUIDs to a KStudioEventStreamSelectorCollection object that can be used for playback and record /// </summary> /// <param name="streamGuids">collection of stream Guids to add</param> /// <param name="swapColor">true, if the uncompressed and compressed color streams should be swapped</param> /// <returns>A KStudioEventStreamSelectorCollection object which contains the requested streams</returns> internal static KStudioEventStreamSelectorCollection CreateStreamCollection(IEnumerable<Guid> streamGuids, bool swapColor) { KStudioEventStreamSelectorCollection streamCollection = new KStudioEventStreamSelectorCollection(); HashSet<Guid> streamDataTypeIds = streamGuids as HashSet<Guid>; if (swapColor) { if (streamDataTypeIds.Contains(KStudioEventStreamDataTypeIds.UncompressedColor)) { streamDataTypeIds.Remove(KStudioEventStreamDataTypeIds.UncompressedColor); streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.CompressedColor); } else if (streamDataTypeIds.Contains(KStudioEventStreamDataTypeIds.CompressedColor)) { streamDataTypeIds.Remove(KStudioEventStreamDataTypeIds.CompressedColor); streamDataTypeIds.Add(KStudioEventStreamDataTypeIds.UncompressedColor); } } foreach (Guid dataTypeId in streamDataTypeIds) { streamCollection.Add(dataTypeId); } return streamCollection; }