private void ReplayButtonClick(object sender, RoutedEventArgs e)
{
Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog {
Title = "Select filename", Filter = "Replay files|*.replay"
};
if (openFileDialog.ShowDialog() == true)
{
if (replay != null)
{
replay.SkeletonFrameReady -= ReplaySkeletonFrameReady;
replay.ColorImageFrameReady -= ReplayColorImageFrameReady;
replay.Stop();
}
this.image_stream.DataContext = colorManager;
Stream recordStream = File.OpenRead(openFileDialog.FileName);
replay = new KinectReplay(recordStream);
replay.SkeletonFrameReady += ReplaySkeletonFrameReady;
replay.ColorImageFrameReady += ReplayColorImageFrameReady;
replay.Start();
}
}
private void replayButton_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog {
Title = "Select filename", Filter = "Replay files|*.replay"
};
if (openFileDialog.ShowDialog() == true)
{
if (replay != null)
{
replay.SkeletonFrameReady -= replay_SkeletonFrameReady;
replay.ColorImageFrameReady -= replay_ColorImageFrameReady;
replay.Stop();
}
Stream recordStream = File.OpenRead(openFileDialog.FileName);
replay = new KinectReplay(recordStream);
replay.SkeletonFrameReady += replay_SkeletonFrameReady;
replay.ColorImageFrameReady += replay_ColorImageFrameReady;
replay.DepthImageFrameReady += replay_DepthImageFrameReady;
replay.Start();
}
}
//generate files for analyser
private void generate_initialization()
{
var openFileDialog = new OpenFileDialog {
Title = "Select filename", Filter = "Replay files|*.replay"
};
if (openFileDialog.ShowDialog() == true)
{
//get the pure filename(without path and extension)
string path = openFileDialog.FileName;
string filename = openFileDialog.SafeFileName;
System.Console.WriteLine("path = " + path + "purepath= ");
string pathwithoutextension = path.Remove(path.IndexOf('.'));
replay = new KinectReplay(openFileDialog.FileName);
message = string.Format("Replaying {0}", RecordOptions.ToString());
videoWriter.FrameRate = 30;
videoWriter.Open(pathwithoutextension + ".avi", 640, 480);
//xmlwriter
xmlwriter = new XMLWriter(pathwithoutextension + "_jointsdata.xml", pathwithoutextension + "_keyframes.xml", filename);
IsGenerating = true;
replay.AllFramesReady += ReplayAllFramesReady;
replay.ReplayFinished += CleanupGeneration;
replay.Start();
generationstatus.Content = "generating analysis files, please wait";
}
}
public void Close()
{
if (_replay != null)
{
if (_replay.IsStarted)
{
_replay.Stop();
}
_replay.PropertyChanged -= _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived -= _replay_BodyFrameArrived;
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived -= _replay_ColorFrameArrived;
}
_replay.Dispose();
_replay = null;
}
_colorBitmap = null; // reset to force recreation for new file
}
private void replayButton_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog {
Title = "Select filename", Filter = "Replay files|*.replay"
};
if (openFileDialog.ShowDialog() == true)
{
if (replay != null)
{
replay.SkeletonFrameReady -= replay_SkeletonFrameReady;
replay.ColorImageFrameReady -= replay_ColorImageFrameReady;
replay.Stop();
comparisonStopWatch.Stop();
comparisonStopWatch.Reset();
setPoints();
replayOption.Content = "Record";
}
Stream recordStream = File.OpenRead(openFileDialog.FileName);
replay = new KinectReplay(recordStream);
replay.SkeletonFrameReady += replay_SkeletonFrameReady;
replay.ColorImageFrameReady += replay_ColorImageFrameReady;
replay.Start();
comparisonStopWatch = new Stopwatch();
comparisonStopWatch.Start();
startPlaybackSkeleton();
//Debug.WriteLine("REPLAY");
}
}
public void StopReplaying()
{
if (null != KinectReplay && KinectReplay.Started)
{
KinectReplay.Dispose();
}
Status = Service.RecordingManagerStatus.Standby;
}
public void Close()
{
if (!ReferenceEquals(null, _replay))
{
_replay.Stop();
_replay.Dispose();
_replay = null;
}
}
public KinectFrame(KinectReplay replay)
{
init();
_replay = replay;
//_pixelColorDataLength = replay.ColorDataPixelLength;
//_pixelDepthDataLength = replay.DepthDataPixelLength;
MaxDepth = replay.MaxDepth;
MinDepth = replay.MinDepth;
}
public void StartReplaying(string fileId)
{
StopRecording();
if (null != KinectReplay && KinectReplay.Started)
{
KinectReplay.Dispose();
}
if (null != SkeletonEventListener)
{
foreach (EventHandler <ReplaySkeletonFrameReadyEventArgs> eventHandler
in SkeletonEventListener)
{
KinectReplay.SkeletonFrameReady -= eventHandler;
}
}
if (null != ColorEventListener)
{
foreach (EventHandler <ReplayColorImageFrameReadyEventArgs> eventHandler
in ColorEventListener)
{
KinectReplay.ColorImageFrameReady -= eventHandler;
}
}
_replayStream = new FileStream(
FilesUsed[fileId],
FileMode.Open,
FileAccess.Read
);
KinectReplay = new KinectReplay(_replayStream);
if (null != SkeletonEventListener)
{
foreach (EventHandler <ReplaySkeletonFrameReadyEventArgs> eventHandler
in SkeletonEventListener)
{
KinectReplay.SkeletonFrameReady += eventHandler;
}
}
if (null != ColorEventListener)
{
foreach (EventHandler <ReplayColorImageFrameReadyEventArgs> eventHandler
in ColorEventListener)
{
KinectReplay.ColorImageFrameReady += eventHandler;
}
}
KinectReplay.Start();
Status = Service.RecordingManagerStatus.Replaying;
}
public DeviceBase(AudioBase audio, VideoBase video, String filePath)
{
_audio = audio;
_video = video;
_filePath = filePath;
_deviceType = DeviceType.RECORD_FILE_KINECT_1;
_name = "RF-" + System.IO.Path.GetFileName(_filePath);
replay = new KinectReplay(_filePath);
replay.ReplayFinished += Replay_ReplayFinished;
}
public void RestartReplay()
{
if (null != KinectReplay && null != _replayStream)
{
_replayStream.Position = 0;
KinectReplay.Stop();
KinectReplay.Start();
}
Status = Service.RecordingManagerStatus.Replaying;
}
public static Byte[] GetKinectParams(this KinectReplay player)
{
Log.Debug("GetKinectParams called.");
var bf = new BinaryFormatter();
var stream = new MemoryStream(Properties.Resources.ColorToDepthRelationalParameters);
IEnumerable <byte> kinectParams = bf.Deserialize(stream) as IEnumerable <byte>;
stream.Close();
return(kinectParams.ToArray <byte>());
}
private static async void TranscodeVideo(string kdvrFile, string videoFile)
{
string tempPath = Path.GetTempPath() + Guid.NewGuid();
try
{
Directory.CreateDirectory(tempPath);
using (Stream kdvrStream = File.Open(kdvrFile, FileMode.Open, FileAccess.Read))
{
if (kdvrStream == null)
{
Console.Error.WriteLine("Error opening file {0}", kdvrFile);
return;
}
using (KinectReplay replay = new KinectReplay(kdvrStream))
{
if (replay == null || !replay.HasColorFrames)
{
Console.Error.WriteLine("Error with KDVR file (does it have color frames?)");
return;
}
Console.WriteLine("Converting {0} to {1}", kdvrFile, videoFile);
Console.WriteLine("EXPORTING JPEG IMAGES FROM {0}...", kdvrFile);
await replay.ExportColorFramesAsync(tempPath);
Console.WriteLine("ENCODING {0}...", videoFile);
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.UseShellExecute = false;
startInfo.FileName = "ffmpeg.exe";
startInfo.Arguments = "-framerate 30 -i \"" + tempPath + "\\%06d.jpeg\" \"" + videoFile + "\"";
using (Process exeProcess = Process.Start(startInfo))
{
exeProcess.WaitForExit();
}
Console.WriteLine("SUCCESS!!!");
}
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
finally
{
Directory.Delete(tempPath, true);
}
}
public void Initialize()
{
string fakeFile = _fileLocation + Guid.NewGuid().ToString();
_recordingStream = new FileStream(fakeFile, FileMode.OpenOrCreate);
KinectRecorder = new KinectRecorder(0, _recordingStream);
_replayStream = new FileStream(fakeFile + "1", FileMode.OpenOrCreate);
KinectReplay = new KinectReplay(_replayStream);
_dataOutStream = new FileStream(fakeFile + "2", FileMode.OpenOrCreate);
DataRecorder = new PostProcessedRecorder(_dataOutStream);
}
private void CleanupReplay()
{
if (!IsReplaying)
{
return;
}
message = "";
//if (_soundPlayer != null && _startedAudio)
// _soundPlayer.Stop();
replay.AllFramesReady -= ReplayAllFramesReady;
replay.Stop();
replay.Dispose();
replay = null;
IsReplaying = false;
}
private void CleanupGeneration()
{
videoWriter.Close();
IsGenerating = false;
replay.AllFramesReady -= ReplayAllFramesReady;
replay.Stop();
replay.Dispose();
replay = null;
//write xml to disk
xmlwriter.write();
System.Console.WriteLine("lastframenumber = " + lastframenumber);
System.Console.WriteLine("framecounter = " + framecounter);
System.Console.WriteLine("missingFrameCount = " + missingFrameCount);
//lastframenumber
generationstatus.Content = "Generation finished";
}
/// <summary>
/// Start playing selected scene.
/// </summary>
private void Play()
{
if (this.KinectReplay == null)
{
if (this.ReplayStream == null)
{
this.ReplayStream = new FileStream(this.Preferences.KinectDataFile, FileMode.Open);
}
this.KinectReplay = new KinectReplay(this.ReplayStream);
this.KinectReplay.ColorImageFrameReady += new EventHandler <ReplayColorImageFrameReadyEventArgs>(this.ReplayColorImageFrameReady);
this.KinectReplay.SkeletonFrameReady += new EventHandler <ReplaySkeletonFrameReadyEventArgs>(this.ReplaySkeletonFrameReady);
this.KinectReplay.Start();
this.Mode = ControlMode.Replay;
}
}
public void OpenFile(string fullPath)
{
this.Close();
_replay = new KinectReplay(File.Open(fullPath, FileMode.Open, FileAccess.Read));
_replay.PropertyChanged += _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived += _replay_BodyFrameArrived;
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived += _replay_ColorFrameArrived;
}
MainWindow.Instance().sceneDurationLabel.Content = _replay.Duration.ToString(@"hh\:mm\:ss");
this.sendToStartLocation();
//_replay.Start();
//Thread.Sleep(150);
//_replay.Stop();
}
private void ReplayClick(object sender, RoutedEventArgs e)
{
if (IsReplaying)
{
CleanupReplay();
Message = "";
return;
}
_startedAudio = false;
var openFileDialog = new OpenFileDialog {
Title = "Select filename", Filter = "Replay files|*.replay"
};
if (openFileDialog.ShowDialog() == true)
{
replay = new KinectReplay(openFileDialog.FileName);
Message = string.Format("Replaying {0}", RecordOptions.ToString());
replay.AllFramesReady += ReplayAllFramesReady;
replay.ReplayFinished += CleanupReplay;
replay.Start();
}
IsReplaying = true;
}
public void Play()
{
if (ReferenceEquals(null, _replay) &&
!ReferenceEquals(null, _dataAccessFacade.GetSceneInUseAccess().GetScene()))
{
try
{
string fileName = _dataAccessFacade.GetGeneralSettings().GetDataDirectory() +
"scene/" + _dataAccessFacade.GetSceneInUseAccess().GetScene().SceneId + "/kinect.dvr";
if (File.Exists(fileName))
{
Console.WriteLine($"archivo {fileName} existe, a abrirlo");
_replay = new KinectReplay(File.Open(fileName, FileMode.Open, FileAccess.Read));
_replay.PropertyChanged += _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived += KinectInput.SkeletonColorVideoViewer._replay_BodyFrameArrived;
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived += KinectInput.SkeletonColorVideoViewer._replay_ColorFrameArrived;
}
_replay.ScrubTo(new TimeSpan(0));
_replay.Start();
}
}
catch (Exception)
{
Close();
}
}
else
{
_replay.Start();
}
}
void OpenButton_Click(object sender, RoutedEventArgs e)
{
if (_replay != null)
{
if (_replay.IsStarted)
{
_replay.Stop();
}
_replay.PropertyChanged -= _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived -= _replay_BodyFrameArrived;
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived -= _replay_ColorFrameArrived;
}
if (_replay.HasDepthFrames)
{
_replay.DepthFrameArrived -= _replay_DepthFrameArrived;
}
if (_replay.HasInfraredFrames)
{
_replay.InfraredFrameArrived -= _replay_InfraredFrameArrived;
}
_replay = null;
}
var dlg = new OpenFileDialog()
{
DefaultExt = ".kdvr",
Filter = "KinectEx.DVR Files (*.kdvr)|*.kdvr"
};
if (dlg.ShowDialog().GetValueOrDefault())
{
_colorBitmap = null; // reset to force recreation for new file
OutputCombo.Items.Clear();
_replay = new KinectReplay(File.Open(dlg.FileName, FileMode.Open, FileAccess.Read));
_replay.PropertyChanged += _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived += _replay_BodyFrameArrived;
OutputCombo.Items.Add("Body");
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived += _replay_ColorFrameArrived;
OutputCombo.Items.Add("Color");
}
if (_replay.HasDepthFrames)
{
_replay.DepthFrameArrived += _replay_DepthFrameArrived;
OutputCombo.Items.Add("Depth");
}
if (_replay.HasInfraredFrames)
{
_replay.InfraredFrameArrived += _replay_InfraredFrameArrived;
OutputCombo.Items.Add("Infrared");
}
if (OutputCombo.Items.Count > 0)
{
OutputCombo.SelectedIndex = 0;
}
else
{
PlayButton.IsEnabled = false;
}
}
}
async void OpenButton_Click(object sender, RoutedEventArgs e)
{
if (_replay != null)
{
if (_replay.IsStarted)
{
_replay.Stop();
}
_replay.PropertyChanged -= _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived -= _replay_BodyFrameArrived;
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived -= _replay_ColorFrameArrived;
}
if (_replay.HasDepthFrames)
{
_replay.DepthFrameArrived -= _replay_DepthFrameArrived;
}
if (_replay.HasInfraredFrames)
{
_replay.InfraredFrameArrived -= _replay_InfraredFrameArrived;
}
_replay = null;
}
var picker = new FileOpenPicker();
picker.FileTypeFilter.Add(".kdvr");
var file = await picker.PickSingleFileAsync();
if (file != null)
{
_colorBitmap = null; // reset to force recreation for new file
OutputCombo.Items.Clear();
_replay = new KinectReplay(await file.OpenStreamForReadAsync());
_replay.PropertyChanged += _replay_PropertyChanged;
if (_replay.HasBodyFrames)
{
_replay.BodyFrameArrived += _replay_BodyFrameArrived;
OutputCombo.Items.Add("Body");
}
if (_replay.HasColorFrames)
{
_replay.ColorFrameArrived += _replay_ColorFrameArrived;
OutputCombo.Items.Add("Color");
}
if (_replay.HasDepthFrames)
{
_replay.DepthFrameArrived += _replay_DepthFrameArrived;
OutputCombo.Items.Add("Depth");
}
if (_replay.HasInfraredFrames)
{
_replay.InfraredFrameArrived += _replay_InfraredFrameArrived;
OutputCombo.Items.Add("Infrared");
}
if (OutputCombo.Items.Count > 0)
{
OutputCombo.SelectedIndex = 0;
LocationSlider.Maximum = _replay.Duration.TotalMilliseconds;
LocationSlider.TickFrequency = 1000;
LocationSlider.SmallChange = 1000;
}
else
{
PlayButton.IsEnabled = false;
}
}
}
