private void cb_sensor_SelectedIndexChanged(object sender, EventArgs e)
{
cb_videomode.Items.Clear();
if (cb_sensor.SelectedItem != null && currentDevice != null)
{
if (currentSensor != null && currentSensor.isValid) currentSensor.Stop();
switch ((string)(cb_sensor.SelectedItem))
{
case "Color":
currentSensor = currentDevice.CreateVideoStream(Device.SensorType.COLOR);
break;
case "Depth":
currentSensor = currentDevice.CreateVideoStream(Device.SensorType.DEPTH);
break;
case "IR":
currentSensor = currentDevice.CreateVideoStream(Device.SensorType.IR);
break;
default:
break;
}
VideoMode[] videoModes = currentSensor.SensorInfo.getSupportedVideoModes();
for (int i = 0; i < videoModes.Length; i++)
{
if (videoModes[i].DataPixelFormat == VideoMode.PixelFormat.GRAY16 ||
videoModes[i].DataPixelFormat == VideoMode.PixelFormat.GRAY8 ||
videoModes[i].DataPixelFormat == VideoMode.PixelFormat.RGB888 ||
videoModes[i].DataPixelFormat == VideoMode.PixelFormat.DEPTH_1MM)
cb_videomode.Items.Add(videoModes[i]);
}
}
}
public static OpenNI.Status convertDepthToColor(VideoStream depthStream, VideoStream colorStream,
int depthX, int depthY, UInt16 depthZ, out int pColorX, out int pColorY)
{
pColorX = 0;
pColorY = 0;
return CoordinateConverter_convertDepthToColor(depthStream.Handle, colorStream.Handle,
depthX, depthY, depthZ,ref pColorX, ref pColorY);
}
public static OpenNI.Status convertDepthToWorld(VideoStream depthStream,
float depthX, float depthY, float depthZ, out float pWorldX, out float pWorldY, out float pWorldZ)
{
pWorldX = 0;
pWorldY = 0;
pWorldZ = 0;
return CoordinateConverter_convertDepthToWorld_Float(depthStream.Handle,
depthX, depthY, depthZ, ref pWorldX, ref pWorldY, ref pWorldZ);
}
internal static VideoStream Private_Create(Device device, Device.SensorType sensorType)
{
IntPtr handle;
OpenNI.throwIfError(VideoStream_create(out handle, device.Handle, sensorType));
VideoStream vs = new VideoStream(handle);
vs.ParentDevice = device;
vs.handler_events = VideoStream_RegisterListener(handle, vs.internal_NewFrame);
return vs;
}
public static OpenNI.Status convertWorldToDepth(
VideoStream depthStream, float worldX, float worldY, float worldZ,
out int pDepthX, out int pDepthY, out UInt16 pDepthZ)
{
pDepthX = 0;
pDepthY = 0;
pDepthZ = 0;
return CoordinateConverter_convertWorldToDepth(depthStream.Handle,
worldX, worldY, worldZ, ref pDepthX, ref pDepthY, ref pDepthZ);
}
static void Main(string[] args)
{
OpenNI.Status status;
Console.WriteLine(OpenNI.Version.ToString());
status = OpenNI.Initialize();
if (!HandleError(status)) { Environment.Exit(0); }
OpenNI.onDeviceConnected += new OpenNI.DeviceConnectionStateChanged(OpenNI_onDeviceConnected);
OpenNI.onDeviceDisconnected += new OpenNI.DeviceConnectionStateChanged(OpenNI_onDeviceDisconnected);
DeviceInfo[] devices = OpenNI.EnumerateDevices();
if (devices.Length == 0)
return;
Device device;
using (device = Device.Open(null,"lr")) // lean init and no reset flags
{
VideoStream depth;
SensorInfo sensorInfo = device.getSensorInfo(Device.SensorType.DEPTH);
if (sensorInfo != null)
{
depth = VideoStream.Create(device, OpenNIWrapper.Device.SensorType.DEPTH);
}
if (device.hasSensor(Device.SensorType.DEPTH) &&
device.hasSensor(Device.SensorType.COLOR))
{
VideoStream depthStream = device.CreateVideoStream(Device.SensorType.DEPTH);
VideoStream colorStream = device.CreateVideoStream(Device.SensorType.COLOR);
if (depthStream.isValid && colorStream.isValid)
{
if (!HandleError(depthStream.Start())) { OpenNI.Shutdown(); return; }
if (!HandleError(colorStream.Start())) { OpenNI.Shutdown(); return; }
new System.Threading.Thread(new System.Threading.ThreadStart(DisplayInfo)).Start();
depthStream.onNewFrame += new VideoStream.VideoStreamNewFrame(depthStream_onNewFrame);
colorStream.onNewFrame += new VideoStream.VideoStreamNewFrame(colorStream_onNewFrame);
VideoStream[] array = new VideoStream[] { depthStream, colorStream };
while (!Console.KeyAvailable)
{
VideoStream aS;
if (OpenNI.WaitForAnyStream(array, out aS) == OpenNI.Status.OK)
{
if (aS.Equals(colorStream))
inlineColor++;
else
inlineDepth++;
aS.readFrame().Release();
}
}
}
}
Console.ReadLine();
}
OpenNI.Shutdown();
Environment.Exit(0);
}
public static void Main(string[] args)
{
try
{
OpenNI.Initialize();
device = Device.Open(Device.AnyDevice);
depthStream = device.CreateVideoStream(Device.SensorType.Depth);
depthStream.VideoMode = new VideoMode
{
DataPixelFormat = VideoMode.PixelFormat.Depth1Mm,
Fps = 30,
Resolution = new Size(640, 480)
};
colorStream = device.CreateVideoStream(Device.SensorType.Color);
colorStream.VideoMode = new VideoMode
{
DataPixelFormat = VideoMode.PixelFormat.Rgb888,
Fps = 30,
Resolution = new Size(640, 480)
};
device.DepthColorSyncEnabled = true;
depthStream.Start();
colorStream.Start();
device.ImageRegistration = Device.ImageRegistrationMode.DepthToColor;
Console.WriteLine("Image registration is active and working well.");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
if (device != null)
{
device.Close();
}
OpenNI.Shutdown();
}
public static OpenNI.Status ConvertDepthToColor(
VideoStream depthStream,
VideoStream colorStream,
int depthX,
int depthY,
ushort depthZ,
out int colorX,
out int colorY)
{
colorX = 0;
colorY = 0;
return CoordinateConverter_convertDepthToColor(
depthStream.Handle,
colorStream.Handle,
depthX,
depthY,
depthZ,
ref colorX,
ref colorY);
}
public KinectOpenNi2()
{
HandleError(OpenNI.Initialize());
DeviceInfo[] devices = OpenNI.EnumerateDevices();
if (devices.Length == 0)
HandleError(OpenNI.Status.NO_DEVICE);
kinectDevice = devices[0].OpenDevice();
colorSensor = kinectDevice.CreateVideoStream(Device.SensorType.COLOR);
VideoMode[] videoModes = colorSensor.SensorInfo.getSupportedVideoModes();
colorSensor.VideoMode = videoModes[1];
colorSensor.Start();
colorSensor.onNewFrame += new VideoStream.VideoStreamNewFrame(colorSensor_onNewFrame);
depthSensor = kinectDevice.CreateVideoStream(Device.SensorType.DEPTH);
videoModes = depthSensor.SensorInfo.getSupportedVideoModes();
depthSensor.VideoMode = videoModes[0];
depthSensor.Start();
depthSensor.onNewFrame += new VideoStream.VideoStreamNewFrame(depthSensor_onNewFrame);
}
public OpenKinect()
{
HandleOpenNIError(OpenNI.Initialize());
DeviceInfo[] devices = OpenNI.EnumerateDevices();
if (devices.Length == 0)
HandleOpenNIError(OpenNI.Status.NoDevice);
kinectDevice = devices[0].OpenDevice();
colorSensor = kinectDevice.CreateVideoStream(Device.SensorType.Color);
colorSensor.VideoMode = colorSensor.SensorInfo.GetSupportedVideoModes()[1];
//Start Skeleton Sensor
HandleNiteError(NiTE.Initialize());
try
{
SkeletonSensor = UserTracker.Create();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void colorStream_onNewFrame(VideoStream vStream)
{
if (vStream.isValid && vStream.isFrameAvailable())
{
using (VideoFrameRef frame = vStream.readFrame())
{
if (frame.isValid)
{
if (this.colorBitmap == null)
{
this.colorBitmap = new Bitmap(1, 1);
}
lock (this.colorBitmap)
{
try
{
frame.updateBitmap(this.colorBitmap, VideoFrameRef.copyBitmapOptions.Force24BitRGB);
}
catch (Exception)
{
this.colorBitmap = frame.toBitmap(VideoFrameRef.copyBitmapOptions.Force24BitRGB);
}
}
this.BeginInvoke(
(Action)delegate
{
lock (this.colorBitmap)
{
if (this.p_image.Image != null)
{
this.p_image.Image.Dispose();
}
this.p_image.Image = new Bitmap(this.colorBitmap);
this.p_image.Refresh();
}
});
}
}
}
}
void Stop(bool isApply)
{
bool isSameDevice = isApply && currentDevice != null && currentDevice.isValid && currentDevice.DeviceInfo.URI == NiUI.Properties.Settings.Default.DeviceURI;
bool isSameSensor = isApply && isSameDevice && currentSensor != null && currentSensor.isValid && currentSensor.SensorInfo.getSensorType() == (Device.SensorType)NiUI.Properties.Settings.Default.CameraType;
if (!isSameSensor)
{
if (currentSensor != null && currentSensor.isValid)
{
currentSensor.Stop();
currentSensor.onNewFrame -= currentSensor_onNewFrame;
}
currentSensor = null;
}
if (!isSameDevice)
{
//if (uTracker != null && uTracker.isValid)
// uTracker.Destroy();
//if (hTracker != null && hTracker.isValid)
// hTracker.Destroy();
if (currentDevice != null && currentDevice.isValid)
currentDevice.Close();
//hTracker = null;
//uTracker = null;
currentDevice = null;
}
isIdle = true;
btn_stopstart.Text = "Start Streaming";
if (!isApply)
{
broadcaster.ClearScreen();
pb_image.Image = null;
pb_image.Refresh();
}
if (NiUI.Properties.Settings.Default.AutoNotification)
notify.Visible = false;
}
public int getNumberOfFrames(VideoStream stream)
{
return PlaybackControl_getNumberOfFrames(this.Handle, stream.Handle);
}
public OpenNI.Status seek(VideoStream stream, int frameIndex)
{
return PlaybackControl_seek(this.Handle, stream.Handle, frameIndex);
}
private void CbSensorSelectedIndexChanged(object sender, EventArgs e)
{
this.cb_videomode.Items.Clear();
if (this.cb_sensor.SelectedItem != null && this.currentDevice != null)
{
if (this.currentSensor != null && this.currentSensor.IsValid)
{
this.currentSensor.Stop();
}
switch ((string)this.cb_sensor.SelectedItem)
{
case "Color":
this.currentSensor = this.currentDevice.CreateVideoStream(Device.SensorType.Color);
break;
case "Depth":
this.currentSensor = this.currentDevice.CreateVideoStream(Device.SensorType.Depth);
break;
case "IR":
this.currentSensor = this.currentDevice.CreateVideoStream(Device.SensorType.Ir);
break;
}
if (this.currentSensor != null)
{
IEnumerable<VideoMode> videoModes = this.currentSensor.SensorInfo.GetSupportedVideoModes();
foreach (VideoMode mode in videoModes)
{
if (mode.DataPixelFormat == VideoMode.PixelFormat.Gray16
|| mode.DataPixelFormat == VideoMode.PixelFormat.Gray8
|| mode.DataPixelFormat == VideoMode.PixelFormat.Rgb888
|| mode.DataPixelFormat == VideoMode.PixelFormat.Depth1Mm)
{
this.cb_videomode.Items.Add(mode);
}
}
}
}
}
public int GetNumberOfFrames(VideoStream stream)
{
return(PlaybackControl_getNumberOfFrames(this.Handle, stream.Handle));
}
public static Status WaitForStream(VideoStream streams, int timeout = TimeoutForever)
{
VideoStream vs;
Status returnValue = WaitForAnyStream(new[] { streams }, out vs, timeout);
if (returnValue == Status.Ok && !vs.Equals(streams))
{
return Status.Error;
}
return returnValue;
}
public OpenNI.Status Attach(VideoStream stream, bool allowLossyCompression = false)
{
return Recorder_attach(this.Handle, stream.Handle, allowLossyCompression);
}
private static void DepthStreamOnNewFrame(VideoStream videoStream)
{
eventDepth++;
}
void depthSensor_onNewFrame(VideoStream vStream)
{
if (!vStream.isValid || !vStream.isFrameAvailable())
return;
VideoFrameRef frame = vStream.readFrame();
if (!frame.isValid)
return;
lock (depthMutex)
{
depthFrame = frame;
}
}
void colorSensor_onNewFrame(VideoStream vStream)
{
if (!vStream.isValid || !vStream.isFrameAvailable())
return;
VideoFrameRef frame = vStream.readFrame();
if (!frame.isValid)
return;
lock (colorMutex)
{
colorFrame = frame;
}
}
public static OpenNI.Status ConvertWorldToDepth(
VideoStream depthStream,
float worldX,
float worldY,
float worldZ,
out float depthX,
out float depthY,
out float depthZ)
{
depthX = 0;
depthY = 0;
depthZ = 0;
return CoordinateConverter_convertWorldToDepth_Float(
depthStream.Handle,
worldX,
worldY,
worldZ,
ref depthX,
ref depthY,
ref depthZ);
}
private void depthStream_onNewFrame(VideoStream vStream)
{
if (vStream.isValid && vStream.isFrameAvailable())
{
using (VideoFrameRef frame = vStream.readFrame())
{
if (frame.isValid)
{
if (this.depthBitmap == null)
{
this.depthBitmap = new Bitmap(1, 1);
}
lock (this.depthBitmap)
{
try
{
frame.updateBitmap(
this.depthBitmap,
VideoFrameRef.copyBitmapOptions.Force24BitRGB
| VideoFrameRef.copyBitmapOptions.DepthInvert
| VideoFrameRef.copyBitmapOptions.DepthFillShadow
| VideoFrameRef.copyBitmapOptions.DepthHistogramEqualize
| VideoFrameRef.copyBitmapOptions.DepthFillRigthBlack);
}
catch (Exception)
{
this.depthBitmap =
frame.toBitmap(
VideoFrameRef.copyBitmapOptions.Force24BitRGB
| VideoFrameRef.copyBitmapOptions.DepthInvert
| VideoFrameRef.copyBitmapOptions.DepthFillShadow
| VideoFrameRef.copyBitmapOptions.DepthHistogramEqualize
| VideoFrameRef.copyBitmapOptions.DepthFillRigthBlack);
}
}
this.BeginInvoke(
(Action)delegate
{
lock (this.depthBitmap)
{
if (this.p_depth.Image != null)
{
this.p_depth.Image.Dispose();
}
this.p_depth.Image = new Bitmap(this.depthBitmap);
this.p_depth.Refresh();
}
});
}
}
}
}
//private Bitmap DepthFix(Bitmap depthBitmap)
//{
// Bitmap x = new Bitmap(640, 480);
// Graphics g = Graphics.FromImage(x);
// g.DrawImage(depthBitmap, new Rectangle(30, 8, 600, 450));
// g.Flush();
// g.Dispose();
// return x;
//}
private void DeviceChanged()
{
this.but_anag.Enabled = false;
this.but_stereo.Enabled = false;
this.but_saveall.Enabled = false;
if (this.selectedDevice != null)
{
this.selectedDevice.Close();
}
if (this.cb_devices.Items.Count < 1)
{
this.selectedDevice = null;
return;
}
if (this.cb_devices.SelectedItem == null)
{
this.selectedDevice = null;
return;
}
if (this.cb_devices.SelectedItem is string && this.cb_devices.SelectedItem.ToString() == "None")
{
this.selectedDevice = null;
return;
}
if (!(this.cb_devices.SelectedItem is DeviceInfo))
{
this.selectedDevice = null;
MessageBox.Show(
"Selected item is not a device.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
try
{
this.selectedDevice = (this.cb_devices.SelectedItem as DeviceInfo).OpenDevice();
}
catch (Exception)
{
this.selectedDevice = null;
MessageBox.Show(
"Can not open selected device.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
if (!this.selectedDevice.hasSensor(Device.SensorType.COLOR))
{
this.selectedDevice.Close();
this.selectedDevice = null;
MessageBox.Show(
"Selected device can not offer depth stream.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
if (!this.selectedDevice.hasSensor(Device.SensorType.DEPTH))
{
this.selectedDevice.Close();
this.selectedDevice = null;
MessageBox.Show(
"Selected device can not offer depth stream.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
try
{
this.depthStream = this.selectedDevice.CreateVideoStream(Device.SensorType.DEPTH);
this.colorStream = this.selectedDevice.CreateVideoStream(Device.SensorType.COLOR);
}
catch (Exception)
{
this.selectedDevice.Close();
this.selectedDevice = null;
this.depthStream = null;
this.colorStream = null;
MessageBox.Show(
"Can not create Depth and Color streams.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
this.cb_hd.Enabled = false;
foreach (VideoMode vm in this.colorStream.SensorInfo.getSupportedVideoModes())
{
if (vm.Resolution.Equals(new Size(1280, 1024)) || vm.Resolution.Equals(new Size(1280, 960)))
{
this.cb_hd.Enabled = true;
this.isUse960asHD = vm.Resolution.Height == 960;
break;
}
}
VideoMode depthMode = new VideoMode
{
Resolution = new Size(640, 480),
FPS = 30,
DataPixelFormat = VideoMode.PixelFormat.DEPTH_1MM
};
VideoMode colorMode = new VideoMode
{
Resolution = new Size(640, 480),
FPS = 30,
DataPixelFormat = VideoMode.PixelFormat.RGB888
};
if (this.cb_hd.Enabled && this.cb_hd.Checked)
{
colorMode.Resolution = this.isUse960asHD ? new Size(1280, 960) : new Size(1280, 1024);
}
try
{
this.depthStream.VideoMode = depthMode;
this.colorStream.VideoMode = colorMode;
}
catch (Exception)
{
this.selectedDevice.Close();
this.selectedDevice = null;
this.depthStream = null;
this.colorStream = null;
MessageBox.Show(
"Can not set Depth and Color streams video mode to 640x480@30fps. This application need at least this resolution.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
try
{
this.selectedDevice.ImageRegistration = Device.ImageRegistrationMode.DEPTH_TO_COLOR;
}
catch (Exception)
{
MessageBox.Show(
"We failed to register image over depth map.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
try
{
// this.selectedDevice.DepthColorSyncEnabled = true;
}
catch (Exception)
{
}
if (!this.HandleError(this.depthStream.Start()) || !this.HandleError(this.colorStream.Start()))
{
this.selectedDevice.Close();
this.selectedDevice = null;
this.depthStream = null;
this.colorStream = null;
MessageBox.Show(
"Can not start depth and color streams.",
"Device Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
this.depthStream.onNewFrame += this.depthStream_onNewFrame;
this.colorStream.onNewFrame += this.colorStream_onNewFrame;
this.but_anag.Enabled = true;
this.but_stereo.Enabled = true;
this.but_saveall.Enabled = true;
}
void currentSensor_onNewFrame(VideoStream vStream)
{
if (vStream.isValid && vStream.isFrameAvailable())
{
using (VideoFrameRef frame = vStream.readFrame())
{
if (frame.isValid)
{
VideoFrameRef.copyBitmapOptions options = VideoFrameRef.copyBitmapOptions.Force24BitRGB | VideoFrameRef.copyBitmapOptions.DepthFillShadow;
if (cb_invert.Checked)
options |= VideoFrameRef.copyBitmapOptions.DepthInvert;
if (cb_equal.Checked)
options |= VideoFrameRef.copyBitmapOptions.DepthHistogramEqualize;
if (cb_fill.Checked)
options |= (vStream.Mirroring) ? VideoFrameRef.copyBitmapOptions.DepthFillRigthBlack : VideoFrameRef.copyBitmapOptions.DepthFillLeftBlack;
lock (bitmap)
{
try
{
frame.updateBitmap(bitmap, options);
}
catch (Exception)
{
bitmap = frame.toBitmap(options);
}
}
this.BeginInvoke(new MethodInvoker(delegate()
{
lock (bitmap)
{
if (pb_image.Image != null)
pb_image.Image.Dispose();
pb_image.Image = new Bitmap(bitmap, pb_image.Size);
pb_image.Refresh();
}
}));
}
}
}
}
public OpenNI.Status Seek(VideoStream stream, int frameIndex)
{
return(PlaybackControl_seek(this.Handle, stream.Handle, frameIndex));
}
private static void ColorStreamOnNewFrame(VideoStream videoStream)
{
eventColor++;
}
private void CurrentSensorOnNewFrame(VideoStream videoStream)
{
if (videoStream.IsValid && videoStream.IsFrameAvailable())
{
using (VideoFrameRef frame = videoStream.ReadFrame())
{
if (frame.IsValid)
{
VideoFrameRef.CopyBitmapOptions options = VideoFrameRef.CopyBitmapOptions.Force24BitRgb
| VideoFrameRef.CopyBitmapOptions.DepthFillShadow;
if (this.cb_invert.Checked)
{
options |= VideoFrameRef.CopyBitmapOptions.DepthInvert;
}
if (this.cb_equal.Checked)
{
options |= VideoFrameRef.CopyBitmapOptions.DepthHistogramEqualize;
}
if (this.cb_fill.Checked)
{
options |= videoStream.Mirroring
? VideoFrameRef.CopyBitmapOptions.DepthFillRigthBlack
: VideoFrameRef.CopyBitmapOptions.DepthFillLeftBlack;
}
lock (this.bitmap)
{
/////////////////////// Instead of creating a bitmap object for each frame, you can simply
/////////////////////// update one you have. Please note that you must be very careful
/////////////////////// with multi-thread situations.
try
{
frame.UpdateBitmap(this.bitmap, options);
}
catch (Exception)
{
// Happens when our Bitmap object is not compatible with returned Frame
this.bitmap = frame.ToBitmap(options);
}
/////////////////////// END NOTE
/////////////////////// You can always use .toBitmap() if you dont want to
/////////////////////// clone image later and be safe when using it in multi-thread situations
/////////////////////// This is little slower, but easier to handle
// bitmap = frame.toBitmap(options);
/////////////////////// END NOTE
if (this.cb_mirrorSoft.Checked)
{
this.bitmap.RotateFlip(RotateFlipType.RotateNoneFlipX);
}
}
///////////////////// You can simply pass the newly created/updated image to a
///////////////////// PictureBox right here instead of drawing it with Graphic object
// this.BeginInvoke(new MethodInvoker(delegate()
// {
// if (!pb_image.Visible)
// pb_image.Visible = true;
// if (bitmap == null)
// return;
// lock (bitmap) // this.BeginInvoke happens on UI Thread so it is better to always keep this lock in place
// {
// if (pb_image.Image != null)
// pb_image.Image.Dispose();
// /////////////////////// If you want to use one bitmap object for all frames, the
// /////////////////////// best way to prevent and multi-thread access problems
// /////////////////////// is to clone the bitmap each time you want to send it to PictureBox
// pb_image.Image = new Bitmap(bitmap, bitmap.Size);
// /////////////////////// END NOTE
// /////////////////////// If you only use toBitmap() method. you can simply skip the
// /////////////////////// cloning process. It is perfectly thread-safe.
// //pb_image.Image = bitmap;
// /////////////////////// END NOTE
// pb_image.Refresh();
// }
// }));
///////////////////// END NOTE
if (!this.pb_image.Visible)
{
this.Invalidate();
}
}
}
}
}
public static OpenNI.Status ConvertDepthToWorld(
VideoStream depthStream,
int depthX,
int depthY,
ushort depthZ,
out float worldX,
out float worldY,
out float worldZ)
{
worldX = 0;
worldY = 0;
worldZ = 0;
return CoordinateConverter_convertDepthToWorld(
depthStream.Handle,
depthX,
depthY,
depthZ,
ref worldX,
ref worldY,
ref worldZ);
}
public static Status WaitForAnyStream(
VideoStream[] streams,
out VideoStream readyStream,
int timeout = TimeoutForever)
{
readyStream = null;
IntPtr[] streamArray = new IntPtr[streams.Length];
int i = 0;
foreach (VideoStream vs in streams)
{
streamArray[i] = vs.Handle;
i++;
}
int selectedId = -1;
Status returnValue;
IntPtr arrayPointer = Marshal.AllocHGlobal(IntPtr.Size * streamArray.Length);
try
{
Marshal.Copy(streamArray, 0, arrayPointer, streamArray.Length);
returnValue = OpenNI_waitForAnyStream(arrayPointer, streamArray.Length, ref selectedId, timeout);
}
finally
{
Marshal.FreeHGlobal(arrayPointer);
}
if (returnValue == Status.Ok)
{
foreach (VideoStream vs in streams)
{
if (vs.Equals(streamArray[selectedId]))
{
readyStream = vs;
}
}
}
return returnValue;
}
public static Status WaitForAnyStream(VideoStream[] pStreams, out VideoStream pReadyStream, int timeout = OpenNI.TIMEOUT_FOREVER)
{
pReadyStream = null;
IntPtr[] pStreamArray = new IntPtr[pStreams.Length];
int i = 0;
foreach (VideoStream vs in pStreams)
{
pStreamArray[i] = vs.Handle;
i++;
}
int selectedId = -1;
Status ret = Status.ERROR;
IntPtr arrayPointer = Marshal.AllocHGlobal(IntPtr.Size * pStreamArray.Length);
try
{
Marshal.Copy(pStreamArray, 0, arrayPointer, pStreamArray.Length);
ret = OpenNI_waitForAnyStream(arrayPointer, pStreamArray.Length, ref selectedId, timeout);
}
finally
{
Marshal.FreeHGlobal(arrayPointer);
}
if (ret == Status.OK)
foreach (VideoStream vs in pStreams)
if (vs.Equals(pStreamArray[selectedId]))
pReadyStream = vs;
return ret;
}
public OpenNI.Status Attach(VideoStream stream, bool allowLossyCompression = false)
{
return(Recorder_attach(this.Handle, stream.Handle, allowLossyCompression));
}
public static Status WaitForStream(VideoStream pStreams, int timeout = OpenNI.TIMEOUT_FOREVER)
{
VideoStream vs;
Status ret = WaitForAnyStream(new VideoStream[] { pStreams }, out vs, timeout);
if (ret == Status.OK && !vs.Equals(pStreams))
return Status.ERROR;
return ret;
}
