public CaptureWindow()
{
InitializeComponent();
try
{
Action <VideoFrame> updateDepth;
Action <VideoFrame> updateColor;
// The colorizer processing block will be used to visualize the depth frames.
colorizer = new Colorizer();
// Create and config the pipeline to strem color and depth frames.
pipeline = new Pipeline();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480);
cfg.EnableStream(Stream.Color, Format.Rgb8);
var pp = pipeline.Start(cfg);
SetupWindow(pp, out updateDepth, out updateColor);
Task.Factory.StartNew(() =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
// We wait for the next available FrameSet and using it as a releaser object that would track
// all newly allocated .NET frames, and ensure deterministic finalization
// at the end of scope.
using (var frames = pipeline.WaitForFrames())
{
var colorFrame = frames.ColorFrame.DisposeWith(frames);
var depthFrame = frames.DepthFrame.DisposeWith(frames);
// We colorize the depth frame for visualization purposes
var colorizedDepth = colorizer.Process <VideoFrame>(depthFrame).DisposeWith(frames);
// Render the frames.
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
Dispatcher.Invoke(new Action(() =>
{
String depth_dev_sn = new Sensor.CameraInfos(depthFrame.Sensor)[CameraInfo.SerialNumber];
txtTimeStamp.Text = depth_dev_sn + " : " + String.Format("{0,-20:0.00}", depthFrame.Timestamp) + "(" + depthFrame.TimestampDomain.ToString() + ")";
}));
}
}
}, tokenSource.Token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
private void Init()
{
using Context ctx = new Context();
var devices = ctx.QueryDevices();
Console.WriteLine($"Found {devices.Count} RealSense devices connected.");
if (devices.Count == 0)
{
throw new Exception("No RealSense device detected!");
}
Device dev = devices[0];
Console.WriteLine($"Using device 0: {dev.Info[CameraInfo.Name]}");
Console.WriteLine("Device Sources:");
foreach (Sensor sensor in dev.Sensors)
{
Console.WriteLine($"Sensor found: {sensor.Info[CameraInfo.Name]}");
}
var cfg = new Config();
cfg.EnableStream(Stream.Depth);
cfg.EnableStream(Stream.Color, Format.Bgr8);
intelPipe = new Intel.RealSense.Pipeline();
PipelineProfile profileIntelPipe = intelPipe.Start(cfg);
var streamDepth = profileIntelPipe.GetStream <VideoStreamProfile>(Stream.Depth);
sicsDepth = streamDepth.GetIntrinsics();
Console.WriteLine($"Depth Stream: {sicsDepth.width}X{sicsDepth.height}");
var streamRBG = profileIntelPipe.GetStream <VideoStreamProfile>(Stream.Color);
sicsRBG = streamRBG.GetIntrinsics();
Console.WriteLine($"RBG Stream: {sicsRBG.width}X{sicsRBG.height}");
Task.Run(() =>
{
while (true)
{
try
{
using FrameSet frames = intelPipe.WaitForFrames();
using Frame frDepth = frames.FirstOrDefault(Stream.Depth);
qDepth.Enqueue(frDepth);
using Frame frRBG = frames.FirstOrDefault(Stream.Color);
qRBG.Enqueue(frRBG);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
});
}
private Pipeline StartPipeline(VideoStreamProfile depthProfile, Device dev)
{
var cfg = new Config();
cfg.EnableDevice(dev.Info[CameraInfo.SerialNumber]);
cfg.EnableStream(Stream.Depth, depthProfile.Width, depthProfile.Height, depthProfile.Format, depthProfile.Framerate);
var pipeline = new Pipeline();
var pp = pipeline.Start(cfg);
return(pipeline);
}
public CaptureWindow()
{
try
{
pipeline = new Pipeline();
colorizer = new Colorizer();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480);
cfg.EnableStream(Stream.Color, Format.Rgb8);
pipeline.Start(cfg);
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
var frames = pipeline.WaitForFrames();
var depth_frame = frames.DepthFrame;
var color_frame = frames.ColorFrame;
var colorized_depth = colorizer.Colorize(depth_frame);
UploadImage(imgDepth, colorized_depth);
UploadImage(imgColor, color_frame);
// It is important to pre-emptively dispose of native resources
// to avoid creating bottleneck at finalization stage after GC
// (Also see FrameReleaser helper object in next tutorial)
frames.Dispose();
depth_frame.Dispose();
colorized_depth.Dispose();
color_frame.Dispose();
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}
static void Main(string[] args)
{
using (var ctx = new Context())
{
DeviceList devices = ctx.QueryDevices();
if (devices.Count == 0)
{
Console.WriteLine("RealSense devices are not connected.");
return;
}
using (var pipeline = new Pipeline(ctx))
using (var config = new Config())
{
// Add pose stream
config.EnableStream(Stream.Pose, Format.SixDOF);
// Start pipeline with chosen configuration
using (var profile = pipeline.Start(config))
using (var streamprofile = profile.GetStream(Stream.Pose).As <PoseStreamProfile>())
{
Console.WriteLine($"\nDevice : {profile.Device.Info[CameraInfo.Name]}");
Console.WriteLine($" Serial number: {profile.Device.Info[CameraInfo.SerialNumber]}");
Console.WriteLine($" Firmware version: {profile.Device.Info[CameraInfo.FirmwareVersion]}");
Console.WriteLine($" Pose stream framerate: {streamprofile.Framerate}\n");
}
while (true)
{
// Wait for the next set of frames from the camera
using (FrameSet frameset = pipeline.WaitForFrames())
// Get a frame from the pose stream
using (PoseFrame frame = frameset.PoseFrame)
{
// Get pose frame data
Pose data = frame.PoseData;
// Print the x, y, z values of the translation, relative to initial position
Console.Write("\r" + new String(' ', 80));
Console.Write("\rDevice Position: {0} {1} {2} (meters)", data.translation.x.ToString("N3"), data.translation.y.ToString("N3"), data.translation.z.ToString("N3"));
}
}
}
}
}
public CaptureWindow()
{
try
{
//窗口最大化
//WindowState = WindowState.Maximized;
//imgColor.Width = WIDTH;
//imgColor.Height = HEIGHT;
//imgDepth.Width = WIDTH;
//imgDepth.Height = HEIGHT;
//imgObs.Width = WIDTH;
//imgObs.Height = HEIGHT;
//初始化定时器
timer1.Tick += new EventHandler(timer1_cycle);
timer1.Interval = new TimeSpan(0, 0, 0, 0, 1000);
pipeline = new Pipeline();
colorizer = new Colorizer();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, WIDTH, HEIGHT);
cfg.EnableStream(Stream.Color, WIDTH, HEIGHT, Format.Rgb8);
//cfg.EnableStream(Stream.Gyro, Format.Z16);
pProfile = pipeline.Start(cfg);
//var gyro = pProfile.GetStream(Stream.Gyro);
imgColor = new Image();
imgDepth = new Image();
timer1.Start();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}
public CaptureWindow()
{
try
{
pipeline = new Pipeline();
colorizer = new Colorizer();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480);
cfg.EnableStream(Stream.Color, Format.Rgb8);
pipeline.Start(cfg);
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
var frames = pipeline.WaitForFrames();
var colorized_depth = colorizer.Colorize(frames.DepthFrame);
UploadImage(imgDepth, colorized_depth);
UploadImage(imgColor, frames.ColorFrame);
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}
public ProcessingWindow()
{
InitializeComponent();
try
{
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480);
cfg.EnableStream(Stream.Color, Format.Rgb8);
var pp = pipeline.Start(cfg);
var s = pp.Device.Sensors;
var blocks = new List <ProcessingBlock>();
foreach (var sensor in pp.Device.Sensors)
{
var list = sensor.ProcessingBlocks;
foreach (var block in list)
{
blocks.Add(block);
}
}
// Allocate bitmaps for rendring.
// Since the sample aligns the depth frames to the color frames, both of the images will have the color resolution
using (var p = pp.GetStream(Stream.Color).As <VideoStreamProfile>())
{
imgColor.Source = new WriteableBitmap(p.Width, p.Height, 96d, 96d, PixelFormats.Rgb24, null);
imgDepth.Source = new WriteableBitmap(p.Width, p.Height, 96d, 96d, PixelFormats.Rgb24, null);
}
var updateColor = UpdateImage(imgColor);
var updateDepth = UpdateImage(imgDepth);
// Create custom processing block
// For demonstration purposes it will:
// a. Get a frameset
// b. Run post-processing on the depth frame
// c. Combine the result back into a frameset
// Processing blocks are inherently thread-safe and play well with
// other API primitives such as frame-queues,
// and can be used to encapsulate advanced operations.
// All invokations are, however, synchronious so the high-level threading model
// is up to the developer
block = new CustomProcessingBlock((f, src) =>
{
// We create a FrameReleaser object that would track
// all newly allocated .NET frames, and ensure deterministic finalization
// at the end of scope.
using (var releaser = new FramesReleaser())
{
var frames = FrameSet.FromFrame(f).DisposeWith(releaser);
foreach (ProcessingBlock p in blocks)
{
frames = p.Process(frames).DisposeWith(releaser);
}
frames = frames.ApplyFilter(align).DisposeWith(releaser);
frames = frames.ApplyFilter(colorizer).DisposeWith(releaser);
var colorFrame = frames[Stream.Color, Format.Rgb8].DisposeWith(releaser);
var colorizedDepth = frames[Stream.Depth, Format.Rgb8].DisposeWith(releaser);
// Combine the frames into a single result
var res = src.AllocateCompositeFrame(colorizedDepth, colorFrame).DisposeWith(releaser);
// Send it to the next processing stage
src.FramesReady(res);
}
});
// Register to results of processing via a callback:
block.Start(f =>
{
using (var frames = FrameSet.FromFrame(f))
{
var colorFrame = frames.ColorFrame.DisposeWith(frames);
var colorizedDepth = frames[Stream.Depth, Format.Rgb8].As <VideoFrame>().DisposeWith(frames);
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
}
});
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
using (var frames = pipeline.WaitForFrames())
{
// Invoke custom processing block
block.ProcessFrames(frames);
}
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}
public MainWindow()
{
InitializeComponent();
pipeline = new RS.Pipeline();
colorizer = new RS.Colorizer();
Action <RS.VideoFrame> mainAction;
Action <RS.VideoFrame> depthAction;
var config = new RS.Config();
config.EnableStream(RS.Stream.Color, 640, 480, RS.Format.Rgb8);
config.EnableStream(RS.Stream.Depth, 640, 480);
timer = new System.Timers.Timer();
timer.Elapsed += Timer_Elapsed;
timer.Interval = 1000;
timer.Enabled = false;
timerCountdown = new System.Timers.Timer();
timerCountdown.Elapsed += TimerCountdown_Elapsed;
timerCountdown.Interval = 1000;
timerCountdown.Enabled = false;
try
{
var pp = pipeline.Start(config);
SetupWindow(pp, out mainAction, out depthAction);
Task.Factory.StartNew(() =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
using (var frames = pipeline.WaitForFrames())
{
var mainFrame = frames.ColorFrame.DisposeWith(frames);
var depthFrame = frames.DepthFrame.DisposeWith(frames);
var colorizedDepth = colorizer.Process <VideoFrame>(depthFrame).DisposeWith(frames);
Dispatcher.Invoke(DispatcherPriority.Render, mainAction, mainFrame);
Dispatcher.Invoke(DispatcherPriority.Render, depthAction, colorizedDepth);
}
if (isRecording)
{
imageCount++;
Dispatcher.Invoke(new SaveImagesDelegate(SaveImage), new object[] { "image_", imageCount });
}
else
{
imageCount = 0;
}
}
}, tokenSource.Token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public CaptureWindow()
{
InitializeComponent();
try
{
Action <VideoFrame> updateDepth;
Action <VideoFrame> updateColor;
pipeline = new Pipeline();
colorizer = new Colorizer();
var depthWidth = 640;
var depthHeight = 480;
var depthFrames = 30;
var depthFormat = Format.Z16;
var colorWidth = 640;
var colorHeight = 480;
var colorFrames = 30;
using (var ctx = new Context())
{
var devices = ctx.QueryDevices();
var dev = devices[0];
Console.WriteLine("\nUsing device 0, an {0}", dev.Info[CameraInfo.Name]);
Console.WriteLine(" Serial number: {0}", dev.Info[CameraInfo.SerialNumber]);
Console.WriteLine(" Firmware version: {0}", dev.Info[CameraInfo.FirmwareVersion]);
var sensors = dev.QuerySensors();
var depthSensor = sensors[0];
var colorSensor = sensors[1];
var depthProfiles = depthSensor.StreamProfiles
.Where(p => p.Stream == Stream.Depth)
.OrderBy(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>());
VideoStreamProfile colorProfile = null;
// select color profile to have frameset equal or closer to depth frameset to syncer work smooth
foreach (var depthProfile in depthProfiles)
{
depthWidth = depthProfile.Width;
depthHeight = depthProfile.Height;
depthFrames = depthProfile.Framerate;
depthFormat = depthProfile.Format;
colorProfile = colorSensor.StreamProfiles
.Where(p => p.Stream == Stream.Color)
.OrderByDescending(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>())
.FirstOrDefault(p => p.Framerate == depthFrames);
if (colorProfile != null)
{
colorWidth = colorProfile.Width;
colorHeight = colorProfile.Height;
colorFrames = colorProfile.Framerate;
break;
}
}
if (colorProfile == null)
{
// if no profile with the same framerate found, takes the first
colorProfile = colorSensor.StreamProfiles
.Where(p => p.Stream == Stream.Color)
.OrderByDescending(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>()).FirstOrDefault();
if (colorProfile == null)
{
throw new InvalidOperationException($"Error while finding appropriate depth and color profiles");
}
colorWidth = colorProfile.Width;
colorHeight = colorProfile.Height;
colorFrames = colorProfile.Framerate;
}
}
var cfg = new Config();
cfg.EnableStream(Stream.Depth, depthWidth, depthHeight, depthFormat, depthFrames);
cfg.EnableStream(Stream.Color, colorWidth, colorHeight, Format.Rgb8, colorFrames);
var profile = pipeline.Start(cfg);
SetupWindow(profile, out updateDepth, out updateColor);
// Setup the SW device and sensors
var software_dev = new SoftwareDevice();
var depth_sensor = software_dev.AddSensor("Depth");
var depth_profile = depth_sensor.AddVideoStream(new SoftwareVideoStream
{
type = Stream.Depth,
index = 0,
uid = 100,
width = depthWidth,
height = depthHeight,
fps = depthFrames,
bpp = 2,
format = depthFormat,
intrinsics = profile.GetStream(Stream.Depth).As <VideoStreamProfile>().GetIntrinsics()
});
depth_sensor.AddReadOnlyOption(Option.DepthUnits, 1.0f / 5000);
var color_sensor = software_dev.AddSensor("Color");
var color_profile = color_sensor.AddVideoStream(new SoftwareVideoStream
{
type = Stream.Color,
index = 0,
uid = 101,
width = colorWidth,
height = colorHeight,
fps = colorFrames,
bpp = 3,
format = Format.Rgb8,
intrinsics = profile.GetStream(Stream.Color).As <VideoStreamProfile>().GetIntrinsics()
});
// Note about the Syncer: If actual FPS is significantly different from reported FPS in AddVideoStream
// this can confuse the syncer and prevent it from producing synchronized pairs
software_dev.SetMatcher(Matchers.Default);
var sync = new Syncer();
// The raw depth->metric units translation scale is required for Colorizer to work
var realDepthSensor = profile.Device.QuerySensors().First(s => s.Is(Extension.DepthSensor));
depth_sensor.AddReadOnlyOption(Option.DepthUnits, realDepthSensor.DepthScale);
depth_sensor.Open(depth_profile);
color_sensor.Open(color_profile);
// Push the SW device frames to the syncer
depth_sensor.Start(sync.SubmitFrame);
color_sensor.Start(sync.SubmitFrame);
var token = tokenSource.Token;
ushort[] depthData = null;
byte[] colorData = null;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
// We use the frames that are captured from live camera as the input data for the SW device
using (var frames = pipeline.WaitForFrames())
{
var depthFrame = frames.DepthFrame.DisposeWith(frames);
var colorFrame = frames.ColorFrame.DisposeWith(frames);
depthData = depthData ?? new ushort[depthFrame.Width * depthFrame.Height];
depthFrame.CopyTo(depthData);
depth_sensor.AddVideoFrame(depthData, depthFrame.Stride, depthFrame.BitsPerPixel / 8, depthFrame.Timestamp,
depthFrame.TimestampDomain, (int)depthFrame.Number, depth_profile);
colorData = colorData ?? new byte[colorFrame.Stride * colorFrame.Height];
colorFrame.CopyTo(colorData);
color_sensor.AddVideoFrame(colorData, colorFrame.Stride, colorFrame.BitsPerPixel / 8, colorFrame.Timestamp,
colorFrame.TimestampDomain, (int)colorFrame.Number, color_profile);
}
// Dispaly the frames that come from the SW device after synchronization
using (var new_frames = sync.WaitForFrames())
{
if (new_frames.Count == 2)
{
var colorFrame = new_frames.ColorFrame.DisposeWith(new_frames);
var depthFrame = new_frames.DepthFrame.DisposeWith(new_frames);
var colorizedDepth = colorizer.Process <VideoFrame>(depthFrame).DisposeWith(new_frames);
// Render the frames.
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
}
}
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
/**
* NOTES
* Curently it records immediately after linking the program with LabStreamLayer.
* There might be a better solution, but we don't want to increase the number of button presses for the protoccol. It is probably better to record more than to forget pressing
* the record button before an experiment.
*
* **/
// Code Taken Directly from the LibRealSense 2 Examples -- Captures and Displays Depth and RGB Camera.
private void startRecordingProcess()
{
try
{
pipeline = new Pipeline();
colorizer = new Colorizer();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480, Format.Z16, 30);
cfg.EnableStream(Stream.Color, 640, 480, Format.Bgr8, 30);
//cfg.EnableRecordToFile(fileRecording); // This is now taken care of by FFMPEG
pipeline.Start(cfg);
applyRecordingConfig();
processBlock = new CustomProcessingBlock((f, src) =>
{
using (var releaser = new FramesReleaser())
{
var frames = FrameSet.FromFrame(f, releaser);
VideoFrame depth = FramesReleaser.ScopedReturn(releaser, frames.DepthFrame);
VideoFrame color = FramesReleaser.ScopedReturn(releaser, frames.ColorFrame);
var res = src.AllocateCompositeFrame(releaser, depth, color);
src.FramesReady(res);
}
});
processBlock.Start(f =>
{
using (var releaser = new FramesReleaser())
{
var frames = FrameSet.FromFrame(f, releaser);
var depth_frame = FramesReleaser.ScopedReturn(releaser, frames.DepthFrame);
var color_frame = FramesReleaser.ScopedReturn(releaser, frames.ColorFrame);
var colorized_depth = colorizer.Colorize(depth_frame);
UploadImage(imgDepth, colorized_depth);
UploadImage(imgColor, color_frame);
// Record FFMPEG
Bitmap bmpColor = new Bitmap(color_frame.Width, color_frame.Height, color_frame.Stride, System.Drawing.Imaging.PixelFormat.Format24bppRgb, color_frame.Data);
vidWriter_Color.WriteVideoFrame(bmpColor);
Bitmap bmpDepth = new Bitmap(colorized_depth.Width, colorized_depth.Height, colorized_depth.Stride, System.Drawing.Imaging.PixelFormat.Format24bppRgb, colorized_depth.Data);
vidWriter_Depth.WriteVideoFrame(bmpDepth);
if (lslOutlet != null)
{
// Do LSL Streaming Here
sample[0] = "" + colorized_depth.Number + "_" + colorized_depth.Timestamp;
sample[1] = "" + color_frame.Number + "_" + color_frame.Timestamp;
lslOutlet.push_sample(sample, liblsl.local_clock());
}
}
});
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
// Main Loop --
while (!token.IsCancellationRequested)
{
using (var frames = pipeline.WaitForFrames())
{
processBlock.ProcessFrames(frames);
}
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
public CaptureWindow()
{
InitializeComponent();
try
{
Action <VideoFrame> updateDepth;
Action <VideoFrame> updateColor;
pipeline = new Pipeline();
colorizer = new Colorizer();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480, Format.Z16, 30);
cfg.EnableStream(Stream.Color, 640, 480, Format.Rgb8, 30);
var profile = pipeline.Start(cfg);
SetupWindow(profile, out updateDepth, out updateColor);
// Setup the SW device and sensors
var software_dev = new SoftwareDevice();
var depth_sensor = software_dev.AddSensor("Depth");
var depth_profile = depth_sensor.AddVideoStream(new SoftwareVideoStream
{
type = Stream.Depth,
index = 0,
uid = 100,
width = 640,
height = 480,
fps = 30,
bpp = 2,
format = Format.Z16,
intrinsics = profile.GetStream(Stream.Depth).As <VideoStreamProfile>().GetIntrinsics()
});
var color_sensor = software_dev.AddSensor("Color");
var color_profile = color_sensor.AddVideoStream(new SoftwareVideoStream
{
type = Stream.Color,
index = 0,
uid = 101,
width = 640,
height = 480,
fps = 30,
bpp = 3,
format = Format.Rgb8,
intrinsics = profile.GetStream(Stream.Color).As <VideoStreamProfile>().GetIntrinsics()
});
// Note about the Syncer: If actual FPS is significantly different from reported FPS in AddVideoStream
// this can confuse the syncer and prevent it from producing synchronized pairs
software_dev.SetMatcher(Matchers.Default);
var sync = new Syncer();
depth_sensor.Open(depth_profile);
color_sensor.Open(color_profile);
// Push the SW device frames to the syncer
depth_sensor.Start(sync.SubmitFrame);
color_sensor.Start(sync.SubmitFrame);
var token = tokenSource.Token;
ushort[] depthData = null;
byte[] colorData = null;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
// We use the frames that are captured from live camera as the input data for the SW device
using (var frames = pipeline.WaitForFrames())
{
var depthFrame = frames.DepthFrame.DisposeWith(frames);
var colorFrame = frames.ColorFrame.DisposeWith(frames);
depthData = depthData ?? new ushort[depthFrame.Width * depthFrame.Height];
depthFrame.CopyTo(depthData);
depth_sensor.AddVideoFrame(depthData, depthFrame.Stride, depthFrame.BitsPerPixel / 8, depthFrame.Timestamp,
depthFrame.TimestampDomain, (int)depthFrame.Number, depth_profile);
colorData = colorData ?? new byte[colorFrame.Stride * colorFrame.Height];
colorFrame.CopyTo(colorData);
color_sensor.AddVideoFrame(colorData, colorFrame.Stride, colorFrame.BitsPerPixel / 8, colorFrame.Timestamp,
colorFrame.TimestampDomain, (int)colorFrame.Number, color_profile);
}
// Dispaly the frames that come from the SW device after synchronization
using (var new_frames = sync.WaitForFrames())
{
if (new_frames.Count == 2)
{
var depthFrame = new_frames.DepthFrame.DisposeWith(new_frames);
var colorFrame = new_frames.ColorFrame.DisposeWith(new_frames);
VideoFrame colorizedDepth = colorizer.Process(depthFrame).As <VideoFrame>().DisposeWith(new_frames);
// Render the frames.
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
}
}
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
public CaptureWindow()
{
InitializeComponent();
try
{
Action <VideoFrame> updateDepth;
Action <VideoFrame> updateColor;
// The colorizer processing block will be used to visualize the depth frames.
colorizer = new Colorizer();
// Create and config the pipeline to strem color and depth frames.
pipeline = new Pipeline();
var cfg = new Config();
using (var ctx = new Context())
{
var devices = ctx.QueryDevices();
if ((devices.Count != 1) || (!ExampleAutocalibrateDevice.IsTheDeviceD400Series(devices[0])))
{
Console.WriteLine("The tutorial {0} requires a single Realsense D400 device to run.\nFix the setup and rerun",
System.Diagnostics.Process.GetCurrentProcess().ProcessName);
Environment.Exit(1);
}
var dev = devices[0];
Console.WriteLine("Using device 0, an {0}", dev.Info[CameraInfo.Name]);
Console.WriteLine(" Serial number: {0}", dev.Info[CameraInfo.SerialNumber]);
Console.WriteLine(" Firmware version: {0}", dev.Info[CameraInfo.FirmwareVersion]);
var sensors = dev.QuerySensors();
var depthProfile = sensors
.SelectMany(s => s.StreamProfiles)
.Where(sp => sp.Stream == Stream.Depth)
.Select(sp => sp.As <VideoStreamProfile>())
.OrderBy(p => p.Framerate)
.First();
var colorProfile = sensors
.SelectMany(s => s.StreamProfiles)
.Where(sp => sp.Stream == Stream.Color)
.Select(sp => sp.As <VideoStreamProfile>())
.OrderBy(p => p.Framerate)
.First();
cfg.EnableDevice(dev.Info[CameraInfo.SerialNumber]);
cfg.EnableStream(Stream.Depth, depthProfile.Width, depthProfile.Height, depthProfile.Format, depthProfile.Framerate);
cfg.EnableStream(Stream.Color, colorProfile.Width, colorProfile.Height, colorProfile.Format, colorProfile.Framerate);
var pp = pipeline.Start(cfg);
SetupWindow(pp, out updateDepth, out updateColor);
}
// Rendering task
var renderingPause = false;
var rendering = Task.Factory.StartNew(() =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
if (renderingPause)
{
continue; //pause the rendering
}
// We wait for the next available FrameSet and using it as a releaser object that would track
// all newly allocated .NET frames, and ensure deterministic finalization
// at the end of scope.
using (var frames = pipeline.WaitForFrames())
{
var colorFrame = frames.ColorFrame.DisposeWith(frames);
var depthFrame = frames.DepthFrame.DisposeWith(frames);
// Render the frames.
if (depthFrame != null)
{
// We colorize the depth frame for visualization purposes
var colorizedDepth = colorizer.Process <VideoFrame>(depthFrame).DisposeWith(frames);
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
}
if (colorFrame != null)
{
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
}
if (depthFrame != null)
{
Dispatcher.Invoke(new Action(() =>
{
String depth_dev_sn = depthFrame.Sensor.Info[CameraInfo.SerialNumber];
txtTimeStamp.Text = $"{depth_dev_sn} : {depthFrame.Timestamp,-20:0.00}({depthFrame.TimestampDomain})" +
$"{Environment.NewLine}To start Auto-Calibration flow, switch focus to the application console and press C";
}));
}
}
}
}, tokenSource.Token);
// Input to calibration mode task
Task.Factory.StartNew(() =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
if (ConsoleKey.C == ExampleAutocalibrateDevice.ConsoleGetKey(new[] { ConsoleKey.C },
"To start Auto-Calibration flow, switch focus to the application console and press C"))
{
renderingPause = true;
Console.WriteLine($"{Environment.NewLine}Stopping rendering pipeline...");
pipeline.Stop();
new ExampleAutocalibrateDevice().Start();
Console.WriteLine($"{Environment.NewLine}Starting rendering pipeline...");
pipeline.Start(cfg);
renderingPause = false;
}
}
}, tokenSource.Token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
public CaptureWindow()
{
InitializeComponent();
try
{
Action <VideoFrame> updateDepth;
Action <VideoFrame> updateColor;
// The colorizer processing block will be used to visualize the depth frames.
colorizer = new Colorizer();
// Create and config the pipeline to strem color and depth frames.
pipeline = new Pipeline();
using (var ctx = new Context())
{
var devices = ctx.QueryDevices();
var dev = devices[0];
Console.WriteLine("\nUsing device 0, an {0}", dev.Info[CameraInfo.Name]);
Console.WriteLine(" Serial number: {0}", dev.Info[CameraInfo.SerialNumber]);
Console.WriteLine(" Firmware version: {0}", dev.Info[CameraInfo.FirmwareVersion]);
var sensors = dev.QuerySensors();
var depthSensor = sensors[0];
var colorSensor = sensors[1];
var depthProfile = depthSensor.StreamProfiles
.Where(p => p.Stream == Stream.Depth)
.OrderBy(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>()).First();
var colorProfile = colorSensor.StreamProfiles
.Where(p => p.Stream == Stream.Color)
.OrderBy(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>()).First();
if (!testLoadSettingsJson.LoadSettingsJson(dev))
{
return;
}
var cfg = new Config();
cfg.EnableDevice(dev.Info.GetInfo(CameraInfo.SerialNumber));
cfg.EnableStream(Stream.Depth, depthProfile.Width, depthProfile.Height, depthProfile.Format, depthProfile.Framerate);
cfg.EnableStream(Stream.Color, colorProfile.Width, colorProfile.Height, colorProfile.Format, colorProfile.Framerate);
var pp = pipeline.Start(cfg);
SetupWindow(pp, out updateDepth, out updateColor);
// more device info
Console.WriteLine($"--------------------------");
foreach (var item in pp.Device.Info.ToArray())
{
Console.WriteLine($"{item.Key} - {item.Value}");
}
Console.WriteLine($"--------------------------");
}
Task.Factory.StartNew(() =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
// We wait for the next available FrameSet and using it as a releaser object that would track
// all newly allocated .NET frames, and ensure deterministic finalization
// at the end of scope.
using (var frames = pipeline.WaitForFrames())
{
var colorFrame = frames.ColorFrame.DisposeWith(frames);
var depthFrame = frames.DepthFrame.DisposeWith(frames);
// We colorize the depth frame for visualization purposes
var colorizedDepth = colorizer.Process <VideoFrame>(depthFrame).DisposeWith(frames);
// Render the frames.
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
Dispatcher.Invoke(new Action(() =>
{
String depth_dev_sn = depthFrame.Sensor.Info[CameraInfo.SerialNumber];
txtTimeStamp.Text = depth_dev_sn + " : " + String.Format("{0,-20:0.00}", depthFrame.Timestamp) + "(" + depthFrame.TimestampDomain.ToString() + ")";
}));
}
}
}, tokenSource.Token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
}
public ProcessingWindow()
{
InitializeComponent();
try
{
var cfg = new Config();
using (var ctx = new Context())
{
var devices = ctx.QueryDevices();
var dev = devices[0];
Console.WriteLine("\nUsing device 0, an {0}", dev.Info[CameraInfo.Name]);
Console.WriteLine(" Serial number: {0}", dev.Info[CameraInfo.SerialNumber]);
Console.WriteLine(" Firmware version: {0}", dev.Info[CameraInfo.FirmwareVersion]);
var sensors = dev.QuerySensors();
var depthSensor = sensors[0];
var colorSensor = sensors[1];
var depthProfile = depthSensor.StreamProfiles
.Where(p => p.Stream == Stream.Depth)
.OrderBy(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>()).First();
var colorProfile = colorSensor.StreamProfiles
.Where(p => p.Stream == Stream.Color)
.OrderBy(p => p.Framerate)
.Select(p => p.As <VideoStreamProfile>()).First();
cfg.EnableStream(Stream.Depth, depthProfile.Width, depthProfile.Height, depthProfile.Format, depthProfile.Framerate);
cfg.EnableStream(Stream.Color, colorProfile.Width, colorProfile.Height, colorProfile.Format, colorProfile.Framerate);
}
var pp = pipeline.Start(cfg);
// Get the recommended processing blocks for the depth sensor
var sensor = pp.Device.QuerySensors().First(s => s.Is(Extension.DepthSensor));
var blocks = sensor.ProcessingBlocks.ToList();
// Allocate bitmaps for rendring.
// Since the sample aligns the depth frames to the color frames, both of the images will have the color resolution
using (var p = pp.GetStream(Stream.Color).As <VideoStreamProfile>())
{
imgColor.Source = new WriteableBitmap(p.Width, p.Height, 96d, 96d, PixelFormats.Rgb24, null);
imgDepth.Source = new WriteableBitmap(p.Width, p.Height, 96d, 96d, PixelFormats.Rgb24, null);
}
var updateColor = UpdateImage(imgColor);
var updateDepth = UpdateImage(imgDepth);
// Create custom processing block
// For demonstration purposes it will:
// a. Get a frameset
// b. Run post-processing on the depth frame
// c. Combine the result back into a frameset
// Processing blocks are inherently thread-safe and play well with
// other API primitives such as frame-queues,
// and can be used to encapsulate advanced operations.
// All invocations are, however, synchronious so the high-level threading model
// is up to the developer
block = new CustomProcessingBlock((f, src) =>
{
// We create a FrameReleaser object that would track
// all newly allocated .NET frames, and ensure deterministic finalization
// at the end of scope.
using (var releaser = new FramesReleaser())
{
foreach (ProcessingBlock p in blocks)
{
f = p.Process(f).DisposeWith(releaser);
}
f = f.ApplyFilter(align).DisposeWith(releaser);
f = f.ApplyFilter(colorizer).DisposeWith(releaser);
var frames = f.As <FrameSet>().DisposeWith(releaser);
var colorFrame = frames[Stream.Color, Format.Rgb8].DisposeWith(releaser);
var colorizedDepth = frames[Stream.Depth, Format.Rgb8].DisposeWith(releaser);
// Combine the frames into a single result
var res = src.AllocateCompositeFrame(colorizedDepth, colorFrame).DisposeWith(releaser);
// Send it to the next processing stage
src.FrameReady(res);
}
});
// Register to results of processing via a callback:
block.Start(f =>
{
using (var frames = f.As <FrameSet>())
{
var colorFrame = frames.ColorFrame.DisposeWith(frames);
var colorizedDepth = frames.First <VideoFrame>(Stream.Depth, Format.Rgb8).DisposeWith(frames);
Dispatcher.Invoke(DispatcherPriority.Render, updateDepth, colorizedDepth);
Dispatcher.Invoke(DispatcherPriority.Render, updateColor, colorFrame);
}
});
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
using (var frames = pipeline.WaitForFrames())
{
// Invoke custom processing block
block.Process(frames);
}
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}
public CaptureWindow()
{
//Log.ToFile(LogSeverity.Debug, "1.log");
try
{
pipeline = new Pipeline();
colorizer = new Colorizer();
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480, Format.Z16, 30);
cfg.EnableStream(Stream.Color, 640, 480, Format.Rgb8, 30);
var profile = pipeline.Start(cfg);
var software_dev = new SoftwareDevice();
var depth_sensor = software_dev.AddSensor("Depth");
var depth_profile = depth_sensor.AddVideoStream(new VideoStream
{
type = Stream.Depth,
index = 0,
uid = 100,
width = 640,
height = 480,
fps = 30,
bpp = 2,
fmt = Format.Z16,
intrinsics = (profile.GetStream(Stream.Depth) as VideoStreamProfile).GetIntrinsics()
});
var color_sensor = software_dev.AddSensor("Color");
var color_profile = color_sensor.AddVideoStream(new VideoStream
{
type = Stream.Color,
index = 0,
uid = 101,
width = 640,
height = 480,
fps = 30,
bpp = 2,
fmt = Format.Z16,
intrinsics = (profile.GetStream(Stream.Color) as VideoStreamProfile).GetIntrinsics()
});
// Note about the Syncer: If actual FPS is significantly different from reported FPS in AddVideoStream
// this can confuse the syncer and prevent it from producing synchronized pairs
software_dev.SetMatcher(Matchers.Default);
var sync = new Syncer();
depth_sensor.Open(depth_profile);
color_sensor.Open(color_profile);
depth_sensor.Start(f =>
{
sync.SubmitFrame(f);
//Debug.WriteLine("D");
});
color_sensor.Start(f => {
sync.SubmitFrame(f);
//Debug.WriteLine("C");
});
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
var frames = pipeline.WaitForFrames();
var depth_frame = frames.DepthFrame;
var color_frame = frames.ColorFrame;
var bytes = new byte[depth_frame.Stride * depth_frame.Height];
depth_frame.CopyTo(bytes);
depth_sensor.AddVideoFrame(bytes, depth_frame.Stride, 2, depth_frame.Timestamp,
depth_frame.TimestampDomain, (int)depth_frame.Number,
depth_profile);
bytes = new byte[color_frame.Stride * color_frame.Height];
color_frame.CopyTo(bytes);
color_sensor.AddVideoFrame(bytes, color_frame.Stride, 2, depth_frame.Timestamp,
color_frame.TimestampDomain, (int)depth_frame.Number,
color_profile);
depth_frame.Dispose();
color_frame.Dispose();
frames.Dispose();
var new_frames = sync.WaitForFrames();
if (new_frames.Count == 2)
{
depth_frame = new_frames.DepthFrame;
color_frame = new_frames.ColorFrame;
var colorized_depth = colorizer.Colorize(depth_frame);
UploadImage(imgDepth, colorized_depth);
UploadImage(imgColor, color_frame);
depth_frame.Dispose();
colorized_depth.Dispose();
color_frame.Dispose();
}
new_frames.Dispose();
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}
public ProcessingWindow()
{
try
{
var cfg = new Config();
cfg.EnableStream(Stream.Depth, 640, 480);
cfg.EnableStream(Stream.Color, Format.Rgb8);
pipeline.Start(cfg);
// Create custom processing block
// For demonstration purposes it will:
// a. Get a frameset
// b. Break it down to frames
// c. Run post-processing on the depth frame
// d. Combine the result back into a frameset
// Processing blocks are inherently thread-safe and play well with
// other API primitives such as frame-queues,
// and can be used to encapsulate advanced operations.
// All invokations are, however, synchronious so the high-level threading model
// is up to the developer
block = new CustomProcessingBlock((f, src) =>
{
// We create a FrameReleaser object that would track
// all newly allocated .NET frames, and ensure deterministic finalization
// at the end of scope.
using (var releaser = new FramesReleaser())
{
var frames = FrameSet.FromFrame(f, releaser);
VideoFrame depth = FramesReleaser.ScopedReturn(releaser, frames.DepthFrame);
VideoFrame color = FramesReleaser.ScopedReturn(releaser, frames.ColorFrame);
// Apply depth post-processing
depth = decimate.ApplyFilter(depth, releaser);
depth = spatial.ApplyFilter(depth, releaser);
depth = temp.ApplyFilter(depth, releaser);
// Combine the frames into a single result
var res = src.AllocateCompositeFrame(releaser, depth, color);
// Send it to the next processing stage
src.FramesReady(res);
}
});
// Register to results of processing via a callback:
block.Start(f =>
{
using (var releaser = new FramesReleaser())
{
// Align, colorize and upload frames for rendering
var frames = FrameSet.FromFrame(f, releaser);
// Align both frames to the viewport of color camera
frames = align.Process(frames, releaser);
var depth_frame = FramesReleaser.ScopedReturn(releaser, frames.DepthFrame);
var color_frame = FramesReleaser.ScopedReturn(releaser, frames.ColorFrame);
UploadImage(imgDepth, colorizer.Colorize(depth_frame, releaser));
UploadImage(imgColor, color_frame);
}
});
var token = tokenSource.Token;
var t = Task.Factory.StartNew(() =>
{
while (!token.IsCancellationRequested)
{
using (var frames = pipeline.WaitForFrames())
{
// Invoke custom processing block
block.ProcessFrames(frames);
}
}
}, token);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
Application.Current.Shutdown();
}
InitializeComponent();
}