Kinect Fusion Basics-WPF C# Sample代码解析
各位博友，这是我第一次写技术博客，有编辑方面的不足或者技术方面不足的，请诸位谅解。
本人这段时间，一直研读微软SDK官方样例kinect fusion代码，总体理解程序流程，在这发一篇小博客供大家交流学习。由于工程代码较长，所以本人打算直接copy代码，但加上自己理解注释，希望同该方向研究的人有所借鉴。
///<summary>
/// 该程序是基于CSharp的WPF编程，是基于事件触发的，程序主要事件有WindowLoaded,ProcessDepthData,
/// ResetReconstruction，SensorDepthFrameReady,FpsTimerTick.编程思想为:窗口初始化时候,便会调
/// 用WindowLoaded进行一些类成员 变量的初始化,并设置了时钟,最后ResetReconstruction了一下，
/// 激活kinect进行数据捕获。帧会更新,更新会触发事件SensorDepthFrameReady,由其中
/// ProcessDepthData处理深度数据并负责深度图的显示,当跟踪错误次数超过默认的
/// 次数之后,便会调用ResetReconstruction一下。直到WindowClosing之后才关闭应用。
/// </summary>
namespace Microsoft.Samples.Kinect.KinectFusionBasics
{
using System;
using System.Diagnostics;
using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Microsoft.Kinect;
using Microsoft.Kinect.Toolkit.Fusion;
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window, IDisposable
{
/// <summary>
/// Max tracking error count, we will reset the reconstruction if tracking errors
/// reach this number
/// </summary>
///最大跟踪错误数目
private const int MaxTrackingErrors = 100;
/// <summary>
/// If set true, will automatically reset the reconstruction when MaxTrackingErrors have occurred
/// </summary>
/// 最大跟踪错误之后，如果该变量为true，则自动更新reconstruction
///在ProcessDepthData中调用
private const bool AutoResetReconstructionWhenLost = false;
/// <summary>
/// The resolution of the depth image to be processed.
/// </summary>
/// DepthImageFormat是一个枚举类型，有Undefined, Resolution640x480Fps30, Resolution320x240Fps30,Resolution80x60Fps30,
private const DepthImageFormat DepthImageResolution = DepthImageFormat.Resolution640x480Fps30;
/// <summary>
/// The seconds interval to calculate FPS
/// </summary>
private const int FpsInterval = 10;
///<summary>
/// 调整以下几个变量，可以改变成像立方体的大小，也就可以改变重建范围
/// </summary>
///
/// <summary>
/// The reconstruction volume voxel density in voxels per meter (vpm)
/// vpm表示每米有多少个voxel，是一种密度
/// 1000mm / 256vpm = ~3.9mm/voxel
/// </summary>
/// 方块立体单元
private const int VoxelsPerMeter = 256;
/// <summary>
/// The reconstruction volume voxel resolution in the X axis
/// At a setting of 256vpm the volume is 512 / 256 = 2m wide
/// </summary>
/// X方向的像素总长度
private const int VoxelResolutionX = 512;
/// <summary>
/// The reconstruction volume voxel resolution in the Y axis
/// At a setting of 256vpm the volume is 384 / 256 = 1.5m high
/// </summary>
/// Y方向总长度
private const int VoxelResolutionY = 384;
/// <summary>
/// The reconstruction volume voxel resolution in the Z axis
/// At a setting of 256vpm the volume is 512 / 256 = 2m deep
/// </summary>
private const int VoxelResolutionZ = 512;
/// <summary>
/// The reconstruction volume processor type. This parameter sets whether AMP or CPU processing
/// is used. Note that CPU processing will likely be too slow for real-time processing.
/// </summary>
/// 重建处理器类型，是CPU重建还是AMP重建（GPU实时重建）
private const ReconstructionProcessor ProcessorType = ReconstructionProcessor.Amp;
/// <summary>
/// The zero-based device index to choose for reconstruction processing if the
/// ReconstructionProcessor AMP options are selected.
/// Here we automatically choose a device to use for processing by passing -1,
/// </summary>
private const int DeviceToUse = -1;
/// <summary>
/// Parameter to translate the reconstruction based on the minimum depth setting. When set to
/// false, the reconstruction volume +Z axis starts at the camera lens and extends into the scene.
/// Setting this true in the constructor will move the volume forward along +Z away from the
/// camera by the minimum depth threshold to enable capture of very small reconstruction volumes
/// by setting a non-identity world-volume transformation in the ResetReconstruction call.
/// Small volumes should be shifted, as the Kinect hardware has a minimum sensing limit of ~0.35m,
/// inside which no valid depth is returned, hence it is difficult to initialize and track robustly
/// when the majority of a small volume is inside this distance.
/// </summary>
private bool translateResetPoseByMinDepthThreshold = true;
/// <summary>
/// Minimum depth distance threshold in meters. Depth pixels below this value will be
/// returned as invalid (0). Min depth must be positive or 0.
/// </summary>
/// DefaultMinimumDepth=0.5f，Min depth为正数
private float minDepthClip = FusionDepthProcessor.DefaultMinimumDepth;
/// <summary>
/// Maximum depth distance threshold in meters. Depth pixels above this value will be
/// returned as invalid (0). Max depth must be greater than 0.
/// </summary>
/// DefaultMaximumDepth=8.0f
private float maxDepthClip = FusionDepthProcessor.DefaultMaximumDepth;
/// <summary>
/// Active Kinect sensor
/// </summary>
private KinectSensor sensor;
/// <summary>
/// Bitmap that will hold color information
/// </summary>
/// 在WindowLoaded中赋值，并在在其中绑定Image控件
private WriteableBitmap colorBitmap;
/// <summary>
/// Intermediate storage for the depth data converted to color
/// </summary>
/// 缓存，用于保存转化为颜色值的深度数据
private int[] colorPixels;
/// <summary>
/// Intermediate storage for the depth float data converted from depth image frame
/// </summary>
/// 从深度帧转化的浮点型深度数据
private FusionFloatImageFrame depthFloatBuffer;
/// <summary>
/// Intermediate storage for the point cloud data converted from depth float image frame
/// </summary>
/// 从深度帧转化而来的点云数据
private FusionPointCloudImageFrame pointCloudBuffer;
/// <summary>
/// Raycast shaded surface image
/// </summary>
private FusionColorImageFrame shadedSurfaceColorFrame;
/// <summary>
/// The transformation between the world and camera view coordinate system
/// </summary>
/// 变换矩阵
private Matrix4 worldToCameraTransform;
/// <summary>
/// The default transformation between the world and volume coordinate system
/// </summary>
private Matrix4 defaultWorldToVolumeTransform;
/// <summary>
/// The Kinect Fusion volume
/// </summary>
private Reconstruction volume;
/// <summary>
/// The timer to calculate FPS
/// </summary>
/// System.Windows.Threading命名空间，计时器
/// 帧率 = processedFrameCount / FpsInterval
private DispatcherTimer fpsTimer;
/// <summary>
/// The count of the frames processed in the FPS interval
/// </summary>
/// 在采集间隔（FpsInterval=10）内，处理帧的数目
private int processedFrameCount;
/// <summary>
/// The tracking error count
/// </summary>
/// 用于保存连续跟踪错误次数
private int trackingErrorCount;
/// <summary>
/// The sensor depth frame data length
/// </summary>
private int frameDataLength;
/// <summary>
/// wether the depth frames to be processed
/// </summary>
private bool processingFrame;
/// <summary>
/// Track whether Dispose has been called
/// </summary>
private bool disposed;
/// <summary>
/// Initializes a new instance of the MainWindow class.
/// </summary>
public MainWindow()
{
this.InitializeComponent();
}
/// <summary>
/// Finalizes an instance of the MainWindow class.
/// This destructor will run only if the Dispose method does not get called.
/// </summary>
~MainWindow()
{
this.Dispose(false);
}
/// <summary>
/// Get the image size of fusion images and bitmap.
/// </summary>
/// 返回深度图像的大小，DepthImageResolution为上面全局变量设置，该变量ImageSize为结构体变量，可以直接调用
public static Size ImageSize
{
get
{//GetImageSize函数为私有定义函数，在以下有定义
//DepthImageResolution=DepthImageFormat.Resolution640x480Fps30;则返回Size(640,480)
return GetImageSize(DepthImageResolution);
}
}
/// <summary>
/// Dispose the allocated frame buffers and reconstruction.
/// </summary>
/// 内存释放函数，和Dispose(bool disposing)结合使用
public void Dispose()
{
this.Dispose(true);
// This object will be cleaned up by the Dispose method.
GC.SuppressFinalize(this);
}
/// <summary>
/// Frees all memory associated with the FusionImageFrame.
/// </summary>
/// <param name="disposing">Whether the function was called from Dispose.</param>
/// 内存释放函数
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (null != this.depthFloatBuffer)
{//depthFloatBuffer为深度数据缓冲储存区
this.depthFloatBuffer.Dispose();
}
if (null != this.pointCloudBuffer)
{
this.pointCloudBuffer.Dispose();
}
if (null != this.shadedSurfaceColorFrame)
{
this.shadedSurfaceColorFrame.Dispose();
}
if (null != this.volume)
{
this.volume.Dispose();
}
this.disposed = true;
}
}
/// <summary>
/// Get the depth image size from the input depth image format.
/// </summary>
/// <param name="imageFormat">The depth image format.</param>
/// <returns>The widht and height of the input depth image format.</returns>
/// 在ImageSize被调用
/// 输入深度图像的格式
private static Size GetImageSize(DepthImageFormat imageFormat)
{
switch (imageFormat)
{
case DepthImageFormat.Resolution320x240Fps30:
return new Size(320, 240);
case DepthImageFormat.Resolution640x480Fps30:
return new Size(640, 480);
case DepthImageFormat.Resolution80x60Fps30:
return new Size(80, 60);
}
throw new ArgumentOutOfRangeException("imageFormat");
}
/// <summary>
/// Execute startup tasks
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
/// WPF窗口初始化加载函数
/// 初始化了sensor和fpsTimer两个变量
private void WindowLoaded(object sender, RoutedEventArgs e)
{
// Look through all sensors and start the first connected one.
// This requires that a Kinect is connected at the time of app startup.
// To make your app robust against plug/unplug,
// it is recommended to use KinectSensorChooser provided in Microsoft.Kinect.Toolkit
//功能：遍历所有kinect sensors并开始第一个连接上的kinect
//这个函数要求在app启动之前至少要有一个kinect接入电脑
//.............
//要求必须使用Microsoft.Kinect.Toolkit中的KinectSensorChooser进行编程
//KinectSensor.KinectSensors返回一个kinect设备数组
//该循环功能为了找出具备能力的kinect设备
foreach (var potentialSensor in KinectSensor.KinectSensors)
{
if (potentialSensor.Status == KinectStatus.Connected)
{//sensor为全局变量，表示该kinect
this.sensor = potentialSensor;
break;
}
}
//如果没有可以使用的kinect sensor，则退出窗口初始化
if (null == this.sensor)
{//statusBarText为窗口提示栏名，跟踪之后，在状态栏中输出字符串“NoKinectReady”
this.statusBarText.Text = Properties.Resources.NoKinectReady;
return;
}
// Turn on the depth stream to receive depth frames
//打开深度流以接收深度数据
//Enable()为Overloaded. Methods for enabling a sensor to stream out depth data.
//DepthImageStream.Enable ()为默认格式DepthImageFormat.Resolution640x480Fps30.
this.sensor.DepthStream.Enable(DepthImageResolution);
//frameDataLength为深度数据总长度
this.frameDataLength = this.sensor.DepthStream.FramePixelDataLength;
// Allocate space to put the color pixels we‘ll create
this.colorPixels = new int[this.frameDataLength];
// This is the bitmap we‘ll display on-screen
//C#函数： WriteableBitmap(int pixelWidth, int pixelHeight,
//double dpiX, double dpiY, PixelFormat pixelFormat, BitmapPalette palette);
this.colorBitmap = new WriteableBitmap(
(int)ImageSize.Width,
(int)ImageSize.Height,
96.0,//起点X坐标
96.0,//起点Y坐标
PixelFormats.Bgr32,//图片格式
null);//画板对象
// Set the image we display to point to the bitmap where we‘ll put the image data
//Image为图片控件名
this.Image.Source = this.colorBitmap;
// Add an event handler to be called whenever there is new depth frame data
//SensorDepthFrameReady为深度帧数据更新的处理函数，也是大的处理框架
//即下一帧深度准备好时候，就调用SensorDepthFrameReady更新数据
this.sensor.DepthFrameReady += this.SensorDepthFrameReady;
//VoxelsPerMeter = 256; X:2m Y:1.5m高 Z:2m深
//volParam为Voxel重建的参数实例对象，用于保存重建参数
var volParam = new ReconstructionParameters(VoxelsPerMeter, VoxelResolutionX, VoxelResolutionY, VoxelResolutionZ);
// Set the world-view transform to identity, so the world origin is the initial camera location.
this.worldToCameraTransform = Matrix4.Identity;
try
{
// This creates a volume cube with the Kinect at center of near plane, and volume directly
// in front of Kinect.
//创建一个重建立方体
//ProcessorType = ReconstructionProcessor.Amp;GPU重建
//this.worldToCameraTransform = Matrix4.Identity;
//DeviceToUse=-1
this.volume = Reconstruction.FusionCreateReconstruction(volParam, ProcessorType, DeviceToUse, this.worldToCameraTransform);
this.defaultWorldToVolumeTransform = this.volume.GetCurrentWorldToVolumeTransform();
//this.translateResetPoseByMinDepthThreshold=true
// Setting this true in the constructor will move the volume forward along +Z away from the
// camera by the minimum depth threshold to enable capture of very small reconstruction volumes
// by setting a non-identity world-volume transformation in the ResetReconstruction call.
if (this.translateResetPoseByMinDepthThreshold)
{
//ResetReconstruction()为主要处理函数
this.ResetReconstruction();
}
}
catch (InvalidOperationException ex)
{//statusBarText为控件名字
this.statusBarText.Text = ex.Message;
return;
}
catch (DllNotFoundException)
{
this.statusBarText.Text = this.statusBarText.Text = Properties.Resources.MissingPrerequisite;
return;
}
//初始化数据空间
// Depth frames generated from the depth input
this.depthFloatBuffer = new FusionFloatImageFrame((int)ImageSize.Width, (int)ImageSize.Height);
// Point cloud frames generated from the depth float input
this.pointCloudBuffer = new FusionPointCloudImageFrame((int)ImageSize.Width, (int)ImageSize.Height);
// Create images to raycast the Reconstruction Volume
this.shadedSurfaceColorFrame = new FusionColorImageFrame((int)ImageSize.Width, (int)ImageSize.Height);
// Start the sensor!
try
{
this.sensor.Start();
}
catch (IOException ex)
{
// Device is in use
this.sensor = null;
this.statusBarText.Text = ex.Message;
return;
}
catch (InvalidOperationException ex)
{
// Device is not valid, not supported or hardware feature unavailable
this.sensor = null;
this.statusBarText.Text = ex.Message;
return;
}
// Set Near Mode by default
try
{
this.sensor.DepthStream.Range = DepthRange.Near;
checkBoxNearMode.IsChecked = true;
}
catch
{
// device not near mode capable
}
// Initialize and start the FPS timer
this.fpsTimer = new DispatcherTimer();
//FpsTimerTick为时钟处理响应函数
//private const int FpsInterval = 10
//每10s计时一次 ，并触发一次计时器，便执行FpsTimerTick
this.fpsTimer.Tick += new EventHandler(this.FpsTimerTick);
this.fpsTimer.Interval = new TimeSpan(0, 0, FpsInterval);//时，分，秒
this.fpsTimer.Start();
// Reset the reconstruction
this.ResetReconstruction();
}
/// <summary>
/// Execute shutdown tasks
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void WindowClosing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (null != this.fpsTimer)
{
this.fpsTimer.Stop();
}
if (null != this.sensor)
{
this.sensor.Stop();
}
}
/// <summary>
/// Update the FPS reading in the status text bar
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
/// 将帧率信息显示在状态栏上,买10s计算一次帧率，并实现显示在状态栏
private void FpsTimerTick(object sender, EventArgs e)
{
// Update the FPS reading
//FpsInterval=10为常数
this.statusBarText.Text = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
Properties.Resources.Fps,
(double)this.processedFrameCount / FpsInterval);
// Reset the frame count，该变量在 ProcessDepthData函数中被更新，
//当成功处理帧数据一次，就更新一次数据
this.processedFrameCount = 0;
}
/// <summary>
/// Event handler for Kinect sensor‘s DepthFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
/// 该函数为新帧准备好时被调用，在WindowLoaded函数中被声明
private void SensorDepthFrameReady(object sender, DepthImageFrameReadyEventArgs e)
{
using (DepthImageFrame depthFrame = e.OpenDepthImageFrame())
{
if (depthFrame != null && !this.processingFrame)
{
//this.frameDataLength为帧图像元素的长度,在WindowLoaded函数中被赋值
var depthPixels = new DepthImagePixel[this.frameDataLength];
// Copy the pixel data from the image to a temporary array
//从深度图中提取深度数据到暂时数组中
depthFrame.CopyDepthImagePixelDataTo(depthPixels);
this.Dispatcher.BeginInvoke(
DispatcherPriority.Background,
(Action<DepthImagePixel[]>)((d) => { this.ProcessDepthData(d); }),
depthPixels);
// Mark that one frame will be processed
//标记新的帧数据可以被处理，处理完之后，赋值为false
this.processingFrame = true;
}
}
}
/// <summary>
/// Process the depth input
/// </summary>
/// <param name="depthPixels">The depth data array to be processed</param>
/// 处理输入深度数据
/// SensorDepthFrameReady函数中，调用了ProcessDepthData函数，SensorDepthFrameReady中确定了
/// 作为参数的深度数据数组（类型DepthImagePixel）
private void ProcessDepthData(DepthImagePixel[] depthPixels)
{
//Assert检查提示，如果条件错误，就会输出提示 ，并显示一个信息框
//以下三个变量均在WindowLoaded中被赋值
Debug.Assert(null != this.volume, "volume should be initialized");
Debug.Assert(null != this.shadedSurfaceColorFrame, "shaded surface should be initialized");
Debug.Assert(null != this.colorBitmap, "color bitmap should be initialized");
//depthFloatBuffer在WindowLoaded中被声明空间，但没有储存数据
//将深度图帧转化为深度浮点数据帧
try
{
// Convert the depth image frame to depth float image frame
// Converts Kinect depth frames in unsigned short format to depth frames in float format
// representing distance from the camera in meters (parallel to the optical center axis).
FusionDepthProcessor.DepthToDepthFloatFrame(
depthPixels,//输入数据数组
(int)ImageSize.Width,
(int)ImageSize.Height,
this.depthFloatBuffer,//缓冲数据区，前13位
FusionDepthProcessor.DefaultMinimumDepth,//0.35f
FusionDepthProcessor.DefaultMaximumDepth,//8.0f
false);
//ProcessFrame函数：
//处理每一帧的函数（On_GPU）
//有两个功能：1.AlignDepthFloatToReconstruction:对其深度浮点型数据depthFloatBuffer到重建立方体当中。
//2.IntegrateFrame:使得帧融合在一起
// After this call completes, if a visible output image of the reconstruction
// is required, the user can call CalculatePointCloud and then ShadePointCloud.
// The maximum image resolution supported in this function is 640x480.
// ProcessFrame will first calculate the camera pose and then integrate
// if tracking is successful
//成功返回true，如果在对齐输入深度数据有问题时候并不能计算出有用的变换，则返回false
bool trackingSucceeded = this.volume.ProcessFrame(
this.depthFloatBuffer,//输入深度浮点数据
FusionDepthProcessor.DefaultAlignIterationCount,//最大对齐次数
FusionDepthProcessor.DefaultIntegrationWeight,//最大融合权重
this.volume.GetCurrentWorldToCameraTransform());//最新一次的变换矩阵，则需要在以下更新变化矩阵
// If camera tracking failed, no data integration or raycast for reference
// point cloud will have taken place, and the internal camera pose
// will be unchanged.
// 成功返回true，如果在对齐输入深度数据有问题时候并不能计算出有用的变换，则返回false
if (!trackingSucceeded)
{
//The tracking error count跟踪错误总次数
//用于记录连续跟踪错误次数
this.trackingErrorCount++;
// Show tracking error on status bar
this.statusBarText.Text = Properties.Resources.CameraTrackingFailed;
}
else//跟踪成功
{
Matrix4 calculatedCameraPose = this.volume.GetCurrentWorldToCameraTransform();
// Set the camera pose and reset tracking errors
this.worldToCameraTransform = calculatedCameraPose;//更新（世界坐标---相机坐标）变换矩阵
//更新该变量，新的一次相机正常tracking，则需要更新该变量
this.trackingErrorCount = 0;
}
//达到最大跟踪错误次数之后，则自动更新reconstruction
if (AutoResetReconstructionWhenLost && !trackingSucceeded && this.trackingErrorCount == MaxTrackingErrors)
{
// Auto Reset due to bad tracking
this.statusBarText.Text = Properties.Resources.ResetVolume;
// Automatically Clear Volume and reset tracking if tracking fails
this.ResetReconstruction();
}
//用于显示到Image控件上，即reconstruction如果需要显示出来，就需要计算出PointCloud和ShadePointCloud
// Calculate the point cloud
//返回3D坐标数据点和一个零交叉稠密表面的标准。保存到pointCloudBuffer中
this.volume.CalculatePointCloud(this.pointCloudBuffer, this.worldToCameraTransform);
// Shade point cloud and render
FusionDepthProcessor.ShadePointCloud(
this.pointCloudBuffer,//输入数据
this.worldToCameraTransform,
this.shadedSurfaceColorFrame,//输出数据
null);
//this.colorPixels在WindowLoaded中开辟了空间里，没有初始化数据
this.shadedSurfaceColorFrame.CopyPixelDataTo(this.colorPixels);
// Write the pixel data into our bitmap
//this.colorBitmap在WindowLoaded中开辟了空间里，没有初始化数据
this.colorBitmap.WritePixels(
new Int32Rect(0, 0, this.colorBitmap.PixelWidth, this.colorBitmap.PixelHeight),
this.colorPixels,//int[]
this.colorBitmap.PixelWidth * sizeof(int),
0);
// The input frame was processed successfully, increase the processed frame count
++this.processedFrameCount;
}
catch (InvalidOperationException ex)
{
this.statusBarText.Text = ex.Message;
}
finally
{
//表示该帧数据已经处理完毕，在SensorDepthFrameReady被赋值true，之后就达到这里
this.processingFrame = false;
}
}
/// <summary>
/// Reset the reconstruction to initial value
/// </summary>
/// 1.该函数在WindowLoaded中被调用了第一次初始化
///2.在 ProcessDepthData函数达到最大跟踪错误次数trackingErrorCount之后，则自动更新reconstruction
private void ResetReconstruction()
{
// Reset tracking error counter
this.trackingErrorCount = 0;
// Set the world-view transform to identity, so the world origin is the initial camera location.
this.worldToCameraTransform = Matrix4.Identity;
if (null != this.volume)
{
// Translate the reconstruction volume location away from the world origin by an amount equal
// to the minimum depth threshold. This ensures that some depth signal falls inside the volume.
// If set false, the default world origin is set to the center of the front face of the
// volume, which has the effect of locating the volume directly in front of the initial camera
// position with the +Z axis into the volume along the initial camera direction of view.
//this.translateResetPoseByMinDepthThreshold变量
//Setting this true in the constructor will move the volume forward along +Z away from the
// camera by the minimum depth threshold to enable capture of very small reconstruction volumes
// by setting a non-identity world-volume transformation in the ResetReconstruction call.
//如果为true，则将reconstruction cube 一直往远处延伸，以捕捉更小的体积，
if (this.translateResetPoseByMinDepthThreshold)
{
Matrix4 worldToVolumeTransform = this.defaultWorldToVolumeTransform;
// Translate the volume in the Z axis by the minDepthThreshold distance
float minDist = (this.minDepthClip < this.maxDepthClip) ? this.minDepthClip : this.maxDepthClip;
worldToVolumeTransform.M43 -= minDist * VoxelsPerMeter;
this.volume.ResetReconstruction(this.worldToCameraTransform, worldToVolumeTransform);
}
else
{
this.volume.ResetReconstruction(this.worldToCameraTransform);
}
}
if (null != this.fpsTimer)
{
// Reset the processed frame count and reset the FPS timer
this.fpsTimer.Stop();
this.processedFrameCount = 0;
this.fpsTimer.Start();
}
}
/// <summary>
/// Handles the user clicking on the reset reconstruction button
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void ButtonResetReconstructionClick(object sender, RoutedEventArgs e)
{
if (null == this.sensor)
{
this.statusBarText.Text = Properties.Resources.ConnectDeviceFirst;
return;
}
// reset the reconstruction and update the status text
this.ResetReconstruction();
this.statusBarText.Text = Properties.Resources.ResetReconstruction;
}
/// <summary>
/// Handles the checking or un-checking of the near mode combo box
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void CheckBoxNearModeChanged(object sender, RoutedEventArgs e)
{
if (this.sensor != null)
{
// will not function on non-Kinect for Windows devices
try
{
if (this.checkBoxNearMode.IsChecked.GetValueOrDefault())
{
this.sensor.DepthStream.Range = DepthRange.Near;
}
else
{
this.sensor.DepthStream.Range = DepthRange.Default;
}
}
catch (InvalidOperationException)
{
}
}
}
}
}